1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015-2020 Intel Corporation
7 #include <rte_common.h>
8 #include <rte_hexdump.h>
10 #include <rte_malloc.h>
11 #include <rte_memcpy.h>
12 #include <rte_pause.h>
13 #include <rte_bus_vdev.h>
14 #include <rte_ether.h>
16 #include <rte_crypto.h>
17 #include <rte_cryptodev.h>
18 #include <rte_cryptodev_pmd.h>
19 #include <rte_string_fns.h>
21 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
22 #include <rte_cryptodev_scheduler.h>
23 #include <rte_cryptodev_scheduler_operations.h>
26 #include <rte_lcore.h>
29 #include "test_cryptodev.h"
31 #include "test_cryptodev_blockcipher.h"
32 #include "test_cryptodev_aes_test_vectors.h"
33 #include "test_cryptodev_des_test_vectors.h"
34 #include "test_cryptodev_hash_test_vectors.h"
35 #include "test_cryptodev_kasumi_test_vectors.h"
36 #include "test_cryptodev_kasumi_hash_test_vectors.h"
37 #include "test_cryptodev_snow3g_test_vectors.h"
38 #include "test_cryptodev_snow3g_hash_test_vectors.h"
39 #include "test_cryptodev_zuc_test_vectors.h"
40 #include "test_cryptodev_aead_test_vectors.h"
41 #include "test_cryptodev_hmac_test_vectors.h"
42 #include "test_cryptodev_mixed_test_vectors.h"
43 #ifdef RTE_LIBRTE_SECURITY
44 #include "test_cryptodev_security_pdcp_test_vectors.h"
45 #include "test_cryptodev_security_pdcp_test_func.h"
46 #include "test_cryptodev_security_docsis_test_vectors.h"
49 #define VDEV_ARGS_SIZE 100
50 #define MAX_NB_SESSIONS 4
53 #define OUT_OF_PLACE 1
55 static int gbl_driver_id;
57 static enum rte_security_session_action_type gbl_action_type =
58 RTE_SECURITY_ACTION_TYPE_NONE;
60 struct crypto_testsuite_params {
61 struct rte_mempool *mbuf_pool;
62 struct rte_mempool *large_mbuf_pool;
63 struct rte_mempool *op_mpool;
64 struct rte_mempool *session_mpool;
65 struct rte_mempool *session_priv_mpool;
66 struct rte_cryptodev_config conf;
67 struct rte_cryptodev_qp_conf qp_conf;
69 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
70 uint8_t valid_dev_count;
73 struct crypto_unittest_params {
74 struct rte_crypto_sym_xform cipher_xform;
75 struct rte_crypto_sym_xform auth_xform;
76 struct rte_crypto_sym_xform aead_xform;
77 #ifdef RTE_LIBRTE_SECURITY
78 struct rte_security_docsis_xform docsis_xform;
82 struct rte_cryptodev_sym_session *sess;
83 #ifdef RTE_LIBRTE_SECURITY
84 struct rte_security_session *sec_session;
87 #ifdef RTE_LIBRTE_SECURITY
88 enum rte_security_session_action_type type;
90 struct rte_crypto_op *op;
92 struct rte_mbuf *obuf, *ibuf;
97 #define ALIGN_POW2_ROUNDUP(num, align) \
98 (((num) + (align) - 1) & ~((align) - 1))
101 * Forward declarations.
104 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
105 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
109 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
110 struct crypto_unittest_params *ut_params,
111 struct crypto_testsuite_params *ts_param,
112 const uint8_t *cipher,
113 const uint8_t *digest,
116 static struct rte_mbuf *
117 setup_test_string(struct rte_mempool *mpool,
118 const char *string, size_t len, uint8_t blocksize)
120 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
121 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
123 memset(m->buf_addr, 0, m->buf_len);
125 char *dst = rte_pktmbuf_append(m, t_len);
132 rte_memcpy(dst, string, t_len);
134 memset(dst, 0, t_len);
140 /* Get number of bytes in X bits (rounding up) */
142 ceil_byte_length(uint32_t num_bits)
145 return ((num_bits >> 3) + 1);
147 return (num_bits >> 3);
151 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
155 struct rte_crypto_sym_op *sop;
156 union rte_crypto_sym_ofs ofs;
157 struct rte_crypto_sgl sgl;
158 struct rte_crypto_sym_vec symvec;
159 struct rte_crypto_vec vec[UINT8_MAX];
163 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
164 sop->aead.data.length, vec, RTE_DIM(vec));
166 if (n < 0 || n != sop->m_src->nb_segs) {
167 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
174 iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
176 symvec.aad = (void **)&sop->aead.aad.data;
177 symvec.digest = (void **)&sop->aead.digest.data;
183 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
187 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
189 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
193 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
197 struct rte_crypto_sym_op *sop;
198 union rte_crypto_sym_ofs ofs;
199 struct rte_crypto_sgl sgl;
200 struct rte_crypto_sym_vec symvec;
201 struct rte_crypto_vec vec[UINT8_MAX];
205 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
206 sop->auth.data.length, vec, RTE_DIM(vec));
208 if (n < 0 || n != sop->m_src->nb_segs) {
209 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
216 iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
218 symvec.aad = (void **)&sop->aead.aad.data;
219 symvec.digest = (void **)&sop->auth.digest.data;
224 ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
225 ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
226 (sop->cipher.data.offset + sop->cipher.data.length);
228 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
232 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
234 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
237 static struct rte_crypto_op *
238 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
241 RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
243 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
244 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
250 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
253 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
254 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
261 static struct crypto_testsuite_params testsuite_params = { NULL };
262 static struct crypto_unittest_params unittest_params;
265 testsuite_setup(void)
267 struct crypto_testsuite_params *ts_params = &testsuite_params;
268 struct rte_cryptodev_info info;
269 uint32_t i = 0, nb_devs, dev_id;
273 memset(ts_params, 0, sizeof(*ts_params));
275 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
276 if (ts_params->mbuf_pool == NULL) {
277 /* Not already created so create */
278 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
280 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
282 if (ts_params->mbuf_pool == NULL) {
283 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
288 ts_params->large_mbuf_pool = rte_mempool_lookup(
289 "CRYPTO_LARGE_MBUFPOOL");
290 if (ts_params->large_mbuf_pool == NULL) {
291 /* Not already created so create */
292 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
293 "CRYPTO_LARGE_MBUFPOOL",
296 if (ts_params->large_mbuf_pool == NULL) {
298 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
303 ts_params->op_mpool = rte_crypto_op_pool_create(
304 "MBUF_CRYPTO_SYM_OP_POOL",
305 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
306 NUM_MBUFS, MBUF_CACHE_SIZE,
308 sizeof(struct rte_crypto_sym_xform) +
311 if (ts_params->op_mpool == NULL) {
312 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
316 /* Create an AESNI MB device if required */
317 if (gbl_driver_id == rte_cryptodev_driver_id_get(
318 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
319 nb_devs = rte_cryptodev_device_count_by_driver(
320 rte_cryptodev_driver_id_get(
321 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
324 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
326 TEST_ASSERT(ret == 0,
327 "Failed to create instance of"
329 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
333 /* Create an AESNI GCM device if required */
334 if (gbl_driver_id == rte_cryptodev_driver_id_get(
335 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
336 nb_devs = rte_cryptodev_device_count_by_driver(
337 rte_cryptodev_driver_id_get(
338 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
340 TEST_ASSERT_SUCCESS(rte_vdev_init(
341 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
342 "Failed to create instance of"
344 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
348 /* Create a SNOW 3G device if required */
349 if (gbl_driver_id == rte_cryptodev_driver_id_get(
350 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
351 nb_devs = rte_cryptodev_device_count_by_driver(
352 rte_cryptodev_driver_id_get(
353 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
355 TEST_ASSERT_SUCCESS(rte_vdev_init(
356 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
357 "Failed to create instance of"
359 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
363 /* Create a KASUMI device if required */
364 if (gbl_driver_id == rte_cryptodev_driver_id_get(
365 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
366 nb_devs = rte_cryptodev_device_count_by_driver(
367 rte_cryptodev_driver_id_get(
368 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
370 TEST_ASSERT_SUCCESS(rte_vdev_init(
371 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
372 "Failed to create instance of"
374 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
378 /* Create a ZUC device if required */
379 if (gbl_driver_id == rte_cryptodev_driver_id_get(
380 RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
381 nb_devs = rte_cryptodev_device_count_by_driver(
382 rte_cryptodev_driver_id_get(
383 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
385 TEST_ASSERT_SUCCESS(rte_vdev_init(
386 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
387 "Failed to create instance of"
389 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
393 /* Create a NULL device if required */
394 if (gbl_driver_id == rte_cryptodev_driver_id_get(
395 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
396 nb_devs = rte_cryptodev_device_count_by_driver(
397 rte_cryptodev_driver_id_get(
398 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
401 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
403 TEST_ASSERT(ret == 0,
404 "Failed to create instance of"
406 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
410 /* Create an OPENSSL device if required */
411 if (gbl_driver_id == rte_cryptodev_driver_id_get(
412 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
413 nb_devs = rte_cryptodev_device_count_by_driver(
414 rte_cryptodev_driver_id_get(
415 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
418 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
421 TEST_ASSERT(ret == 0, "Failed to create "
422 "instance of pmd : %s",
423 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
427 /* Create a ARMv8 device if required */
428 if (gbl_driver_id == rte_cryptodev_driver_id_get(
429 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
430 nb_devs = rte_cryptodev_device_count_by_driver(
431 rte_cryptodev_driver_id_get(
432 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
435 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
438 TEST_ASSERT(ret == 0, "Failed to create "
439 "instance of pmd : %s",
440 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
444 /* Create a MVSAM device if required */
445 if (gbl_driver_id == rte_cryptodev_driver_id_get(
446 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
447 nb_devs = rte_cryptodev_device_count_by_driver(
448 rte_cryptodev_driver_id_get(
449 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
452 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
455 TEST_ASSERT(ret == 0, "Failed to create "
456 "instance of pmd : %s",
457 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
461 /* Create an CCP device if required */
462 if (gbl_driver_id == rte_cryptodev_driver_id_get(
463 RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
464 nb_devs = rte_cryptodev_device_count_by_driver(
465 rte_cryptodev_driver_id_get(
466 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
469 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
472 TEST_ASSERT(ret == 0, "Failed to create "
473 "instance of pmd : %s",
474 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
478 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
479 char vdev_args[VDEV_ARGS_SIZE] = {""};
480 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
481 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
482 uint16_t slave_core_count = 0;
483 uint16_t socket_id = 0;
485 if (gbl_driver_id == rte_cryptodev_driver_id_get(
486 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
488 /* Identify the Slave Cores
489 * Use 2 slave cores for the device args
491 RTE_LCORE_FOREACH_SLAVE(i) {
492 if (slave_core_count > 1)
494 snprintf(vdev_args, sizeof(vdev_args),
495 "%s%d", temp_str, i);
496 strcpy(temp_str, vdev_args);
497 strlcat(temp_str, ";", sizeof(temp_str));
499 socket_id = rte_lcore_to_socket_id(i);
501 if (slave_core_count != 2) {
503 "Cryptodev scheduler test require at least "
504 "two slave cores to run. "
505 "Please use the correct coremask.\n");
508 strcpy(temp_str, vdev_args);
509 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
510 temp_str, socket_id);
511 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
512 nb_devs = rte_cryptodev_device_count_by_driver(
513 rte_cryptodev_driver_id_get(
514 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
517 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
519 TEST_ASSERT(ret == 0,
520 "Failed to create instance %u of"
522 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
525 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
527 nb_devs = rte_cryptodev_count();
529 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
533 /* Create list of valid crypto devs */
534 for (i = 0; i < nb_devs; i++) {
535 rte_cryptodev_info_get(i, &info);
536 if (info.driver_id == gbl_driver_id)
537 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
540 if (ts_params->valid_dev_count < 1)
543 /* Set up all the qps on the first of the valid devices found */
545 dev_id = ts_params->valid_devs[0];
547 rte_cryptodev_info_get(dev_id, &info);
549 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
550 ts_params->conf.socket_id = SOCKET_ID_ANY;
551 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
553 unsigned int session_size =
554 rte_cryptodev_sym_get_private_session_size(dev_id);
557 * Create mempool with maximum number of sessions * 2,
558 * to include the session headers
560 if (info.sym.max_nb_sessions != 0 &&
561 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
562 RTE_LOG(ERR, USER1, "Device does not support "
563 "at least %u sessions\n",
568 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
569 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
571 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
572 "session mempool allocation failed");
574 ts_params->session_priv_mpool = rte_mempool_create(
578 0, 0, NULL, NULL, NULL,
581 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
582 "session mempool allocation failed");
586 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
588 "Failed to configure cryptodev %u with %u qps",
589 dev_id, ts_params->conf.nb_queue_pairs);
591 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
592 ts_params->qp_conf.mp_session = ts_params->session_mpool;
593 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
595 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
596 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
597 dev_id, qp_id, &ts_params->qp_conf,
598 rte_cryptodev_socket_id(dev_id)),
599 "Failed to setup queue pair %u on cryptodev %u",
607 testsuite_teardown(void)
609 struct crypto_testsuite_params *ts_params = &testsuite_params;
611 if (ts_params->mbuf_pool != NULL) {
612 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
613 rte_mempool_avail_count(ts_params->mbuf_pool));
616 if (ts_params->op_mpool != NULL) {
617 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
618 rte_mempool_avail_count(ts_params->op_mpool));
621 /* Free session mempools */
622 if (ts_params->session_priv_mpool != NULL) {
623 rte_mempool_free(ts_params->session_priv_mpool);
624 ts_params->session_priv_mpool = NULL;
627 if (ts_params->session_mpool != NULL) {
628 rte_mempool_free(ts_params->session_mpool);
629 ts_params->session_mpool = NULL;
636 struct crypto_testsuite_params *ts_params = &testsuite_params;
637 struct crypto_unittest_params *ut_params = &unittest_params;
641 /* Clear unit test parameters before running test */
642 memset(ut_params, 0, sizeof(*ut_params));
644 /* Reconfigure device to default parameters */
645 ts_params->conf.socket_id = SOCKET_ID_ANY;
646 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
647 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
648 ts_params->qp_conf.mp_session = ts_params->session_mpool;
649 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
651 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
653 "Failed to configure cryptodev %u",
654 ts_params->valid_devs[0]);
656 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
657 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
658 ts_params->valid_devs[0], qp_id,
660 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
661 "Failed to setup queue pair %u on cryptodev %u",
662 qp_id, ts_params->valid_devs[0]);
666 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
668 /* Start the device */
669 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
670 "Failed to start cryptodev %u",
671 ts_params->valid_devs[0]);
679 struct crypto_testsuite_params *ts_params = &testsuite_params;
680 struct crypto_unittest_params *ut_params = &unittest_params;
681 struct rte_cryptodev_stats stats;
683 /* free crypto session structure */
684 #ifdef RTE_LIBRTE_SECURITY
685 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
686 if (ut_params->sec_session) {
687 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
688 (ts_params->valid_devs[0]),
689 ut_params->sec_session);
690 ut_params->sec_session = NULL;
695 if (ut_params->sess) {
696 rte_cryptodev_sym_session_clear(
697 ts_params->valid_devs[0],
699 rte_cryptodev_sym_session_free(ut_params->sess);
700 ut_params->sess = NULL;
704 /* free crypto operation structure */
706 rte_crypto_op_free(ut_params->op);
709 * free mbuf - both obuf and ibuf are usually the same,
710 * so check if they point at the same address is necessary,
711 * to avoid freeing the mbuf twice.
713 if (ut_params->obuf) {
714 rte_pktmbuf_free(ut_params->obuf);
715 if (ut_params->ibuf == ut_params->obuf)
719 if (ut_params->ibuf) {
720 rte_pktmbuf_free(ut_params->ibuf);
724 if (ts_params->mbuf_pool != NULL)
725 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
726 rte_mempool_avail_count(ts_params->mbuf_pool));
728 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
730 /* Stop the device */
731 rte_cryptodev_stop(ts_params->valid_devs[0]);
735 test_device_configure_invalid_dev_id(void)
737 struct crypto_testsuite_params *ts_params = &testsuite_params;
738 uint16_t dev_id, num_devs = 0;
740 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
741 "Need at least %d devices for test", 1);
743 /* valid dev_id values */
744 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
746 /* Stop the device in case it's started so it can be configured */
747 rte_cryptodev_stop(dev_id);
749 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
750 "Failed test for rte_cryptodev_configure: "
751 "invalid dev_num %u", dev_id);
753 /* invalid dev_id values */
756 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
757 "Failed test for rte_cryptodev_configure: "
758 "invalid dev_num %u", dev_id);
762 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
763 "Failed test for rte_cryptodev_configure:"
764 "invalid dev_num %u", dev_id);
770 test_device_configure_invalid_queue_pair_ids(void)
772 struct crypto_testsuite_params *ts_params = &testsuite_params;
773 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
775 /* Stop the device in case it's started so it can be configured */
776 rte_cryptodev_stop(ts_params->valid_devs[0]);
778 /* valid - max value queue pairs */
779 ts_params->conf.nb_queue_pairs = orig_nb_qps;
781 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
783 "Failed to configure cryptodev: dev_id %u, qp_id %u",
784 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
786 /* valid - one queue pairs */
787 ts_params->conf.nb_queue_pairs = 1;
789 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
791 "Failed to configure cryptodev: dev_id %u, qp_id %u",
792 ts_params->valid_devs[0],
793 ts_params->conf.nb_queue_pairs);
796 /* invalid - zero queue pairs */
797 ts_params->conf.nb_queue_pairs = 0;
799 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
801 "Failed test for rte_cryptodev_configure, dev_id %u,"
803 ts_params->valid_devs[0],
804 ts_params->conf.nb_queue_pairs);
807 /* invalid - max value supported by field queue pairs */
808 ts_params->conf.nb_queue_pairs = UINT16_MAX;
810 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
812 "Failed test for rte_cryptodev_configure, dev_id %u,"
814 ts_params->valid_devs[0],
815 ts_params->conf.nb_queue_pairs);
818 /* invalid - max value + 1 queue pairs */
819 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
821 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
823 "Failed test for rte_cryptodev_configure, dev_id %u,"
825 ts_params->valid_devs[0],
826 ts_params->conf.nb_queue_pairs);
828 /* revert to original testsuite value */
829 ts_params->conf.nb_queue_pairs = orig_nb_qps;
835 test_queue_pair_descriptor_setup(void)
837 struct crypto_testsuite_params *ts_params = &testsuite_params;
838 struct rte_cryptodev_qp_conf qp_conf = {
839 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
843 /* Stop the device in case it's started so it can be configured */
844 rte_cryptodev_stop(ts_params->valid_devs[0]);
846 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
848 "Failed to configure cryptodev %u",
849 ts_params->valid_devs[0]);
852 * Test various ring sizes on this device. memzones can't be
853 * freed so are re-used if ring is released and re-created.
855 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
856 qp_conf.mp_session = ts_params->session_mpool;
857 qp_conf.mp_session_private = ts_params->session_priv_mpool;
859 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
860 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
861 ts_params->valid_devs[0], qp_id, &qp_conf,
862 rte_cryptodev_socket_id(
863 ts_params->valid_devs[0])),
865 "rte_cryptodev_queue_pair_setup: num_inflights "
866 "%u on qp %u on cryptodev %u",
867 qp_conf.nb_descriptors, qp_id,
868 ts_params->valid_devs[0]);
871 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
873 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
874 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
875 ts_params->valid_devs[0], qp_id, &qp_conf,
876 rte_cryptodev_socket_id(
877 ts_params->valid_devs[0])),
879 " rte_cryptodev_queue_pair_setup: num_inflights"
880 " %u on qp %u on cryptodev %u",
881 qp_conf.nb_descriptors, qp_id,
882 ts_params->valid_devs[0]);
885 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
887 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
888 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
889 ts_params->valid_devs[0], qp_id, &qp_conf,
890 rte_cryptodev_socket_id(
891 ts_params->valid_devs[0])),
893 "rte_cryptodev_queue_pair_setup: num_inflights"
894 " %u on qp %u on cryptodev %u",
895 qp_conf.nb_descriptors, qp_id,
896 ts_params->valid_devs[0]);
899 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
901 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
902 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
903 ts_params->valid_devs[0], qp_id, &qp_conf,
904 rte_cryptodev_socket_id(
905 ts_params->valid_devs[0])),
907 " rte_cryptodev_queue_pair_setup:"
908 "num_inflights %u on qp %u on cryptodev %u",
909 qp_conf.nb_descriptors, qp_id,
910 ts_params->valid_devs[0]);
913 /* test invalid queue pair id */
914 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
916 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
918 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
919 ts_params->valid_devs[0],
921 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
922 "Failed test for rte_cryptodev_queue_pair_setup:"
923 "invalid qp %u on cryptodev %u",
924 qp_id, ts_params->valid_devs[0]);
926 qp_id = 0xffff; /*invalid*/
928 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
929 ts_params->valid_devs[0],
931 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
932 "Failed test for rte_cryptodev_queue_pair_setup:"
933 "invalid qp %u on cryptodev %u",
934 qp_id, ts_params->valid_devs[0]);
939 /* ***** Plaintext data for tests ***** */
941 const char catch_22_quote_1[] =
942 "There was only one catch and that was Catch-22, which "
943 "specified that a concern for one's safety in the face of "
944 "dangers that were real and immediate was the process of a "
945 "rational mind. Orr was crazy and could be grounded. All he "
946 "had to do was ask; and as soon as he did, he would no longer "
947 "be crazy and would have to fly more missions. Orr would be "
948 "crazy to fly more missions and sane if he didn't, but if he "
949 "was sane he had to fly them. If he flew them he was crazy "
950 "and didn't have to; but if he didn't want to he was sane and "
951 "had to. Yossarian was moved very deeply by the absolute "
952 "simplicity of this clause of Catch-22 and let out a "
953 "respectful whistle. \"That's some catch, that Catch-22\", he "
954 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
956 const char catch_22_quote[] =
957 "What a lousy earth! He wondered how many people were "
958 "destitute that same night even in his own prosperous country, "
959 "how many homes were shanties, how many husbands were drunk "
960 "and wives socked, and how many children were bullied, abused, "
961 "or abandoned. How many families hungered for food they could "
962 "not afford to buy? How many hearts were broken? How many "
963 "suicides would take place that same night, how many people "
964 "would go insane? How many cockroaches and landlords would "
965 "triumph? How many winners were losers, successes failures, "
966 "and rich men poor men? How many wise guys were stupid? How "
967 "many happy endings were unhappy endings? How many honest men "
968 "were liars, brave men cowards, loyal men traitors, how many "
969 "sainted men were corrupt, how many people in positions of "
970 "trust had sold their souls to bodyguards, how many had never "
971 "had souls? How many straight-and-narrow paths were crooked "
972 "paths? How many best families were worst families and how "
973 "many good people were bad people? When you added them all up "
974 "and then subtracted, you might be left with only the children, "
975 "and perhaps with Albert Einstein and an old violinist or "
976 "sculptor somewhere.";
978 #define QUOTE_480_BYTES (480)
979 #define QUOTE_512_BYTES (512)
980 #define QUOTE_768_BYTES (768)
981 #define QUOTE_1024_BYTES (1024)
985 /* ***** SHA1 Hash Tests ***** */
987 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
989 static uint8_t hmac_sha1_key[] = {
990 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
991 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
992 0xDE, 0xF4, 0xDE, 0xAD };
994 /* ***** SHA224 Hash Tests ***** */
996 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
999 /* ***** AES-CBC Cipher Tests ***** */
1001 #define CIPHER_KEY_LENGTH_AES_CBC (16)
1002 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
1004 static uint8_t aes_cbc_key[] = {
1005 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1006 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1008 static uint8_t aes_cbc_iv[] = {
1009 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1010 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1013 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1015 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1016 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1017 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1018 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1019 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1020 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1021 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1022 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1023 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1024 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1025 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1026 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1027 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1028 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1029 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1030 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1031 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1032 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1033 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1034 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1035 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1036 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1037 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1038 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1039 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1040 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1041 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1042 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1043 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1044 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1045 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1046 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1047 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1048 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1049 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1050 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1051 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1052 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1053 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1054 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1055 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1056 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1057 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1058 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1059 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1060 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1061 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1062 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1063 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1064 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1065 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1066 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1067 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1068 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1069 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1070 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1071 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1072 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1073 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1074 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1075 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1076 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1077 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1078 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1079 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1082 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1083 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1084 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1085 0x18, 0x8c, 0x1d, 0x32
1089 /* Multisession Vector context Test */
1090 /*Begin Session 0 */
1091 static uint8_t ms_aes_cbc_key0[] = {
1092 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1093 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1096 static uint8_t ms_aes_cbc_iv0[] = {
1097 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1098 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1101 static const uint8_t ms_aes_cbc_cipher0[] = {
1102 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1103 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1104 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1105 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1106 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1107 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1108 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1109 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1110 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1111 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1112 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1113 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1114 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1115 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1116 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1117 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1118 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1119 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1120 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1121 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1122 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1123 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1124 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1125 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1126 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1127 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1128 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1129 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1130 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1131 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1132 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1133 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1134 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1135 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1136 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1137 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1138 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1139 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1140 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1141 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1142 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1143 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1144 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1145 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1146 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1147 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1148 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1149 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1150 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1151 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1152 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1153 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1154 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1155 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1156 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1157 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1158 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1159 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1160 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1161 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1162 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1163 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1164 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1165 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1169 static uint8_t ms_hmac_key0[] = {
1170 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1171 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1172 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1173 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1174 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1175 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1176 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1177 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1180 static const uint8_t ms_hmac_digest0[] = {
1181 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1182 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1183 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1184 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1185 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1186 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1187 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1188 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1192 /* Begin session 1 */
1194 static uint8_t ms_aes_cbc_key1[] = {
1195 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1196 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1199 static uint8_t ms_aes_cbc_iv1[] = {
1200 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1201 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1204 static const uint8_t ms_aes_cbc_cipher1[] = {
1205 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1206 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1207 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1208 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1209 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1210 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1211 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1212 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1213 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1214 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1215 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1216 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1217 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1218 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1219 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1220 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1221 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1222 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1223 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1224 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1225 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1226 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1227 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1228 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1229 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1230 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1231 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1232 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1233 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1234 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1235 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1236 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1237 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1238 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1239 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1240 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1241 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1242 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1243 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1244 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1245 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1246 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1247 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1248 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1249 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1250 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1251 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1252 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1253 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1254 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1255 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1256 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1257 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1258 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1259 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1260 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1261 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1262 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1263 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1264 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1265 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1266 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1267 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1268 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1272 static uint8_t ms_hmac_key1[] = {
1273 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1274 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1275 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1276 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1277 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1278 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1279 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1280 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1283 static const uint8_t ms_hmac_digest1[] = {
1284 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1285 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1286 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1287 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1288 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1289 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1290 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1291 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1294 /* Begin Session 2 */
1295 static uint8_t ms_aes_cbc_key2[] = {
1296 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1297 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1300 static uint8_t ms_aes_cbc_iv2[] = {
1301 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1302 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1305 static const uint8_t ms_aes_cbc_cipher2[] = {
1306 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1307 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1308 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1309 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1310 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1311 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1312 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1313 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1314 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1315 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1316 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1317 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1318 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1319 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1320 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1321 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1322 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1323 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1324 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1325 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1326 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1327 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1328 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1329 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1330 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1331 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1332 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1333 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1334 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1335 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1336 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1337 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1338 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1339 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1340 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1341 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1342 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1343 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1344 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1345 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1346 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1347 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1348 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1349 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1350 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1351 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1352 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1353 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1354 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1355 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1356 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1357 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1358 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1359 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1360 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1361 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1362 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1363 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1364 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1365 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1366 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1367 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1368 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1369 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1372 static uint8_t ms_hmac_key2[] = {
1373 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1374 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1375 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1376 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1377 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1378 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1379 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1380 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1383 static const uint8_t ms_hmac_digest2[] = {
1384 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1385 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1386 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1387 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1388 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1389 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1390 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1391 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1398 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1400 struct crypto_testsuite_params *ts_params = &testsuite_params;
1401 struct crypto_unittest_params *ut_params = &unittest_params;
1403 /* Verify the capabilities */
1404 struct rte_cryptodev_sym_capability_idx cap_idx;
1405 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1406 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
1407 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1410 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1411 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
1412 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1416 /* Generate test mbuf data and space for digest */
1417 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1418 catch_22_quote, QUOTE_512_BYTES, 0);
1420 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1421 DIGEST_BYTE_LENGTH_SHA1);
1422 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1424 /* Setup Cipher Parameters */
1425 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1426 ut_params->cipher_xform.next = &ut_params->auth_xform;
1428 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1429 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1430 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1431 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1432 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1433 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1435 /* Setup HMAC Parameters */
1436 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1438 ut_params->auth_xform.next = NULL;
1440 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1441 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1442 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1443 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1444 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1446 ut_params->sess = rte_cryptodev_sym_session_create(
1447 ts_params->session_mpool);
1449 /* Create crypto session*/
1450 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1451 ut_params->sess, &ut_params->cipher_xform,
1452 ts_params->session_priv_mpool);
1453 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1455 /* Generate crypto op data structure */
1456 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1457 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1458 TEST_ASSERT_NOT_NULL(ut_params->op,
1459 "Failed to allocate symmetric crypto operation struct");
1461 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1463 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1465 /* set crypto operation source mbuf */
1466 sym_op->m_src = ut_params->ibuf;
1468 /* Set crypto operation authentication parameters */
1469 sym_op->auth.digest.data = ut_params->digest;
1470 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1471 ut_params->ibuf, QUOTE_512_BYTES);
1473 sym_op->auth.data.offset = 0;
1474 sym_op->auth.data.length = QUOTE_512_BYTES;
1476 /* Copy IV at the end of the crypto operation */
1477 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1478 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1480 /* Set crypto operation cipher parameters */
1481 sym_op->cipher.data.offset = 0;
1482 sym_op->cipher.data.length = QUOTE_512_BYTES;
1484 /* Process crypto operation */
1485 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1486 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1489 TEST_ASSERT_NOT_NULL(
1490 process_crypto_request(ts_params->valid_devs[0],
1492 "failed to process sym crypto op");
1494 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1495 "crypto op processing failed");
1498 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1501 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1502 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1504 "ciphertext data not as expected");
1506 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1508 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1509 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1510 gbl_driver_id == rte_cryptodev_driver_id_get(
1511 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1512 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1513 DIGEST_BYTE_LENGTH_SHA1,
1514 "Generated digest data not as expected");
1516 return TEST_SUCCESS;
1519 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1521 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1523 static uint8_t hmac_sha512_key[] = {
1524 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1525 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1526 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1527 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1528 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1529 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1530 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1531 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1533 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1534 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1535 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1536 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1537 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1538 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1539 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1540 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1541 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1546 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1547 struct crypto_unittest_params *ut_params,
1548 uint8_t *cipher_key,
1552 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1553 struct crypto_unittest_params *ut_params,
1554 struct crypto_testsuite_params *ts_params,
1555 const uint8_t *cipher,
1556 const uint8_t *digest,
1561 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1562 struct crypto_unittest_params *ut_params,
1563 uint8_t *cipher_key,
1567 /* Setup Cipher Parameters */
1568 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1569 ut_params->cipher_xform.next = NULL;
1571 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1572 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1573 ut_params->cipher_xform.cipher.key.data = cipher_key;
1574 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1575 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1576 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1578 /* Setup HMAC Parameters */
1579 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1580 ut_params->auth_xform.next = &ut_params->cipher_xform;
1582 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1583 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1584 ut_params->auth_xform.auth.key.data = hmac_key;
1585 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1586 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1588 return TEST_SUCCESS;
1593 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1594 struct crypto_unittest_params *ut_params,
1595 struct crypto_testsuite_params *ts_params,
1596 const uint8_t *cipher,
1597 const uint8_t *digest,
1600 /* Generate test mbuf data and digest */
1601 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1604 QUOTE_512_BYTES, 0);
1606 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1607 DIGEST_BYTE_LENGTH_SHA512);
1608 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1610 rte_memcpy(ut_params->digest,
1612 DIGEST_BYTE_LENGTH_SHA512);
1614 /* Generate Crypto op data structure */
1615 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1616 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1617 TEST_ASSERT_NOT_NULL(ut_params->op,
1618 "Failed to allocate symmetric crypto operation struct");
1620 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1622 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1624 /* set crypto operation source mbuf */
1625 sym_op->m_src = ut_params->ibuf;
1627 sym_op->auth.digest.data = ut_params->digest;
1628 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1629 ut_params->ibuf, QUOTE_512_BYTES);
1631 sym_op->auth.data.offset = 0;
1632 sym_op->auth.data.length = QUOTE_512_BYTES;
1634 /* Copy IV at the end of the crypto operation */
1635 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1636 iv, CIPHER_IV_LENGTH_AES_CBC);
1638 sym_op->cipher.data.offset = 0;
1639 sym_op->cipher.data.length = QUOTE_512_BYTES;
1641 /* Process crypto operation */
1642 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1643 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1646 TEST_ASSERT_NOT_NULL(
1647 process_crypto_request(ts_params->valid_devs[0],
1649 "failed to process sym crypto op");
1651 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1652 "crypto op processing failed");
1654 ut_params->obuf = ut_params->op->sym->m_src;
1657 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1658 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1661 "Plaintext data not as expected");
1664 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1665 "Digest verification failed");
1667 return TEST_SUCCESS;
1671 test_blockcipher(enum blockcipher_test_type test_type)
1673 struct crypto_testsuite_params *ts_params = &testsuite_params;
1676 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1677 ts_params->op_mpool,
1678 ts_params->session_mpool, ts_params->session_priv_mpool,
1679 ts_params->valid_devs[0],
1682 if (status == -ENOTSUP)
1685 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1687 return TEST_SUCCESS;
1691 test_AES_cipheronly_all(void)
1693 return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
1697 test_AES_docsis_all(void)
1699 return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
1703 test_DES_docsis_all(void)
1705 return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
1709 test_DES_cipheronly_all(void)
1711 return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
1715 test_authonly_all(void)
1717 return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
1721 test_AES_chain_all(void)
1723 return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
1727 test_3DES_chain_all(void)
1729 return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
1733 test_3DES_cipheronly_all(void)
1735 return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
1738 /* ***** SNOW 3G Tests ***** */
1740 create_wireless_algo_hash_session(uint8_t dev_id,
1741 const uint8_t *key, const uint8_t key_len,
1742 const uint8_t iv_len, const uint8_t auth_len,
1743 enum rte_crypto_auth_operation op,
1744 enum rte_crypto_auth_algorithm algo)
1746 uint8_t hash_key[key_len];
1749 struct crypto_testsuite_params *ts_params = &testsuite_params;
1750 struct crypto_unittest_params *ut_params = &unittest_params;
1752 memcpy(hash_key, key, key_len);
1754 debug_hexdump(stdout, "key:", key, key_len);
1756 /* Setup Authentication Parameters */
1757 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1758 ut_params->auth_xform.next = NULL;
1760 ut_params->auth_xform.auth.op = op;
1761 ut_params->auth_xform.auth.algo = algo;
1762 ut_params->auth_xform.auth.key.length = key_len;
1763 ut_params->auth_xform.auth.key.data = hash_key;
1764 ut_params->auth_xform.auth.digest_length = auth_len;
1765 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
1766 ut_params->auth_xform.auth.iv.length = iv_len;
1767 ut_params->sess = rte_cryptodev_sym_session_create(
1768 ts_params->session_mpool);
1770 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1771 &ut_params->auth_xform,
1772 ts_params->session_priv_mpool);
1773 TEST_ASSERT_EQUAL(status, 0, "session init failed");
1774 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1779 create_wireless_algo_cipher_session(uint8_t dev_id,
1780 enum rte_crypto_cipher_operation op,
1781 enum rte_crypto_cipher_algorithm algo,
1782 const uint8_t *key, const uint8_t key_len,
1785 uint8_t cipher_key[key_len];
1787 struct crypto_testsuite_params *ts_params = &testsuite_params;
1788 struct crypto_unittest_params *ut_params = &unittest_params;
1790 memcpy(cipher_key, key, key_len);
1792 /* Setup Cipher Parameters */
1793 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1794 ut_params->cipher_xform.next = NULL;
1796 ut_params->cipher_xform.cipher.algo = algo;
1797 ut_params->cipher_xform.cipher.op = op;
1798 ut_params->cipher_xform.cipher.key.data = cipher_key;
1799 ut_params->cipher_xform.cipher.key.length = key_len;
1800 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1801 ut_params->cipher_xform.cipher.iv.length = iv_len;
1803 debug_hexdump(stdout, "key:", key, key_len);
1805 /* Create Crypto session */
1806 ut_params->sess = rte_cryptodev_sym_session_create(
1807 ts_params->session_mpool);
1809 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1810 &ut_params->cipher_xform,
1811 ts_params->session_priv_mpool);
1812 TEST_ASSERT_EQUAL(status, 0, "session init failed");
1813 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1818 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
1819 unsigned int cipher_len,
1820 unsigned int cipher_offset)
1822 struct crypto_testsuite_params *ts_params = &testsuite_params;
1823 struct crypto_unittest_params *ut_params = &unittest_params;
1825 /* Generate Crypto op data structure */
1826 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1827 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1828 TEST_ASSERT_NOT_NULL(ut_params->op,
1829 "Failed to allocate pktmbuf offload");
1831 /* Set crypto operation data parameters */
1832 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1834 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1836 /* set crypto operation source mbuf */
1837 sym_op->m_src = ut_params->ibuf;
1840 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1842 sym_op->cipher.data.length = cipher_len;
1843 sym_op->cipher.data.offset = cipher_offset;
1848 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
1849 unsigned int cipher_len,
1850 unsigned int cipher_offset)
1852 struct crypto_testsuite_params *ts_params = &testsuite_params;
1853 struct crypto_unittest_params *ut_params = &unittest_params;
1855 /* Generate Crypto op data structure */
1856 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1857 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1858 TEST_ASSERT_NOT_NULL(ut_params->op,
1859 "Failed to allocate pktmbuf offload");
1861 /* Set crypto operation data parameters */
1862 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1864 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1866 /* set crypto operation source mbuf */
1867 sym_op->m_src = ut_params->ibuf;
1868 sym_op->m_dst = ut_params->obuf;
1871 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1873 sym_op->cipher.data.length = cipher_len;
1874 sym_op->cipher.data.offset = cipher_offset;
1879 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1880 enum rte_crypto_cipher_operation cipher_op,
1881 enum rte_crypto_auth_operation auth_op,
1882 enum rte_crypto_auth_algorithm auth_algo,
1883 enum rte_crypto_cipher_algorithm cipher_algo,
1884 const uint8_t *key, uint8_t key_len,
1885 uint8_t auth_iv_len, uint8_t auth_len,
1886 uint8_t cipher_iv_len)
1889 uint8_t cipher_auth_key[key_len];
1892 struct crypto_testsuite_params *ts_params = &testsuite_params;
1893 struct crypto_unittest_params *ut_params = &unittest_params;
1895 memcpy(cipher_auth_key, key, key_len);
1897 /* Setup Authentication Parameters */
1898 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1899 ut_params->auth_xform.next = NULL;
1901 ut_params->auth_xform.auth.op = auth_op;
1902 ut_params->auth_xform.auth.algo = auth_algo;
1903 ut_params->auth_xform.auth.key.length = key_len;
1904 /* Hash key = cipher key */
1905 ut_params->auth_xform.auth.key.data = cipher_auth_key;
1906 ut_params->auth_xform.auth.digest_length = auth_len;
1907 /* Auth IV will be after cipher IV */
1908 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
1909 ut_params->auth_xform.auth.iv.length = auth_iv_len;
1911 /* Setup Cipher Parameters */
1912 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1913 ut_params->cipher_xform.next = &ut_params->auth_xform;
1915 ut_params->cipher_xform.cipher.algo = cipher_algo;
1916 ut_params->cipher_xform.cipher.op = cipher_op;
1917 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1918 ut_params->cipher_xform.cipher.key.length = key_len;
1919 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1920 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
1922 debug_hexdump(stdout, "key:", key, key_len);
1924 /* Create Crypto session*/
1925 ut_params->sess = rte_cryptodev_sym_session_create(
1926 ts_params->session_mpool);
1927 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1929 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1930 &ut_params->cipher_xform,
1931 ts_params->session_priv_mpool);
1932 if (status == -ENOTSUP)
1935 TEST_ASSERT_EQUAL(status, 0, "session init failed");
1940 create_wireless_cipher_auth_session(uint8_t dev_id,
1941 enum rte_crypto_cipher_operation cipher_op,
1942 enum rte_crypto_auth_operation auth_op,
1943 enum rte_crypto_auth_algorithm auth_algo,
1944 enum rte_crypto_cipher_algorithm cipher_algo,
1945 const struct wireless_test_data *tdata)
1947 const uint8_t key_len = tdata->key.len;
1948 uint8_t cipher_auth_key[key_len];
1951 struct crypto_testsuite_params *ts_params = &testsuite_params;
1952 struct crypto_unittest_params *ut_params = &unittest_params;
1953 const uint8_t *key = tdata->key.data;
1954 const uint8_t auth_len = tdata->digest.len;
1955 uint8_t cipher_iv_len = tdata->cipher_iv.len;
1956 uint8_t auth_iv_len = tdata->auth_iv.len;
1958 memcpy(cipher_auth_key, key, key_len);
1960 /* Setup Authentication Parameters */
1961 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1962 ut_params->auth_xform.next = NULL;
1964 ut_params->auth_xform.auth.op = auth_op;
1965 ut_params->auth_xform.auth.algo = auth_algo;
1966 ut_params->auth_xform.auth.key.length = key_len;
1967 /* Hash key = cipher key */
1968 ut_params->auth_xform.auth.key.data = cipher_auth_key;
1969 ut_params->auth_xform.auth.digest_length = auth_len;
1970 /* Auth IV will be after cipher IV */
1971 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
1972 ut_params->auth_xform.auth.iv.length = auth_iv_len;
1974 /* Setup Cipher Parameters */
1975 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1976 ut_params->cipher_xform.next = &ut_params->auth_xform;
1978 ut_params->cipher_xform.cipher.algo = cipher_algo;
1979 ut_params->cipher_xform.cipher.op = cipher_op;
1980 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1981 ut_params->cipher_xform.cipher.key.length = key_len;
1982 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1983 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
1986 debug_hexdump(stdout, "key:", key, key_len);
1988 /* Create Crypto session*/
1989 ut_params->sess = rte_cryptodev_sym_session_create(
1990 ts_params->session_mpool);
1992 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1993 &ut_params->cipher_xform,
1994 ts_params->session_priv_mpool);
1995 if (status == -ENOTSUP)
1998 TEST_ASSERT_EQUAL(status, 0, "session init failed");
1999 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2004 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2005 const struct wireless_test_data *tdata)
2007 return create_wireless_cipher_auth_session(dev_id,
2008 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2009 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2010 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2014 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2015 enum rte_crypto_cipher_operation cipher_op,
2016 enum rte_crypto_auth_operation auth_op,
2017 enum rte_crypto_auth_algorithm auth_algo,
2018 enum rte_crypto_cipher_algorithm cipher_algo,
2019 const uint8_t *key, const uint8_t key_len,
2020 uint8_t auth_iv_len, uint8_t auth_len,
2021 uint8_t cipher_iv_len)
2023 uint8_t auth_cipher_key[key_len];
2025 struct crypto_testsuite_params *ts_params = &testsuite_params;
2026 struct crypto_unittest_params *ut_params = &unittest_params;
2028 memcpy(auth_cipher_key, key, key_len);
2030 /* Setup Authentication Parameters */
2031 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2032 ut_params->auth_xform.auth.op = auth_op;
2033 ut_params->auth_xform.next = &ut_params->cipher_xform;
2034 ut_params->auth_xform.auth.algo = auth_algo;
2035 ut_params->auth_xform.auth.key.length = key_len;
2036 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2037 ut_params->auth_xform.auth.digest_length = auth_len;
2038 /* Auth IV will be after cipher IV */
2039 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2040 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2042 /* Setup Cipher Parameters */
2043 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2044 ut_params->cipher_xform.next = NULL;
2045 ut_params->cipher_xform.cipher.algo = cipher_algo;
2046 ut_params->cipher_xform.cipher.op = cipher_op;
2047 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2048 ut_params->cipher_xform.cipher.key.length = key_len;
2049 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2050 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2052 debug_hexdump(stdout, "key:", key, key_len);
2054 /* Create Crypto session*/
2055 ut_params->sess = rte_cryptodev_sym_session_create(
2056 ts_params->session_mpool);
2057 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2059 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2060 ut_params->auth_xform.next = NULL;
2061 ut_params->cipher_xform.next = &ut_params->auth_xform;
2062 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2063 &ut_params->cipher_xform,
2064 ts_params->session_priv_mpool);
2067 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2068 &ut_params->auth_xform,
2069 ts_params->session_priv_mpool);
2071 if (status == -ENOTSUP)
2074 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2080 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2081 unsigned int auth_tag_len,
2082 const uint8_t *iv, unsigned int iv_len,
2083 unsigned int data_pad_len,
2084 enum rte_crypto_auth_operation op,
2085 unsigned int auth_len, unsigned int auth_offset)
2087 struct crypto_testsuite_params *ts_params = &testsuite_params;
2089 struct crypto_unittest_params *ut_params = &unittest_params;
2091 /* Generate Crypto op data structure */
2092 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2093 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2094 TEST_ASSERT_NOT_NULL(ut_params->op,
2095 "Failed to allocate pktmbuf offload");
2097 /* Set crypto operation data parameters */
2098 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2100 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2102 /* set crypto operation source mbuf */
2103 sym_op->m_src = ut_params->ibuf;
2106 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2109 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2110 ut_params->ibuf, auth_tag_len);
2112 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2113 "no room to append auth tag");
2114 ut_params->digest = sym_op->auth.digest.data;
2115 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2116 ut_params->ibuf, data_pad_len);
2117 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2118 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2120 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2122 debug_hexdump(stdout, "digest:",
2123 sym_op->auth.digest.data,
2126 sym_op->auth.data.length = auth_len;
2127 sym_op->auth.data.offset = auth_offset;
2133 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2134 enum rte_crypto_auth_operation op)
2136 struct crypto_testsuite_params *ts_params = &testsuite_params;
2137 struct crypto_unittest_params *ut_params = &unittest_params;
2139 const uint8_t *auth_tag = tdata->digest.data;
2140 const unsigned int auth_tag_len = tdata->digest.len;
2141 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2142 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2144 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2145 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2146 const uint8_t *auth_iv = tdata->auth_iv.data;
2147 const uint8_t auth_iv_len = tdata->auth_iv.len;
2148 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2149 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2151 /* Generate Crypto op data structure */
2152 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2153 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2154 TEST_ASSERT_NOT_NULL(ut_params->op,
2155 "Failed to allocate pktmbuf offload");
2156 /* Set crypto operation data parameters */
2157 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2159 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2161 /* set crypto operation source mbuf */
2162 sym_op->m_src = ut_params->ibuf;
2165 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2166 ut_params->ibuf, auth_tag_len);
2168 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2169 "no room to append auth tag");
2170 ut_params->digest = sym_op->auth.digest.data;
2171 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2172 ut_params->ibuf, data_pad_len);
2173 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2174 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2176 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2178 debug_hexdump(stdout, "digest:",
2179 sym_op->auth.digest.data,
2182 /* Copy cipher and auth IVs at the end of the crypto operation */
2183 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2185 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2186 iv_ptr += cipher_iv_len;
2187 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2189 sym_op->cipher.data.length = cipher_len;
2190 sym_op->cipher.data.offset = 0;
2191 sym_op->auth.data.length = auth_len;
2192 sym_op->auth.data.offset = 0;
2198 create_zuc_cipher_hash_generate_operation(
2199 const struct wireless_test_data *tdata)
2201 return create_wireless_cipher_hash_operation(tdata,
2202 RTE_CRYPTO_AUTH_OP_GENERATE);
2206 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2207 const unsigned auth_tag_len,
2208 const uint8_t *auth_iv, uint8_t auth_iv_len,
2209 unsigned data_pad_len,
2210 enum rte_crypto_auth_operation op,
2211 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2212 const unsigned cipher_len, const unsigned cipher_offset,
2213 const unsigned auth_len, const unsigned auth_offset)
2215 struct crypto_testsuite_params *ts_params = &testsuite_params;
2216 struct crypto_unittest_params *ut_params = &unittest_params;
2218 enum rte_crypto_cipher_algorithm cipher_algo =
2219 ut_params->cipher_xform.cipher.algo;
2220 enum rte_crypto_auth_algorithm auth_algo =
2221 ut_params->auth_xform.auth.algo;
2223 /* Generate Crypto op data structure */
2224 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2225 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2226 TEST_ASSERT_NOT_NULL(ut_params->op,
2227 "Failed to allocate pktmbuf offload");
2228 /* Set crypto operation data parameters */
2229 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2231 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2233 /* set crypto operation source mbuf */
2234 sym_op->m_src = ut_params->ibuf;
2237 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2238 ut_params->ibuf, auth_tag_len);
2240 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2241 "no room to append auth tag");
2242 ut_params->digest = sym_op->auth.digest.data;
2244 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2245 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2246 ut_params->ibuf, data_pad_len);
2248 struct rte_mbuf *m = ut_params->ibuf;
2249 unsigned int offset = data_pad_len;
2251 while (offset > m->data_len && m->next != NULL) {
2252 offset -= m->data_len;
2255 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2259 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2260 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2262 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2264 debug_hexdump(stdout, "digest:",
2265 sym_op->auth.digest.data,
2268 /* Copy cipher and auth IVs at the end of the crypto operation */
2269 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2271 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2272 iv_ptr += cipher_iv_len;
2273 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2275 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2276 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2277 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2278 sym_op->cipher.data.length = cipher_len;
2279 sym_op->cipher.data.offset = cipher_offset;
2281 sym_op->cipher.data.length = cipher_len >> 3;
2282 sym_op->cipher.data.offset = cipher_offset >> 3;
2285 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2286 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2287 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2288 sym_op->auth.data.length = auth_len;
2289 sym_op->auth.data.offset = auth_offset;
2291 sym_op->auth.data.length = auth_len >> 3;
2292 sym_op->auth.data.offset = auth_offset >> 3;
2299 create_wireless_algo_auth_cipher_operation(
2300 const uint8_t *auth_tag, unsigned int auth_tag_len,
2301 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2302 const uint8_t *auth_iv, uint8_t auth_iv_len,
2303 unsigned int data_pad_len,
2304 unsigned int cipher_len, unsigned int cipher_offset,
2305 unsigned int auth_len, unsigned int auth_offset,
2306 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2308 struct crypto_testsuite_params *ts_params = &testsuite_params;
2309 struct crypto_unittest_params *ut_params = &unittest_params;
2311 enum rte_crypto_cipher_algorithm cipher_algo =
2312 ut_params->cipher_xform.cipher.algo;
2313 enum rte_crypto_auth_algorithm auth_algo =
2314 ut_params->auth_xform.auth.algo;
2316 /* Generate Crypto op data structure */
2317 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2318 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2319 TEST_ASSERT_NOT_NULL(ut_params->op,
2320 "Failed to allocate pktmbuf offload");
2322 /* Set crypto operation data parameters */
2323 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2325 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2327 /* set crypto operation mbufs */
2328 sym_op->m_src = ut_params->ibuf;
2329 if (op_mode == OUT_OF_PLACE)
2330 sym_op->m_dst = ut_params->obuf;
2334 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2335 (op_mode == IN_PLACE ?
2336 ut_params->ibuf : ut_params->obuf),
2337 uint8_t *, data_pad_len);
2338 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2339 (op_mode == IN_PLACE ?
2340 ut_params->ibuf : ut_params->obuf),
2342 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2344 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2345 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2346 sym_op->m_src : sym_op->m_dst);
2347 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2348 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2349 sgl_buf = sgl_buf->next;
2351 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2352 uint8_t *, remaining_off);
2353 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2355 memset(sym_op->auth.digest.data, 0, remaining_off);
2356 while (sgl_buf->next != NULL) {
2357 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2358 0, rte_pktmbuf_data_len(sgl_buf));
2359 sgl_buf = sgl_buf->next;
2363 /* Copy digest for the verification */
2365 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2367 /* Copy cipher and auth IVs at the end of the crypto operation */
2368 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2369 ut_params->op, uint8_t *, IV_OFFSET);
2371 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2372 iv_ptr += cipher_iv_len;
2373 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2375 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2376 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2377 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2378 sym_op->cipher.data.length = cipher_len;
2379 sym_op->cipher.data.offset = cipher_offset;
2381 sym_op->cipher.data.length = cipher_len >> 3;
2382 sym_op->cipher.data.offset = cipher_offset >> 3;
2385 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2386 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2387 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2388 sym_op->auth.data.length = auth_len;
2389 sym_op->auth.data.offset = auth_offset;
2391 sym_op->auth.data.length = auth_len >> 3;
2392 sym_op->auth.data.offset = auth_offset >> 3;
2399 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2401 struct crypto_testsuite_params *ts_params = &testsuite_params;
2402 struct crypto_unittest_params *ut_params = &unittest_params;
2405 unsigned plaintext_pad_len;
2406 unsigned plaintext_len;
2408 struct rte_cryptodev_info dev_info;
2410 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2411 uint64_t feat_flags = dev_info.feature_flags;
2413 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2414 ((tdata->validAuthLenInBits.len % 8) != 0)) {
2415 printf("Device doesn't support NON-Byte Aligned Data.\n");
2419 /* Verify the capabilities */
2420 struct rte_cryptodev_sym_capability_idx cap_idx;
2421 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2422 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2423 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2427 /* Create SNOW 3G session */
2428 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2429 tdata->key.data, tdata->key.len,
2430 tdata->auth_iv.len, tdata->digest.len,
2431 RTE_CRYPTO_AUTH_OP_GENERATE,
2432 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2436 /* alloc mbuf and set payload */
2437 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2439 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2440 rte_pktmbuf_tailroom(ut_params->ibuf));
2442 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2443 /* Append data which is padded to a multiple of */
2444 /* the algorithms block size */
2445 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2446 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2448 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2450 /* Create SNOW 3G operation */
2451 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2452 tdata->auth_iv.data, tdata->auth_iv.len,
2453 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2454 tdata->validAuthLenInBits.len,
2459 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2461 ut_params->obuf = ut_params->op->sym->m_src;
2462 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2463 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2464 + plaintext_pad_len;
2467 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2470 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2471 "SNOW 3G Generated auth tag not as expected");
2477 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2479 struct crypto_testsuite_params *ts_params = &testsuite_params;
2480 struct crypto_unittest_params *ut_params = &unittest_params;
2483 unsigned plaintext_pad_len;
2484 unsigned plaintext_len;
2486 struct rte_cryptodev_info dev_info;
2488 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2489 uint64_t feat_flags = dev_info.feature_flags;
2491 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2492 ((tdata->validAuthLenInBits.len % 8) != 0)) {
2493 printf("Device doesn't support NON-Byte Aligned Data.\n");
2497 /* Verify the capabilities */
2498 struct rte_cryptodev_sym_capability_idx cap_idx;
2499 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2500 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2501 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2505 /* Create SNOW 3G session */
2506 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2507 tdata->key.data, tdata->key.len,
2508 tdata->auth_iv.len, tdata->digest.len,
2509 RTE_CRYPTO_AUTH_OP_VERIFY,
2510 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2513 /* alloc mbuf and set payload */
2514 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2516 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2517 rte_pktmbuf_tailroom(ut_params->ibuf));
2519 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2520 /* Append data which is padded to a multiple of */
2521 /* the algorithms block size */
2522 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2523 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2525 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2527 /* Create SNOW 3G operation */
2528 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2530 tdata->auth_iv.data, tdata->auth_iv.len,
2532 RTE_CRYPTO_AUTH_OP_VERIFY,
2533 tdata->validAuthLenInBits.len,
2538 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2540 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2541 ut_params->obuf = ut_params->op->sym->m_src;
2542 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2543 + plaintext_pad_len;
2546 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2555 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2557 struct crypto_testsuite_params *ts_params = &testsuite_params;
2558 struct crypto_unittest_params *ut_params = &unittest_params;
2561 unsigned plaintext_pad_len;
2562 unsigned plaintext_len;
2565 /* Verify the capabilities */
2566 struct rte_cryptodev_sym_capability_idx cap_idx;
2567 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2568 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2569 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2573 /* Create KASUMI session */
2574 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2575 tdata->key.data, tdata->key.len,
2576 0, tdata->digest.len,
2577 RTE_CRYPTO_AUTH_OP_GENERATE,
2578 RTE_CRYPTO_AUTH_KASUMI_F9);
2582 /* alloc mbuf and set payload */
2583 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2585 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2586 rte_pktmbuf_tailroom(ut_params->ibuf));
2588 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2589 /* Append data which is padded to a multiple of */
2590 /* the algorithms block size */
2591 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2592 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2594 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2596 /* Create KASUMI operation */
2597 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2599 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2600 tdata->plaintext.len,
2605 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2606 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2609 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2612 ut_params->obuf = ut_params->op->sym->m_src;
2613 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2614 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2615 + plaintext_pad_len;
2618 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2621 DIGEST_BYTE_LENGTH_KASUMI_F9,
2622 "KASUMI Generated auth tag not as expected");
2628 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2630 struct crypto_testsuite_params *ts_params = &testsuite_params;
2631 struct crypto_unittest_params *ut_params = &unittest_params;
2634 unsigned plaintext_pad_len;
2635 unsigned plaintext_len;
2638 /* Verify the capabilities */
2639 struct rte_cryptodev_sym_capability_idx cap_idx;
2640 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2641 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2642 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2646 /* Create KASUMI session */
2647 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2648 tdata->key.data, tdata->key.len,
2649 0, tdata->digest.len,
2650 RTE_CRYPTO_AUTH_OP_VERIFY,
2651 RTE_CRYPTO_AUTH_KASUMI_F9);
2654 /* alloc mbuf and set payload */
2655 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2657 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2658 rte_pktmbuf_tailroom(ut_params->ibuf));
2660 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2661 /* Append data which is padded to a multiple */
2662 /* of the algorithms block size */
2663 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2664 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2666 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2668 /* Create KASUMI operation */
2669 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2673 RTE_CRYPTO_AUTH_OP_VERIFY,
2674 tdata->plaintext.len,
2679 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2681 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2682 ut_params->obuf = ut_params->op->sym->m_src;
2683 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2684 + plaintext_pad_len;
2687 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2696 test_snow3g_hash_generate_test_case_1(void)
2698 return test_snow3g_authentication(&snow3g_hash_test_case_1);
2702 test_snow3g_hash_generate_test_case_2(void)
2704 return test_snow3g_authentication(&snow3g_hash_test_case_2);
2708 test_snow3g_hash_generate_test_case_3(void)
2710 return test_snow3g_authentication(&snow3g_hash_test_case_3);
2714 test_snow3g_hash_generate_test_case_4(void)
2716 return test_snow3g_authentication(&snow3g_hash_test_case_4);
2720 test_snow3g_hash_generate_test_case_5(void)
2722 return test_snow3g_authentication(&snow3g_hash_test_case_5);
2726 test_snow3g_hash_generate_test_case_6(void)
2728 return test_snow3g_authentication(&snow3g_hash_test_case_6);
2732 test_snow3g_hash_verify_test_case_1(void)
2734 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2739 test_snow3g_hash_verify_test_case_2(void)
2741 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2745 test_snow3g_hash_verify_test_case_3(void)
2747 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2751 test_snow3g_hash_verify_test_case_4(void)
2753 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2757 test_snow3g_hash_verify_test_case_5(void)
2759 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2763 test_snow3g_hash_verify_test_case_6(void)
2765 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2769 test_kasumi_hash_generate_test_case_1(void)
2771 return test_kasumi_authentication(&kasumi_hash_test_case_1);
2775 test_kasumi_hash_generate_test_case_2(void)
2777 return test_kasumi_authentication(&kasumi_hash_test_case_2);
2781 test_kasumi_hash_generate_test_case_3(void)
2783 return test_kasumi_authentication(&kasumi_hash_test_case_3);
2787 test_kasumi_hash_generate_test_case_4(void)
2789 return test_kasumi_authentication(&kasumi_hash_test_case_4);
2793 test_kasumi_hash_generate_test_case_5(void)
2795 return test_kasumi_authentication(&kasumi_hash_test_case_5);
2799 test_kasumi_hash_generate_test_case_6(void)
2801 return test_kasumi_authentication(&kasumi_hash_test_case_6);
2805 test_kasumi_hash_verify_test_case_1(void)
2807 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2811 test_kasumi_hash_verify_test_case_2(void)
2813 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2817 test_kasumi_hash_verify_test_case_3(void)
2819 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2823 test_kasumi_hash_verify_test_case_4(void)
2825 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2829 test_kasumi_hash_verify_test_case_5(void)
2831 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2835 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2837 struct crypto_testsuite_params *ts_params = &testsuite_params;
2838 struct crypto_unittest_params *ut_params = &unittest_params;
2841 uint8_t *plaintext, *ciphertext;
2842 unsigned plaintext_pad_len;
2843 unsigned plaintext_len;
2845 /* Verify the capabilities */
2846 struct rte_cryptodev_sym_capability_idx cap_idx;
2847 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2848 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
2849 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2853 /* Create KASUMI session */
2854 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2855 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2856 RTE_CRYPTO_CIPHER_KASUMI_F8,
2857 tdata->key.data, tdata->key.len,
2858 tdata->cipher_iv.len);
2862 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2864 /* Clear mbuf payload */
2865 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2866 rte_pktmbuf_tailroom(ut_params->ibuf));
2868 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2869 /* Append data which is padded to a multiple */
2870 /* of the algorithms block size */
2871 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2872 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2874 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2876 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
2878 /* Create KASUMI operation */
2879 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
2880 tdata->cipher_iv.len,
2881 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2882 tdata->validCipherOffsetInBits.len);
2886 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2888 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2890 ut_params->obuf = ut_params->op->sym->m_dst;
2891 if (ut_params->obuf)
2892 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
2894 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
2896 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2898 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
2899 (tdata->validCipherOffsetInBits.len >> 3);
2901 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2903 reference_ciphertext,
2904 tdata->validCipherLenInBits.len,
2905 "KASUMI Ciphertext data not as expected");
2910 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2912 struct crypto_testsuite_params *ts_params = &testsuite_params;
2913 struct crypto_unittest_params *ut_params = &unittest_params;
2917 unsigned int plaintext_pad_len;
2918 unsigned int plaintext_len;
2920 uint8_t buffer[10000];
2921 const uint8_t *ciphertext;
2923 struct rte_cryptodev_info dev_info;
2925 /* Verify the capabilities */
2926 struct rte_cryptodev_sym_capability_idx cap_idx;
2927 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2928 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
2929 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2933 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2935 uint64_t feat_flags = dev_info.feature_flags;
2937 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
2938 printf("Device doesn't support in-place scatter-gather. "
2943 /* Create KASUMI session */
2944 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2945 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2946 RTE_CRYPTO_CIPHER_KASUMI_F8,
2947 tdata->key.data, tdata->key.len,
2948 tdata->cipher_iv.len);
2952 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2955 /* Append data which is padded to a multiple */
2956 /* of the algorithms block size */
2957 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2959 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2960 plaintext_pad_len, 10, 0);
2962 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2964 /* Create KASUMI operation */
2965 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
2966 tdata->cipher_iv.len,
2967 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2968 tdata->validCipherOffsetInBits.len);
2972 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2974 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2976 ut_params->obuf = ut_params->op->sym->m_dst;
2978 if (ut_params->obuf)
2979 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
2980 plaintext_len, buffer);
2982 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
2983 tdata->validCipherOffsetInBits.len >> 3,
2984 plaintext_len, buffer);
2987 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2989 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
2990 (tdata->validCipherOffsetInBits.len >> 3);
2992 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2994 reference_ciphertext,
2995 tdata->validCipherLenInBits.len,
2996 "KASUMI Ciphertext data not as expected");
3001 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3003 struct crypto_testsuite_params *ts_params = &testsuite_params;
3004 struct crypto_unittest_params *ut_params = &unittest_params;
3007 uint8_t *plaintext, *ciphertext;
3008 unsigned plaintext_pad_len;
3009 unsigned plaintext_len;
3011 /* Verify the capabilities */
3012 struct rte_cryptodev_sym_capability_idx cap_idx;
3013 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3014 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3015 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3019 /* Create KASUMI session */
3020 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3021 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3022 RTE_CRYPTO_CIPHER_KASUMI_F8,
3023 tdata->key.data, tdata->key.len,
3024 tdata->cipher_iv.len);
3028 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3029 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3031 /* Clear mbuf payload */
3032 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3033 rte_pktmbuf_tailroom(ut_params->ibuf));
3035 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3036 /* Append data which is padded to a multiple */
3037 /* of the algorithms block size */
3038 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3039 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3041 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3042 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3044 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3046 /* Create KASUMI operation */
3047 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3048 tdata->cipher_iv.len,
3049 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3050 tdata->validCipherOffsetInBits.len);
3054 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3056 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3058 ut_params->obuf = ut_params->op->sym->m_dst;
3059 if (ut_params->obuf)
3060 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3062 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3064 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3066 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3067 (tdata->validCipherOffsetInBits.len >> 3);
3069 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3071 reference_ciphertext,
3072 tdata->validCipherLenInBits.len,
3073 "KASUMI Ciphertext data not as expected");
3078 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3080 struct crypto_testsuite_params *ts_params = &testsuite_params;
3081 struct crypto_unittest_params *ut_params = &unittest_params;
3084 unsigned int plaintext_pad_len;
3085 unsigned int plaintext_len;
3087 const uint8_t *ciphertext;
3088 uint8_t buffer[2048];
3090 struct rte_cryptodev_info dev_info;
3092 /* Verify the capabilities */
3093 struct rte_cryptodev_sym_capability_idx cap_idx;
3094 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3095 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3096 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3100 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3102 uint64_t feat_flags = dev_info.feature_flags;
3103 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3104 printf("Device doesn't support out-of-place scatter-gather "
3105 "in both input and output mbufs. "
3110 /* Create KASUMI session */
3111 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3112 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3113 RTE_CRYPTO_CIPHER_KASUMI_F8,
3114 tdata->key.data, tdata->key.len,
3115 tdata->cipher_iv.len);
3119 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3120 /* Append data which is padded to a multiple */
3121 /* of the algorithms block size */
3122 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3124 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3125 plaintext_pad_len, 10, 0);
3126 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3127 plaintext_pad_len, 3, 0);
3129 /* Append data which is padded to a multiple */
3130 /* of the algorithms block size */
3131 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3133 /* Create KASUMI operation */
3134 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3135 tdata->cipher_iv.len,
3136 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3137 tdata->validCipherOffsetInBits.len);
3141 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3143 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3145 ut_params->obuf = ut_params->op->sym->m_dst;
3146 if (ut_params->obuf)
3147 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3148 plaintext_pad_len, buffer);
3150 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3151 tdata->validCipherOffsetInBits.len >> 3,
3152 plaintext_pad_len, buffer);
3154 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3155 (tdata->validCipherOffsetInBits.len >> 3);
3157 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3159 reference_ciphertext,
3160 tdata->validCipherLenInBits.len,
3161 "KASUMI Ciphertext data not as expected");
3167 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3169 struct crypto_testsuite_params *ts_params = &testsuite_params;
3170 struct crypto_unittest_params *ut_params = &unittest_params;
3173 uint8_t *ciphertext, *plaintext;
3174 unsigned ciphertext_pad_len;
3175 unsigned ciphertext_len;
3177 /* Verify the capabilities */
3178 struct rte_cryptodev_sym_capability_idx cap_idx;
3179 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3180 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3181 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3185 /* Create KASUMI session */
3186 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3187 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3188 RTE_CRYPTO_CIPHER_KASUMI_F8,
3189 tdata->key.data, tdata->key.len,
3190 tdata->cipher_iv.len);
3194 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3195 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3197 /* Clear mbuf payload */
3198 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3199 rte_pktmbuf_tailroom(ut_params->ibuf));
3201 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3202 /* Append data which is padded to a multiple */
3203 /* of the algorithms block size */
3204 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3205 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3206 ciphertext_pad_len);
3207 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3208 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3210 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3212 /* Create KASUMI operation */
3213 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3214 tdata->cipher_iv.len,
3215 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3216 tdata->validCipherOffsetInBits.len);
3220 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3222 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3224 ut_params->obuf = ut_params->op->sym->m_dst;
3225 if (ut_params->obuf)
3226 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3228 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3230 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3232 const uint8_t *reference_plaintext = tdata->plaintext.data +
3233 (tdata->validCipherOffsetInBits.len >> 3);
3235 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3237 reference_plaintext,
3238 tdata->validCipherLenInBits.len,
3239 "KASUMI Plaintext data not as expected");
3244 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3246 struct crypto_testsuite_params *ts_params = &testsuite_params;
3247 struct crypto_unittest_params *ut_params = &unittest_params;
3250 uint8_t *ciphertext, *plaintext;
3251 unsigned ciphertext_pad_len;
3252 unsigned ciphertext_len;
3254 /* Verify the capabilities */
3255 struct rte_cryptodev_sym_capability_idx cap_idx;
3256 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3257 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3258 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3262 /* Create KASUMI session */
3263 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3264 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3265 RTE_CRYPTO_CIPHER_KASUMI_F8,
3266 tdata->key.data, tdata->key.len,
3267 tdata->cipher_iv.len);
3271 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3273 /* Clear mbuf payload */
3274 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3275 rte_pktmbuf_tailroom(ut_params->ibuf));
3277 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3278 /* Append data which is padded to a multiple */
3279 /* of the algorithms block size */
3280 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3281 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3282 ciphertext_pad_len);
3283 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3285 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3287 /* Create KASUMI operation */
3288 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3289 tdata->cipher_iv.len,
3290 tdata->ciphertext.len,
3291 tdata->validCipherOffsetInBits.len);
3295 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3297 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3299 ut_params->obuf = ut_params->op->sym->m_dst;
3300 if (ut_params->obuf)
3301 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3303 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3305 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3307 const uint8_t *reference_plaintext = tdata->plaintext.data +
3308 (tdata->validCipherOffsetInBits.len >> 3);
3310 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3312 reference_plaintext,
3313 tdata->validCipherLenInBits.len,
3314 "KASUMI Plaintext data not as expected");
3319 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3321 struct crypto_testsuite_params *ts_params = &testsuite_params;
3322 struct crypto_unittest_params *ut_params = &unittest_params;
3325 uint8_t *plaintext, *ciphertext;
3326 unsigned plaintext_pad_len;
3327 unsigned plaintext_len;
3329 /* Verify the capabilities */
3330 struct rte_cryptodev_sym_capability_idx cap_idx;
3331 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3332 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3333 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3337 /* Create SNOW 3G session */
3338 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3339 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3340 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3341 tdata->key.data, tdata->key.len,
3342 tdata->cipher_iv.len);
3346 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3348 /* Clear mbuf payload */
3349 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3350 rte_pktmbuf_tailroom(ut_params->ibuf));
3352 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3353 /* Append data which is padded to a multiple of */
3354 /* the algorithms block size */
3355 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3356 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3358 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3360 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3362 /* Create SNOW 3G operation */
3363 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3364 tdata->cipher_iv.len,
3365 tdata->validCipherLenInBits.len,
3370 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3372 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3374 ut_params->obuf = ut_params->op->sym->m_dst;
3375 if (ut_params->obuf)
3376 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3378 ciphertext = plaintext;
3380 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3383 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3385 tdata->ciphertext.data,
3386 tdata->validDataLenInBits.len,
3387 "SNOW 3G Ciphertext data not as expected");
3393 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3395 struct crypto_testsuite_params *ts_params = &testsuite_params;
3396 struct crypto_unittest_params *ut_params = &unittest_params;
3397 uint8_t *plaintext, *ciphertext;
3400 unsigned plaintext_pad_len;
3401 unsigned plaintext_len;
3403 /* Verify the capabilities */
3404 struct rte_cryptodev_sym_capability_idx cap_idx;
3405 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3406 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3407 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3411 /* Create SNOW 3G session */
3412 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3413 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3414 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3415 tdata->key.data, tdata->key.len,
3416 tdata->cipher_iv.len);
3420 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3421 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3423 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3424 "Failed to allocate input buffer in mempool");
3425 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3426 "Failed to allocate output buffer in mempool");
3428 /* Clear mbuf payload */
3429 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3430 rte_pktmbuf_tailroom(ut_params->ibuf));
3432 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3433 /* Append data which is padded to a multiple of */
3434 /* the algorithms block size */
3435 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3436 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3438 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3439 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3441 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3443 /* Create SNOW 3G operation */
3444 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3445 tdata->cipher_iv.len,
3446 tdata->validCipherLenInBits.len,
3451 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3453 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3455 ut_params->obuf = ut_params->op->sym->m_dst;
3456 if (ut_params->obuf)
3457 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3459 ciphertext = plaintext;
3461 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3464 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3466 tdata->ciphertext.data,
3467 tdata->validDataLenInBits.len,
3468 "SNOW 3G Ciphertext data not as expected");
3473 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3475 struct crypto_testsuite_params *ts_params = &testsuite_params;
3476 struct crypto_unittest_params *ut_params = &unittest_params;
3479 unsigned int plaintext_pad_len;
3480 unsigned int plaintext_len;
3481 uint8_t buffer[10000];
3482 const uint8_t *ciphertext;
3484 struct rte_cryptodev_info dev_info;
3486 /* Verify the capabilities */
3487 struct rte_cryptodev_sym_capability_idx cap_idx;
3488 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3489 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3490 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3494 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3496 uint64_t feat_flags = dev_info.feature_flags;
3498 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3499 printf("Device doesn't support out-of-place scatter-gather "
3500 "in both input and output mbufs. "
3505 /* Create SNOW 3G session */
3506 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3507 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3508 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3509 tdata->key.data, tdata->key.len,
3510 tdata->cipher_iv.len);
3514 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3515 /* Append data which is padded to a multiple of */
3516 /* the algorithms block size */
3517 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3519 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3520 plaintext_pad_len, 10, 0);
3521 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3522 plaintext_pad_len, 3, 0);
3524 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3525 "Failed to allocate input buffer in mempool");
3526 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3527 "Failed to allocate output buffer in mempool");
3529 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3531 /* Create SNOW 3G operation */
3532 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3533 tdata->cipher_iv.len,
3534 tdata->validCipherLenInBits.len,
3539 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3541 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3543 ut_params->obuf = ut_params->op->sym->m_dst;
3544 if (ut_params->obuf)
3545 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3546 plaintext_len, buffer);
3548 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3549 plaintext_len, buffer);
3551 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3554 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3556 tdata->ciphertext.data,
3557 tdata->validDataLenInBits.len,
3558 "SNOW 3G Ciphertext data not as expected");
3563 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3565 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3567 uint8_t curr_byte, prev_byte;
3568 uint32_t length_in_bytes = ceil_byte_length(length + offset);
3569 uint8_t lower_byte_mask = (1 << offset) - 1;
3572 prev_byte = buffer[0];
3573 buffer[0] >>= offset;
3575 for (i = 1; i < length_in_bytes; i++) {
3576 curr_byte = buffer[i];
3577 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3578 (curr_byte >> offset);
3579 prev_byte = curr_byte;
3584 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3586 struct crypto_testsuite_params *ts_params = &testsuite_params;
3587 struct crypto_unittest_params *ut_params = &unittest_params;
3588 uint8_t *plaintext, *ciphertext;
3590 uint32_t plaintext_len;
3591 uint32_t plaintext_pad_len;
3592 uint8_t extra_offset = 4;
3593 uint8_t *expected_ciphertext_shifted;
3594 struct rte_cryptodev_info dev_info;
3596 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3597 uint64_t feat_flags = dev_info.feature_flags;
3599 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3600 ((tdata->validDataLenInBits.len % 8) != 0)) {
3601 printf("Device doesn't support NON-Byte Aligned Data.\n");
3605 /* Verify the capabilities */
3606 struct rte_cryptodev_sym_capability_idx cap_idx;
3607 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3608 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3609 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3613 /* Create SNOW 3G session */
3614 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3615 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3616 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3617 tdata->key.data, tdata->key.len,
3618 tdata->cipher_iv.len);
3622 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3623 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3625 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3626 "Failed to allocate input buffer in mempool");
3627 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3628 "Failed to allocate output buffer in mempool");
3630 /* Clear mbuf payload */
3631 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3632 rte_pktmbuf_tailroom(ut_params->ibuf));
3634 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3636 * Append data which is padded to a
3637 * multiple of the algorithms block size
3639 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3641 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3644 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3646 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3647 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3649 #ifdef RTE_APP_TEST_DEBUG
3650 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3652 /* Create SNOW 3G operation */
3653 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3654 tdata->cipher_iv.len,
3655 tdata->validCipherLenInBits.len,
3660 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3662 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3664 ut_params->obuf = ut_params->op->sym->m_dst;
3665 if (ut_params->obuf)
3666 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3668 ciphertext = plaintext;
3670 #ifdef RTE_APP_TEST_DEBUG
3671 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3674 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3676 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3677 "failed to reserve memory for ciphertext shifted\n");
3679 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3680 ceil_byte_length(tdata->ciphertext.len));
3681 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3684 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3686 expected_ciphertext_shifted,
3687 tdata->validDataLenInBits.len,
3689 "SNOW 3G Ciphertext data not as expected");
3693 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3695 struct crypto_testsuite_params *ts_params = &testsuite_params;
3696 struct crypto_unittest_params *ut_params = &unittest_params;
3700 uint8_t *plaintext, *ciphertext;
3701 unsigned ciphertext_pad_len;
3702 unsigned ciphertext_len;
3704 /* Verify the capabilities */
3705 struct rte_cryptodev_sym_capability_idx cap_idx;
3706 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3707 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3708 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3712 /* Create SNOW 3G session */
3713 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3714 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3715 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3716 tdata->key.data, tdata->key.len,
3717 tdata->cipher_iv.len);
3721 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3723 /* Clear mbuf payload */
3724 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3725 rte_pktmbuf_tailroom(ut_params->ibuf));
3727 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3728 /* Append data which is padded to a multiple of */
3729 /* the algorithms block size */
3730 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3731 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3732 ciphertext_pad_len);
3733 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3735 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3737 /* Create SNOW 3G operation */
3738 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3739 tdata->cipher_iv.len,
3740 tdata->validCipherLenInBits.len,
3741 tdata->cipher.offset_bits);
3745 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3747 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3748 ut_params->obuf = ut_params->op->sym->m_dst;
3749 if (ut_params->obuf)
3750 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3752 plaintext = ciphertext;
3754 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3757 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3758 tdata->plaintext.data,
3759 tdata->validDataLenInBits.len,
3760 "SNOW 3G Plaintext data not as expected");
3764 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3766 struct crypto_testsuite_params *ts_params = &testsuite_params;
3767 struct crypto_unittest_params *ut_params = &unittest_params;
3771 uint8_t *plaintext, *ciphertext;
3772 unsigned ciphertext_pad_len;
3773 unsigned ciphertext_len;
3775 /* Verify the capabilities */
3776 struct rte_cryptodev_sym_capability_idx cap_idx;
3777 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3778 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3779 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3783 /* Create SNOW 3G session */
3784 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3785 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3786 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3787 tdata->key.data, tdata->key.len,
3788 tdata->cipher_iv.len);
3792 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3793 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3795 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3796 "Failed to allocate input buffer");
3797 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3798 "Failed to allocate output buffer");
3800 /* Clear mbuf payload */
3801 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3802 rte_pktmbuf_tailroom(ut_params->ibuf));
3804 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3805 rte_pktmbuf_tailroom(ut_params->obuf));
3807 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3808 /* Append data which is padded to a multiple of */
3809 /* the algorithms block size */
3810 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3811 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3812 ciphertext_pad_len);
3813 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3814 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3816 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3818 /* Create SNOW 3G operation */
3819 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3820 tdata->cipher_iv.len,
3821 tdata->validCipherLenInBits.len,
3826 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3828 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3829 ut_params->obuf = ut_params->op->sym->m_dst;
3830 if (ut_params->obuf)
3831 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3833 plaintext = ciphertext;
3835 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3838 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3839 tdata->plaintext.data,
3840 tdata->validDataLenInBits.len,
3841 "SNOW 3G Plaintext data not as expected");
3846 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
3848 struct crypto_testsuite_params *ts_params = &testsuite_params;
3849 struct crypto_unittest_params *ut_params = &unittest_params;
3853 uint8_t *plaintext, *ciphertext;
3854 unsigned int plaintext_pad_len;
3855 unsigned int plaintext_len;
3857 struct rte_cryptodev_info dev_info;
3858 struct rte_cryptodev_sym_capability_idx cap_idx;
3860 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3861 uint64_t feat_flags = dev_info.feature_flags;
3863 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3864 ((tdata->validAuthLenInBits.len % 8 != 0) ||
3865 (tdata->validDataLenInBits.len % 8 != 0))) {
3866 printf("Device doesn't support NON-Byte Aligned Data.\n");
3870 /* Check if device supports ZUC EEA3 */
3871 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3872 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
3874 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3878 /* Check if device supports ZUC EIA3 */
3879 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3880 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
3882 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3886 /* Create ZUC session */
3887 retval = create_zuc_cipher_auth_encrypt_generate_session(
3888 ts_params->valid_devs[0],
3892 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3894 /* clear mbuf payload */
3895 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3896 rte_pktmbuf_tailroom(ut_params->ibuf));
3898 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3899 /* Append data which is padded to a multiple of */
3900 /* the algorithms block size */
3901 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3902 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3904 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3906 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3908 /* Create ZUC operation */
3909 retval = create_zuc_cipher_hash_generate_operation(tdata);
3913 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3915 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3916 ut_params->obuf = ut_params->op->sym->m_src;
3917 if (ut_params->obuf)
3918 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3920 ciphertext = plaintext;
3922 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3924 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3926 tdata->ciphertext.data,
3927 tdata->validDataLenInBits.len,
3928 "ZUC Ciphertext data not as expected");
3930 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3931 + plaintext_pad_len;
3934 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3938 "ZUC Generated auth tag not as expected");
3943 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3945 struct crypto_testsuite_params *ts_params = &testsuite_params;
3946 struct crypto_unittest_params *ut_params = &unittest_params;
3950 uint8_t *plaintext, *ciphertext;
3951 unsigned plaintext_pad_len;
3952 unsigned plaintext_len;
3954 /* Verify the capabilities */
3955 struct rte_cryptodev_sym_capability_idx cap_idx;
3956 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3957 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3958 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3961 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3962 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3963 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3967 /* Create SNOW 3G session */
3968 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3969 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3970 RTE_CRYPTO_AUTH_OP_GENERATE,
3971 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3972 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3973 tdata->key.data, tdata->key.len,
3974 tdata->auth_iv.len, tdata->digest.len,
3975 tdata->cipher_iv.len);
3978 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3980 /* clear mbuf payload */
3981 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3982 rte_pktmbuf_tailroom(ut_params->ibuf));
3984 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3985 /* Append data which is padded to a multiple of */
3986 /* the algorithms block size */
3987 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3988 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3990 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3992 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3994 /* Create SNOW 3G operation */
3995 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3996 tdata->digest.len, tdata->auth_iv.data,
3998 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3999 tdata->cipher_iv.data, tdata->cipher_iv.len,
4000 tdata->validCipherLenInBits.len,
4002 tdata->validAuthLenInBits.len,
4008 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4010 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4011 ut_params->obuf = ut_params->op->sym->m_src;
4012 if (ut_params->obuf)
4013 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4015 ciphertext = plaintext;
4017 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4019 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4021 tdata->ciphertext.data,
4022 tdata->validDataLenInBits.len,
4023 "SNOW 3G Ciphertext data not as expected");
4025 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4026 + plaintext_pad_len;
4029 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4032 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4033 "SNOW 3G Generated auth tag not as expected");
4038 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4039 uint8_t op_mode, uint8_t verify)
4041 struct crypto_testsuite_params *ts_params = &testsuite_params;
4042 struct crypto_unittest_params *ut_params = &unittest_params;
4046 uint8_t *plaintext = NULL, *ciphertext = NULL;
4047 unsigned int plaintext_pad_len;
4048 unsigned int plaintext_len;
4049 unsigned int ciphertext_pad_len;
4050 unsigned int ciphertext_len;
4052 struct rte_cryptodev_info dev_info;
4054 /* Verify the capabilities */
4055 struct rte_cryptodev_sym_capability_idx cap_idx;
4056 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4057 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4058 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4061 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4062 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4063 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4067 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4069 uint64_t feat_flags = dev_info.feature_flags;
4071 if (op_mode == OUT_OF_PLACE) {
4072 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4073 printf("Device doesn't support digest encrypted.\n");
4078 /* Create SNOW 3G session */
4079 retval = create_wireless_algo_auth_cipher_session(
4080 ts_params->valid_devs[0],
4081 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4082 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4083 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4084 : RTE_CRYPTO_AUTH_OP_GENERATE),
4085 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4086 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4087 tdata->key.data, tdata->key.len,
4088 tdata->auth_iv.len, tdata->digest.len,
4089 tdata->cipher_iv.len);
4094 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4095 if (op_mode == OUT_OF_PLACE)
4096 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4098 /* clear mbuf payload */
4099 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4100 rte_pktmbuf_tailroom(ut_params->ibuf));
4101 if (op_mode == OUT_OF_PLACE)
4102 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4103 rte_pktmbuf_tailroom(ut_params->obuf));
4105 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4106 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4107 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4108 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4111 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4112 ciphertext_pad_len);
4113 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4114 if (op_mode == OUT_OF_PLACE)
4115 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4116 debug_hexdump(stdout, "ciphertext:", ciphertext,
4119 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4121 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4122 if (op_mode == OUT_OF_PLACE)
4123 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4124 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4127 /* Create SNOW 3G operation */
4128 retval = create_wireless_algo_auth_cipher_operation(
4129 tdata->digest.data, tdata->digest.len,
4130 tdata->cipher_iv.data, tdata->cipher_iv.len,
4131 tdata->auth_iv.data, tdata->auth_iv.len,
4132 (tdata->digest.offset_bytes == 0 ?
4133 (verify ? ciphertext_pad_len : plaintext_pad_len)
4134 : tdata->digest.offset_bytes),
4135 tdata->validCipherLenInBits.len,
4136 tdata->cipher.offset_bits,
4137 tdata->validAuthLenInBits.len,
4138 tdata->auth.offset_bits,
4139 op_mode, 0, verify);
4144 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4147 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4149 ut_params->obuf = (op_mode == IN_PLACE ?
4150 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4153 if (ut_params->obuf)
4154 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4157 plaintext = ciphertext +
4158 (tdata->cipher.offset_bits >> 3);
4160 debug_hexdump(stdout, "plaintext:", plaintext,
4161 (tdata->plaintext.len >> 3) - tdata->digest.len);
4162 debug_hexdump(stdout, "plaintext expected:",
4163 tdata->plaintext.data,
4164 (tdata->plaintext.len >> 3) - tdata->digest.len);
4166 if (ut_params->obuf)
4167 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4170 ciphertext = plaintext;
4172 debug_hexdump(stdout, "ciphertext:", ciphertext,
4174 debug_hexdump(stdout, "ciphertext expected:",
4175 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4177 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4178 + (tdata->digest.offset_bytes == 0 ?
4179 plaintext_pad_len : tdata->digest.offset_bytes);
4181 debug_hexdump(stdout, "digest:", ut_params->digest,
4183 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4189 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4191 tdata->plaintext.data,
4192 tdata->plaintext.len >> 3,
4193 "SNOW 3G Plaintext data not as expected");
4195 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4197 tdata->ciphertext.data,
4198 tdata->validDataLenInBits.len,
4199 "SNOW 3G Ciphertext data not as expected");
4201 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4204 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4205 "SNOW 3G Generated auth tag not as expected");
4211 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4212 uint8_t op_mode, uint8_t verify)
4214 struct crypto_testsuite_params *ts_params = &testsuite_params;
4215 struct crypto_unittest_params *ut_params = &unittest_params;
4219 const uint8_t *plaintext = NULL;
4220 const uint8_t *ciphertext = NULL;
4221 const uint8_t *digest = NULL;
4222 unsigned int plaintext_pad_len;
4223 unsigned int plaintext_len;
4224 unsigned int ciphertext_pad_len;
4225 unsigned int ciphertext_len;
4226 uint8_t buffer[10000];
4227 uint8_t digest_buffer[10000];
4229 struct rte_cryptodev_info dev_info;
4231 /* Verify the capabilities */
4232 struct rte_cryptodev_sym_capability_idx cap_idx;
4233 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4234 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4235 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4238 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4239 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4240 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4244 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4246 uint64_t feat_flags = dev_info.feature_flags;
4248 if (op_mode == IN_PLACE) {
4249 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4250 printf("Device doesn't support in-place scatter-gather "
4251 "in both input and output mbufs.\n");
4255 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4256 printf("Device doesn't support out-of-place scatter-gather "
4257 "in both input and output mbufs.\n");
4260 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4261 printf("Device doesn't support digest encrypted.\n");
4266 /* Create SNOW 3G session */
4267 retval = create_wireless_algo_auth_cipher_session(
4268 ts_params->valid_devs[0],
4269 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4270 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4271 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4272 : RTE_CRYPTO_AUTH_OP_GENERATE),
4273 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4274 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4275 tdata->key.data, tdata->key.len,
4276 tdata->auth_iv.len, tdata->digest.len,
4277 tdata->cipher_iv.len);
4282 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4283 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4284 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4285 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4287 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4288 plaintext_pad_len, 15, 0);
4289 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4290 "Failed to allocate input buffer in mempool");
4292 if (op_mode == OUT_OF_PLACE) {
4293 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4294 plaintext_pad_len, 15, 0);
4295 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4296 "Failed to allocate output buffer in mempool");
4300 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4301 tdata->ciphertext.data);
4302 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4303 ciphertext_len, buffer);
4304 debug_hexdump(stdout, "ciphertext:", ciphertext,
4307 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4308 tdata->plaintext.data);
4309 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4310 plaintext_len, buffer);
4311 debug_hexdump(stdout, "plaintext:", plaintext,
4314 memset(buffer, 0, sizeof(buffer));
4316 /* Create SNOW 3G operation */
4317 retval = create_wireless_algo_auth_cipher_operation(
4318 tdata->digest.data, tdata->digest.len,
4319 tdata->cipher_iv.data, tdata->cipher_iv.len,
4320 tdata->auth_iv.data, tdata->auth_iv.len,
4321 (tdata->digest.offset_bytes == 0 ?
4322 (verify ? ciphertext_pad_len : plaintext_pad_len)
4323 : tdata->digest.offset_bytes),
4324 tdata->validCipherLenInBits.len,
4325 tdata->cipher.offset_bits,
4326 tdata->validAuthLenInBits.len,
4327 tdata->auth.offset_bits,
4328 op_mode, 1, verify);
4333 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4336 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4338 ut_params->obuf = (op_mode == IN_PLACE ?
4339 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4342 if (ut_params->obuf)
4343 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4344 plaintext_len, buffer);
4346 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4347 plaintext_len, buffer);
4349 debug_hexdump(stdout, "plaintext:", plaintext,
4350 (tdata->plaintext.len >> 3) - tdata->digest.len);
4351 debug_hexdump(stdout, "plaintext expected:",
4352 tdata->plaintext.data,
4353 (tdata->plaintext.len >> 3) - tdata->digest.len);
4355 if (ut_params->obuf)
4356 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4357 ciphertext_len, buffer);
4359 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4360 ciphertext_len, buffer);
4362 debug_hexdump(stdout, "ciphertext:", ciphertext,
4364 debug_hexdump(stdout, "ciphertext expected:",
4365 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4367 if (ut_params->obuf)
4368 digest = rte_pktmbuf_read(ut_params->obuf,
4369 (tdata->digest.offset_bytes == 0 ?
4370 plaintext_pad_len : tdata->digest.offset_bytes),
4371 tdata->digest.len, digest_buffer);
4373 digest = rte_pktmbuf_read(ut_params->ibuf,
4374 (tdata->digest.offset_bytes == 0 ?
4375 plaintext_pad_len : tdata->digest.offset_bytes),
4376 tdata->digest.len, digest_buffer);
4378 debug_hexdump(stdout, "digest:", digest,
4380 debug_hexdump(stdout, "digest expected:",
4381 tdata->digest.data, tdata->digest.len);
4386 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4388 tdata->plaintext.data,
4389 tdata->plaintext.len >> 3,
4390 "SNOW 3G Plaintext data not as expected");
4392 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4394 tdata->ciphertext.data,
4395 tdata->validDataLenInBits.len,
4396 "SNOW 3G Ciphertext data not as expected");
4398 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4401 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4402 "SNOW 3G Generated auth tag not as expected");
4408 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4409 uint8_t op_mode, uint8_t verify)
4411 struct crypto_testsuite_params *ts_params = &testsuite_params;
4412 struct crypto_unittest_params *ut_params = &unittest_params;
4416 uint8_t *plaintext = NULL, *ciphertext = NULL;
4417 unsigned int plaintext_pad_len;
4418 unsigned int plaintext_len;
4419 unsigned int ciphertext_pad_len;
4420 unsigned int ciphertext_len;
4422 struct rte_cryptodev_info dev_info;
4424 /* Verify the capabilities */
4425 struct rte_cryptodev_sym_capability_idx cap_idx;
4426 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4427 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4428 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4431 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4432 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4433 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4437 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4439 uint64_t feat_flags = dev_info.feature_flags;
4441 if (op_mode == OUT_OF_PLACE) {
4442 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4443 printf("Device doesn't support digest encrypted.\n");
4448 /* Create KASUMI session */
4449 retval = create_wireless_algo_auth_cipher_session(
4450 ts_params->valid_devs[0],
4451 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4452 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4453 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4454 : RTE_CRYPTO_AUTH_OP_GENERATE),
4455 RTE_CRYPTO_AUTH_KASUMI_F9,
4456 RTE_CRYPTO_CIPHER_KASUMI_F8,
4457 tdata->key.data, tdata->key.len,
4458 0, tdata->digest.len,
4459 tdata->cipher_iv.len);
4464 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4465 if (op_mode == OUT_OF_PLACE)
4466 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4468 /* clear mbuf payload */
4469 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4470 rte_pktmbuf_tailroom(ut_params->ibuf));
4471 if (op_mode == OUT_OF_PLACE)
4472 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4473 rte_pktmbuf_tailroom(ut_params->obuf));
4475 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4476 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4477 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4478 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4481 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4482 ciphertext_pad_len);
4483 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4484 if (op_mode == OUT_OF_PLACE)
4485 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4486 debug_hexdump(stdout, "ciphertext:", ciphertext,
4489 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4491 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4492 if (op_mode == OUT_OF_PLACE)
4493 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4494 debug_hexdump(stdout, "plaintext:", plaintext,
4498 /* Create KASUMI operation */
4499 retval = create_wireless_algo_auth_cipher_operation(
4500 tdata->digest.data, tdata->digest.len,
4501 tdata->cipher_iv.data, tdata->cipher_iv.len,
4503 (tdata->digest.offset_bytes == 0 ?
4504 (verify ? ciphertext_pad_len : plaintext_pad_len)
4505 : tdata->digest.offset_bytes),
4506 tdata->validCipherLenInBits.len,
4507 tdata->validCipherOffsetInBits.len,
4508 tdata->validAuthLenInBits.len,
4510 op_mode, 0, verify);
4515 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4518 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4520 ut_params->obuf = (op_mode == IN_PLACE ?
4521 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4525 if (ut_params->obuf)
4526 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4529 plaintext = ciphertext;
4531 debug_hexdump(stdout, "plaintext:", plaintext,
4532 (tdata->plaintext.len >> 3) - tdata->digest.len);
4533 debug_hexdump(stdout, "plaintext expected:",
4534 tdata->plaintext.data,
4535 (tdata->plaintext.len >> 3) - tdata->digest.len);
4537 if (ut_params->obuf)
4538 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4541 ciphertext = plaintext;
4543 debug_hexdump(stdout, "ciphertext:", ciphertext,
4545 debug_hexdump(stdout, "ciphertext expected:",
4546 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4548 ut_params->digest = rte_pktmbuf_mtod(
4549 ut_params->obuf, uint8_t *) +
4550 (tdata->digest.offset_bytes == 0 ?
4551 plaintext_pad_len : tdata->digest.offset_bytes);
4553 debug_hexdump(stdout, "digest:", ut_params->digest,
4555 debug_hexdump(stdout, "digest expected:",
4556 tdata->digest.data, tdata->digest.len);
4561 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4563 tdata->plaintext.data,
4564 tdata->plaintext.len >> 3,
4565 "KASUMI Plaintext data not as expected");
4567 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4569 tdata->ciphertext.data,
4570 tdata->ciphertext.len >> 3,
4571 "KASUMI Ciphertext data not as expected");
4573 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4576 DIGEST_BYTE_LENGTH_KASUMI_F9,
4577 "KASUMI Generated auth tag not as expected");
4583 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
4584 uint8_t op_mode, uint8_t verify)
4586 struct crypto_testsuite_params *ts_params = &testsuite_params;
4587 struct crypto_unittest_params *ut_params = &unittest_params;
4591 const uint8_t *plaintext = NULL;
4592 const uint8_t *ciphertext = NULL;
4593 const uint8_t *digest = NULL;
4594 unsigned int plaintext_pad_len;
4595 unsigned int plaintext_len;
4596 unsigned int ciphertext_pad_len;
4597 unsigned int ciphertext_len;
4598 uint8_t buffer[10000];
4599 uint8_t digest_buffer[10000];
4601 struct rte_cryptodev_info dev_info;
4603 /* Verify the capabilities */
4604 struct rte_cryptodev_sym_capability_idx cap_idx;
4605 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4606 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4607 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4610 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4611 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4612 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4616 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4618 uint64_t feat_flags = dev_info.feature_flags;
4620 if (op_mode == IN_PLACE) {
4621 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4622 printf("Device doesn't support in-place scatter-gather "
4623 "in both input and output mbufs.\n");
4627 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4628 printf("Device doesn't support out-of-place scatter-gather "
4629 "in both input and output mbufs.\n");
4632 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4633 printf("Device doesn't support digest encrypted.\n");
4638 /* Create KASUMI session */
4639 retval = create_wireless_algo_auth_cipher_session(
4640 ts_params->valid_devs[0],
4641 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4642 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4643 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4644 : RTE_CRYPTO_AUTH_OP_GENERATE),
4645 RTE_CRYPTO_AUTH_KASUMI_F9,
4646 RTE_CRYPTO_CIPHER_KASUMI_F8,
4647 tdata->key.data, tdata->key.len,
4648 0, tdata->digest.len,
4649 tdata->cipher_iv.len);
4654 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4655 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4656 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4657 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4659 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4660 plaintext_pad_len, 15, 0);
4661 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4662 "Failed to allocate input buffer in mempool");
4664 if (op_mode == OUT_OF_PLACE) {
4665 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4666 plaintext_pad_len, 15, 0);
4667 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4668 "Failed to allocate output buffer in mempool");
4672 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4673 tdata->ciphertext.data);
4674 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4675 ciphertext_len, buffer);
4676 debug_hexdump(stdout, "ciphertext:", ciphertext,
4679 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4680 tdata->plaintext.data);
4681 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4682 plaintext_len, buffer);
4683 debug_hexdump(stdout, "plaintext:", plaintext,
4686 memset(buffer, 0, sizeof(buffer));
4688 /* Create KASUMI operation */
4689 retval = create_wireless_algo_auth_cipher_operation(
4690 tdata->digest.data, tdata->digest.len,
4691 tdata->cipher_iv.data, tdata->cipher_iv.len,
4693 (tdata->digest.offset_bytes == 0 ?
4694 (verify ? ciphertext_pad_len : plaintext_pad_len)
4695 : tdata->digest.offset_bytes),
4696 tdata->validCipherLenInBits.len,
4697 tdata->validCipherOffsetInBits.len,
4698 tdata->validAuthLenInBits.len,
4700 op_mode, 1, verify);
4705 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4708 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4710 ut_params->obuf = (op_mode == IN_PLACE ?
4711 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4714 if (ut_params->obuf)
4715 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4716 plaintext_len, buffer);
4718 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4719 plaintext_len, buffer);
4721 debug_hexdump(stdout, "plaintext:", plaintext,
4722 (tdata->plaintext.len >> 3) - tdata->digest.len);
4723 debug_hexdump(stdout, "plaintext expected:",
4724 tdata->plaintext.data,
4725 (tdata->plaintext.len >> 3) - tdata->digest.len);
4727 if (ut_params->obuf)
4728 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4729 ciphertext_len, buffer);
4731 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4732 ciphertext_len, buffer);
4734 debug_hexdump(stdout, "ciphertext:", ciphertext,
4736 debug_hexdump(stdout, "ciphertext expected:",
4737 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4739 if (ut_params->obuf)
4740 digest = rte_pktmbuf_read(ut_params->obuf,
4741 (tdata->digest.offset_bytes == 0 ?
4742 plaintext_pad_len : tdata->digest.offset_bytes),
4743 tdata->digest.len, digest_buffer);
4745 digest = rte_pktmbuf_read(ut_params->ibuf,
4746 (tdata->digest.offset_bytes == 0 ?
4747 plaintext_pad_len : tdata->digest.offset_bytes),
4748 tdata->digest.len, digest_buffer);
4750 debug_hexdump(stdout, "digest:", digest,
4752 debug_hexdump(stdout, "digest expected:",
4753 tdata->digest.data, tdata->digest.len);
4758 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4760 tdata->plaintext.data,
4761 tdata->plaintext.len >> 3,
4762 "KASUMI Plaintext data not as expected");
4764 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4766 tdata->ciphertext.data,
4767 tdata->validDataLenInBits.len,
4768 "KASUMI Ciphertext data not as expected");
4770 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4773 DIGEST_BYTE_LENGTH_KASUMI_F9,
4774 "KASUMI Generated auth tag not as expected");
4780 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4782 struct crypto_testsuite_params *ts_params = &testsuite_params;
4783 struct crypto_unittest_params *ut_params = &unittest_params;
4787 uint8_t *plaintext, *ciphertext;
4788 unsigned plaintext_pad_len;
4789 unsigned plaintext_len;
4791 /* Verify the capabilities */
4792 struct rte_cryptodev_sym_capability_idx cap_idx;
4793 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4794 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4795 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4798 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4799 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4800 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4804 /* Create KASUMI session */
4805 retval = create_wireless_algo_cipher_auth_session(
4806 ts_params->valid_devs[0],
4807 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4808 RTE_CRYPTO_AUTH_OP_GENERATE,
4809 RTE_CRYPTO_AUTH_KASUMI_F9,
4810 RTE_CRYPTO_CIPHER_KASUMI_F8,
4811 tdata->key.data, tdata->key.len,
4812 0, tdata->digest.len,
4813 tdata->cipher_iv.len);
4817 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4819 /* clear mbuf payload */
4820 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4821 rte_pktmbuf_tailroom(ut_params->ibuf));
4823 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4824 /* Append data which is padded to a multiple of */
4825 /* the algorithms block size */
4826 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4827 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4829 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4831 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4833 /* Create KASUMI operation */
4834 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4835 tdata->digest.len, NULL, 0,
4836 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4837 tdata->cipher_iv.data, tdata->cipher_iv.len,
4838 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4839 tdata->validCipherOffsetInBits.len,
4840 tdata->validAuthLenInBits.len,
4846 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4848 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4850 if (ut_params->op->sym->m_dst)
4851 ut_params->obuf = ut_params->op->sym->m_dst;
4853 ut_params->obuf = ut_params->op->sym->m_src;
4855 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4856 tdata->validCipherOffsetInBits.len >> 3);
4858 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4859 + plaintext_pad_len;
4861 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4862 (tdata->validCipherOffsetInBits.len >> 3);
4864 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4866 reference_ciphertext,
4867 tdata->validCipherLenInBits.len,
4868 "KASUMI Ciphertext data not as expected");
4871 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4874 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4875 "KASUMI Generated auth tag not as expected");
4880 test_zuc_encryption(const struct wireless_test_data *tdata)
4882 struct crypto_testsuite_params *ts_params = &testsuite_params;
4883 struct crypto_unittest_params *ut_params = &unittest_params;
4886 uint8_t *plaintext, *ciphertext;
4887 unsigned plaintext_pad_len;
4888 unsigned plaintext_len;
4890 struct rte_cryptodev_sym_capability_idx cap_idx;
4892 /* Check if device supports ZUC EEA3 */
4893 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4894 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4896 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4900 /* Create ZUC session */
4901 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4902 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4903 RTE_CRYPTO_CIPHER_ZUC_EEA3,
4904 tdata->key.data, tdata->key.len,
4905 tdata->cipher_iv.len);
4909 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4911 /* Clear mbuf payload */
4912 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4913 rte_pktmbuf_tailroom(ut_params->ibuf));
4915 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4916 /* Append data which is padded to a multiple */
4917 /* of the algorithms block size */
4918 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4919 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4921 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4923 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4925 /* Create ZUC operation */
4926 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4927 tdata->cipher_iv.len,
4928 tdata->plaintext.len,
4933 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4935 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4937 ut_params->obuf = ut_params->op->sym->m_dst;
4938 if (ut_params->obuf)
4939 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4941 ciphertext = plaintext;
4943 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4946 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4948 tdata->ciphertext.data,
4949 tdata->validCipherLenInBits.len,
4950 "ZUC Ciphertext data not as expected");
4955 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4957 struct crypto_testsuite_params *ts_params = &testsuite_params;
4958 struct crypto_unittest_params *ut_params = &unittest_params;
4962 unsigned int plaintext_pad_len;
4963 unsigned int plaintext_len;
4964 const uint8_t *ciphertext;
4965 uint8_t ciphertext_buffer[2048];
4966 struct rte_cryptodev_info dev_info;
4968 struct rte_cryptodev_sym_capability_idx cap_idx;
4970 /* Check if device supports ZUC EEA3 */
4971 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4972 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4974 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4978 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4980 uint64_t feat_flags = dev_info.feature_flags;
4982 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4983 printf("Device doesn't support in-place scatter-gather. "
4988 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4990 /* Append data which is padded to a multiple */
4991 /* of the algorithms block size */
4992 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4994 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4995 plaintext_pad_len, 10, 0);
4997 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4998 tdata->plaintext.data);
5000 /* Create ZUC session */
5001 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5002 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5003 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5004 tdata->key.data, tdata->key.len,
5005 tdata->cipher_iv.len);
5009 /* Clear mbuf payload */
5011 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5013 /* Create ZUC operation */
5014 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5015 tdata->cipher_iv.len, tdata->plaintext.len,
5020 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5022 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5024 ut_params->obuf = ut_params->op->sym->m_dst;
5025 if (ut_params->obuf)
5026 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5027 0, plaintext_len, ciphertext_buffer);
5029 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5030 0, plaintext_len, ciphertext_buffer);
5033 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5036 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5038 tdata->ciphertext.data,
5039 tdata->validCipherLenInBits.len,
5040 "ZUC Ciphertext data not as expected");
5046 test_zuc_authentication(const struct wireless_test_data *tdata)
5048 struct crypto_testsuite_params *ts_params = &testsuite_params;
5049 struct crypto_unittest_params *ut_params = &unittest_params;
5052 unsigned plaintext_pad_len;
5053 unsigned plaintext_len;
5056 struct rte_cryptodev_sym_capability_idx cap_idx;
5057 struct rte_cryptodev_info dev_info;
5059 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5060 uint64_t feat_flags = dev_info.feature_flags;
5062 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5063 (tdata->validAuthLenInBits.len % 8 != 0)) {
5064 printf("Device doesn't support NON-Byte Aligned Data.\n");
5068 /* Check if device supports ZUC EIA3 */
5069 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5070 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5072 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5076 /* Create ZUC session */
5077 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5078 tdata->key.data, tdata->key.len,
5079 tdata->auth_iv.len, tdata->digest.len,
5080 RTE_CRYPTO_AUTH_OP_GENERATE,
5081 RTE_CRYPTO_AUTH_ZUC_EIA3);
5085 /* alloc mbuf and set payload */
5086 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5088 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5089 rte_pktmbuf_tailroom(ut_params->ibuf));
5091 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5092 /* Append data which is padded to a multiple of */
5093 /* the algorithms block size */
5094 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5095 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5097 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5099 /* Create ZUC operation */
5100 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5101 tdata->auth_iv.data, tdata->auth_iv.len,
5102 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5103 tdata->validAuthLenInBits.len,
5108 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5110 ut_params->obuf = ut_params->op->sym->m_src;
5111 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5112 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5113 + plaintext_pad_len;
5116 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5120 "ZUC Generated auth tag not as expected");
5126 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5127 uint8_t op_mode, uint8_t verify)
5129 struct crypto_testsuite_params *ts_params = &testsuite_params;
5130 struct crypto_unittest_params *ut_params = &unittest_params;
5134 uint8_t *plaintext = NULL, *ciphertext = NULL;
5135 unsigned int plaintext_pad_len;
5136 unsigned int plaintext_len;
5137 unsigned int ciphertext_pad_len;
5138 unsigned int ciphertext_len;
5140 struct rte_cryptodev_info dev_info;
5141 struct rte_cryptodev_sym_capability_idx cap_idx;
5143 /* Check if device supports ZUC EIA3 */
5144 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5145 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5147 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5151 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5153 uint64_t feat_flags = dev_info.feature_flags;
5155 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5156 printf("Device doesn't support digest encrypted.\n");
5159 if (op_mode == IN_PLACE) {
5160 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5161 printf("Device doesn't support in-place scatter-gather "
5162 "in both input and output mbufs.\n");
5166 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5167 printf("Device doesn't support out-of-place scatter-gather "
5168 "in both input and output mbufs.\n");
5173 /* Create ZUC session */
5174 retval = create_wireless_algo_auth_cipher_session(
5175 ts_params->valid_devs[0],
5176 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5177 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5178 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5179 : RTE_CRYPTO_AUTH_OP_GENERATE),
5180 RTE_CRYPTO_AUTH_ZUC_EIA3,
5181 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5182 tdata->key.data, tdata->key.len,
5183 tdata->auth_iv.len, tdata->digest.len,
5184 tdata->cipher_iv.len);
5189 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5190 if (op_mode == OUT_OF_PLACE)
5191 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5193 /* clear mbuf payload */
5194 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5195 rte_pktmbuf_tailroom(ut_params->ibuf));
5196 if (op_mode == OUT_OF_PLACE)
5197 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5198 rte_pktmbuf_tailroom(ut_params->obuf));
5200 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5201 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5202 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5203 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5206 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5207 ciphertext_pad_len);
5208 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5209 if (op_mode == OUT_OF_PLACE)
5210 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5211 debug_hexdump(stdout, "ciphertext:", ciphertext,
5214 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5216 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5217 if (op_mode == OUT_OF_PLACE)
5218 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5219 debug_hexdump(stdout, "plaintext:", plaintext,
5223 /* Create ZUC operation */
5224 retval = create_wireless_algo_auth_cipher_operation(
5225 tdata->digest.data, tdata->digest.len,
5226 tdata->cipher_iv.data, tdata->cipher_iv.len,
5227 tdata->auth_iv.data, tdata->auth_iv.len,
5228 (tdata->digest.offset_bytes == 0 ?
5229 (verify ? ciphertext_pad_len : plaintext_pad_len)
5230 : tdata->digest.offset_bytes),
5231 tdata->validCipherLenInBits.len,
5232 tdata->validCipherOffsetInBits.len,
5233 tdata->validAuthLenInBits.len,
5235 op_mode, 0, verify);
5240 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5243 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5245 ut_params->obuf = (op_mode == IN_PLACE ?
5246 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5250 if (ut_params->obuf)
5251 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5254 plaintext = ciphertext;
5256 debug_hexdump(stdout, "plaintext:", plaintext,
5257 (tdata->plaintext.len >> 3) - tdata->digest.len);
5258 debug_hexdump(stdout, "plaintext expected:",
5259 tdata->plaintext.data,
5260 (tdata->plaintext.len >> 3) - tdata->digest.len);
5262 if (ut_params->obuf)
5263 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5266 ciphertext = plaintext;
5268 debug_hexdump(stdout, "ciphertext:", ciphertext,
5270 debug_hexdump(stdout, "ciphertext expected:",
5271 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5273 ut_params->digest = rte_pktmbuf_mtod(
5274 ut_params->obuf, uint8_t *) +
5275 (tdata->digest.offset_bytes == 0 ?
5276 plaintext_pad_len : tdata->digest.offset_bytes);
5278 debug_hexdump(stdout, "digest:", ut_params->digest,
5280 debug_hexdump(stdout, "digest expected:",
5281 tdata->digest.data, tdata->digest.len);
5286 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5288 tdata->plaintext.data,
5289 tdata->plaintext.len >> 3,
5290 "ZUC Plaintext data not as expected");
5292 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5294 tdata->ciphertext.data,
5295 tdata->ciphertext.len >> 3,
5296 "ZUC Ciphertext data not as expected");
5298 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5301 DIGEST_BYTE_LENGTH_KASUMI_F9,
5302 "ZUC Generated auth tag not as expected");
5308 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5309 uint8_t op_mode, uint8_t verify)
5311 struct crypto_testsuite_params *ts_params = &testsuite_params;
5312 struct crypto_unittest_params *ut_params = &unittest_params;
5316 const uint8_t *plaintext = NULL;
5317 const uint8_t *ciphertext = NULL;
5318 const uint8_t *digest = NULL;
5319 unsigned int plaintext_pad_len;
5320 unsigned int plaintext_len;
5321 unsigned int ciphertext_pad_len;
5322 unsigned int ciphertext_len;
5323 uint8_t buffer[10000];
5324 uint8_t digest_buffer[10000];
5326 struct rte_cryptodev_info dev_info;
5327 struct rte_cryptodev_sym_capability_idx cap_idx;
5329 /* Check if device supports ZUC EIA3 */
5330 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5331 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5333 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5337 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5339 uint64_t feat_flags = dev_info.feature_flags;
5341 if (op_mode == IN_PLACE) {
5342 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5343 printf("Device doesn't support in-place scatter-gather "
5344 "in both input and output mbufs.\n");
5348 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5349 printf("Device doesn't support out-of-place scatter-gather "
5350 "in both input and output mbufs.\n");
5353 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5354 printf("Device doesn't support digest encrypted.\n");
5359 /* Create ZUC session */
5360 retval = create_wireless_algo_auth_cipher_session(
5361 ts_params->valid_devs[0],
5362 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5363 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5364 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5365 : RTE_CRYPTO_AUTH_OP_GENERATE),
5366 RTE_CRYPTO_AUTH_ZUC_EIA3,
5367 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5368 tdata->key.data, tdata->key.len,
5369 tdata->auth_iv.len, tdata->digest.len,
5370 tdata->cipher_iv.len);
5375 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5376 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5377 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5378 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5380 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5381 plaintext_pad_len, 15, 0);
5382 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5383 "Failed to allocate input buffer in mempool");
5385 if (op_mode == OUT_OF_PLACE) {
5386 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5387 plaintext_pad_len, 15, 0);
5388 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5389 "Failed to allocate output buffer in mempool");
5393 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5394 tdata->ciphertext.data);
5395 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5396 ciphertext_len, buffer);
5397 debug_hexdump(stdout, "ciphertext:", ciphertext,
5400 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5401 tdata->plaintext.data);
5402 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5403 plaintext_len, buffer);
5404 debug_hexdump(stdout, "plaintext:", plaintext,
5407 memset(buffer, 0, sizeof(buffer));
5409 /* Create ZUC operation */
5410 retval = create_wireless_algo_auth_cipher_operation(
5411 tdata->digest.data, tdata->digest.len,
5412 tdata->cipher_iv.data, tdata->cipher_iv.len,
5414 (tdata->digest.offset_bytes == 0 ?
5415 (verify ? ciphertext_pad_len : plaintext_pad_len)
5416 : tdata->digest.offset_bytes),
5417 tdata->validCipherLenInBits.len,
5418 tdata->validCipherOffsetInBits.len,
5419 tdata->validAuthLenInBits.len,
5421 op_mode, 1, verify);
5426 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5429 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5431 ut_params->obuf = (op_mode == IN_PLACE ?
5432 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5435 if (ut_params->obuf)
5436 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5437 plaintext_len, buffer);
5439 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5440 plaintext_len, buffer);
5442 debug_hexdump(stdout, "plaintext:", plaintext,
5443 (tdata->plaintext.len >> 3) - tdata->digest.len);
5444 debug_hexdump(stdout, "plaintext expected:",
5445 tdata->plaintext.data,
5446 (tdata->plaintext.len >> 3) - tdata->digest.len);
5448 if (ut_params->obuf)
5449 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5450 ciphertext_len, buffer);
5452 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5453 ciphertext_len, buffer);
5455 debug_hexdump(stdout, "ciphertext:", ciphertext,
5457 debug_hexdump(stdout, "ciphertext expected:",
5458 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5460 if (ut_params->obuf)
5461 digest = rte_pktmbuf_read(ut_params->obuf,
5462 (tdata->digest.offset_bytes == 0 ?
5463 plaintext_pad_len : tdata->digest.offset_bytes),
5464 tdata->digest.len, digest_buffer);
5466 digest = rte_pktmbuf_read(ut_params->ibuf,
5467 (tdata->digest.offset_bytes == 0 ?
5468 plaintext_pad_len : tdata->digest.offset_bytes),
5469 tdata->digest.len, digest_buffer);
5471 debug_hexdump(stdout, "digest:", digest,
5473 debug_hexdump(stdout, "digest expected:",
5474 tdata->digest.data, tdata->digest.len);
5479 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5481 tdata->plaintext.data,
5482 tdata->plaintext.len >> 3,
5483 "ZUC Plaintext data not as expected");
5485 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5487 tdata->ciphertext.data,
5488 tdata->validDataLenInBits.len,
5489 "ZUC Ciphertext data not as expected");
5491 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5494 DIGEST_BYTE_LENGTH_KASUMI_F9,
5495 "ZUC Generated auth tag not as expected");
5501 test_kasumi_encryption_test_case_1(void)
5503 return test_kasumi_encryption(&kasumi_test_case_1);
5507 test_kasumi_encryption_test_case_1_sgl(void)
5509 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
5513 test_kasumi_encryption_test_case_1_oop(void)
5515 return test_kasumi_encryption_oop(&kasumi_test_case_1);
5519 test_kasumi_encryption_test_case_1_oop_sgl(void)
5521 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
5525 test_kasumi_encryption_test_case_2(void)
5527 return test_kasumi_encryption(&kasumi_test_case_2);
5531 test_kasumi_encryption_test_case_3(void)
5533 return test_kasumi_encryption(&kasumi_test_case_3);
5537 test_kasumi_encryption_test_case_4(void)
5539 return test_kasumi_encryption(&kasumi_test_case_4);
5543 test_kasumi_encryption_test_case_5(void)
5545 return test_kasumi_encryption(&kasumi_test_case_5);
5549 test_kasumi_decryption_test_case_1(void)
5551 return test_kasumi_decryption(&kasumi_test_case_1);
5555 test_kasumi_decryption_test_case_1_oop(void)
5557 return test_kasumi_decryption_oop(&kasumi_test_case_1);
5561 test_kasumi_decryption_test_case_2(void)
5563 return test_kasumi_decryption(&kasumi_test_case_2);
5567 test_kasumi_decryption_test_case_3(void)
5569 return test_kasumi_decryption(&kasumi_test_case_3);
5573 test_kasumi_decryption_test_case_4(void)
5575 return test_kasumi_decryption(&kasumi_test_case_4);
5579 test_kasumi_decryption_test_case_5(void)
5581 return test_kasumi_decryption(&kasumi_test_case_5);
5584 test_snow3g_encryption_test_case_1(void)
5586 return test_snow3g_encryption(&snow3g_test_case_1);
5590 test_snow3g_encryption_test_case_1_oop(void)
5592 return test_snow3g_encryption_oop(&snow3g_test_case_1);
5596 test_snow3g_encryption_test_case_1_oop_sgl(void)
5598 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
5603 test_snow3g_encryption_test_case_1_offset_oop(void)
5605 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
5609 test_snow3g_encryption_test_case_2(void)
5611 return test_snow3g_encryption(&snow3g_test_case_2);
5615 test_snow3g_encryption_test_case_3(void)
5617 return test_snow3g_encryption(&snow3g_test_case_3);
5621 test_snow3g_encryption_test_case_4(void)
5623 return test_snow3g_encryption(&snow3g_test_case_4);
5627 test_snow3g_encryption_test_case_5(void)
5629 return test_snow3g_encryption(&snow3g_test_case_5);
5633 test_snow3g_decryption_test_case_1(void)
5635 return test_snow3g_decryption(&snow3g_test_case_1);
5639 test_snow3g_decryption_test_case_1_oop(void)
5641 return test_snow3g_decryption_oop(&snow3g_test_case_1);
5645 test_snow3g_decryption_test_case_2(void)
5647 return test_snow3g_decryption(&snow3g_test_case_2);
5651 test_snow3g_decryption_test_case_3(void)
5653 return test_snow3g_decryption(&snow3g_test_case_3);
5657 test_snow3g_decryption_test_case_4(void)
5659 return test_snow3g_decryption(&snow3g_test_case_4);
5663 test_snow3g_decryption_test_case_5(void)
5665 return test_snow3g_decryption(&snow3g_test_case_5);
5669 * Function prepares snow3g_hash_test_data from snow3g_test_data.
5670 * Pattern digest from snow3g_test_data must be allocated as
5671 * 4 last bytes in plaintext.
5674 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
5675 struct snow3g_hash_test_data *output)
5677 if ((pattern != NULL) && (output != NULL)) {
5678 output->key.len = pattern->key.len;
5680 memcpy(output->key.data,
5681 pattern->key.data, pattern->key.len);
5683 output->auth_iv.len = pattern->auth_iv.len;
5685 memcpy(output->auth_iv.data,
5686 pattern->auth_iv.data, pattern->auth_iv.len);
5688 output->plaintext.len = pattern->plaintext.len;
5690 memcpy(output->plaintext.data,
5691 pattern->plaintext.data, pattern->plaintext.len >> 3);
5693 output->digest.len = pattern->digest.len;
5695 memcpy(output->digest.data,
5696 &pattern->plaintext.data[pattern->digest.offset_bytes],
5697 pattern->digest.len);
5699 output->validAuthLenInBits.len =
5700 pattern->validAuthLenInBits.len;
5705 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
5708 test_snow3g_decryption_with_digest_test_case_1(void)
5710 struct snow3g_hash_test_data snow3g_hash_data;
5713 * Function prepare data for hash veryfication test case.
5714 * Digest is allocated in 4 last bytes in plaintext, pattern.
5716 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
5718 return test_snow3g_decryption(&snow3g_test_case_7) &
5719 test_snow3g_authentication_verify(&snow3g_hash_data);
5723 test_snow3g_cipher_auth_test_case_1(void)
5725 return test_snow3g_cipher_auth(&snow3g_test_case_3);
5729 test_snow3g_auth_cipher_test_case_1(void)
5731 return test_snow3g_auth_cipher(
5732 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
5736 test_snow3g_auth_cipher_test_case_2(void)
5738 return test_snow3g_auth_cipher(
5739 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
5743 test_snow3g_auth_cipher_test_case_2_oop(void)
5745 return test_snow3g_auth_cipher(
5746 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5750 test_snow3g_auth_cipher_part_digest_enc(void)
5752 return test_snow3g_auth_cipher(
5753 &snow3g_auth_cipher_partial_digest_encryption,
5758 test_snow3g_auth_cipher_part_digest_enc_oop(void)
5760 return test_snow3g_auth_cipher(
5761 &snow3g_auth_cipher_partial_digest_encryption,
5766 test_snow3g_auth_cipher_test_case_3_sgl(void)
5768 return test_snow3g_auth_cipher_sgl(
5769 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
5773 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
5775 return test_snow3g_auth_cipher_sgl(
5776 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
5780 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
5782 return test_snow3g_auth_cipher_sgl(
5783 &snow3g_auth_cipher_partial_digest_encryption,
5788 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
5790 return test_snow3g_auth_cipher_sgl(
5791 &snow3g_auth_cipher_partial_digest_encryption,
5796 test_snow3g_auth_cipher_verify_test_case_1(void)
5798 return test_snow3g_auth_cipher(
5799 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
5803 test_snow3g_auth_cipher_verify_test_case_2(void)
5805 return test_snow3g_auth_cipher(
5806 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
5810 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
5812 return test_snow3g_auth_cipher(
5813 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5817 test_snow3g_auth_cipher_verify_part_digest_enc(void)
5819 return test_snow3g_auth_cipher(
5820 &snow3g_auth_cipher_partial_digest_encryption,
5825 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
5827 return test_snow3g_auth_cipher(
5828 &snow3g_auth_cipher_partial_digest_encryption,
5833 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
5835 return test_snow3g_auth_cipher_sgl(
5836 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
5840 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
5842 return test_snow3g_auth_cipher_sgl(
5843 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
5847 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
5849 return test_snow3g_auth_cipher_sgl(
5850 &snow3g_auth_cipher_partial_digest_encryption,
5855 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
5857 return test_snow3g_auth_cipher_sgl(
5858 &snow3g_auth_cipher_partial_digest_encryption,
5863 test_snow3g_auth_cipher_with_digest_test_case_1(void)
5865 return test_snow3g_auth_cipher(
5866 &snow3g_test_case_7, IN_PLACE, 0);
5870 test_kasumi_auth_cipher_test_case_1(void)
5872 return test_kasumi_auth_cipher(
5873 &kasumi_test_case_3, IN_PLACE, 0);
5877 test_kasumi_auth_cipher_test_case_2(void)
5879 return test_kasumi_auth_cipher(
5880 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
5884 test_kasumi_auth_cipher_test_case_2_oop(void)
5886 return test_kasumi_auth_cipher(
5887 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5891 test_kasumi_auth_cipher_test_case_2_sgl(void)
5893 return test_kasumi_auth_cipher_sgl(
5894 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
5898 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
5900 return test_kasumi_auth_cipher_sgl(
5901 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5905 test_kasumi_auth_cipher_verify_test_case_1(void)
5907 return test_kasumi_auth_cipher(
5908 &kasumi_test_case_3, IN_PLACE, 1);
5912 test_kasumi_auth_cipher_verify_test_case_2(void)
5914 return test_kasumi_auth_cipher(
5915 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
5919 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
5921 return test_kasumi_auth_cipher(
5922 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5926 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
5928 return test_kasumi_auth_cipher_sgl(
5929 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
5933 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
5935 return test_kasumi_auth_cipher_sgl(
5936 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5940 test_kasumi_cipher_auth_test_case_1(void)
5942 return test_kasumi_cipher_auth(&kasumi_test_case_6);
5946 test_zuc_encryption_test_case_1(void)
5948 return test_zuc_encryption(&zuc_test_case_cipher_193b);
5952 test_zuc_encryption_test_case_2(void)
5954 return test_zuc_encryption(&zuc_test_case_cipher_800b);
5958 test_zuc_encryption_test_case_3(void)
5960 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
5964 test_zuc_encryption_test_case_4(void)
5966 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
5970 test_zuc_encryption_test_case_5(void)
5972 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
5976 test_zuc_encryption_test_case_6_sgl(void)
5978 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
5982 test_zuc_hash_generate_test_case_1(void)
5984 return test_zuc_authentication(&zuc_test_case_auth_1b);
5988 test_zuc_hash_generate_test_case_2(void)
5990 return test_zuc_authentication(&zuc_test_case_auth_90b);
5994 test_zuc_hash_generate_test_case_3(void)
5996 return test_zuc_authentication(&zuc_test_case_auth_577b);
6000 test_zuc_hash_generate_test_case_4(void)
6002 return test_zuc_authentication(&zuc_test_case_auth_2079b);
6006 test_zuc_hash_generate_test_case_5(void)
6008 return test_zuc_authentication(&zuc_test_auth_5670b);
6012 test_zuc_hash_generate_test_case_6(void)
6014 return test_zuc_authentication(&zuc_test_case_auth_128b);
6018 test_zuc_hash_generate_test_case_7(void)
6020 return test_zuc_authentication(&zuc_test_case_auth_2080b);
6024 test_zuc_hash_generate_test_case_8(void)
6026 return test_zuc_authentication(&zuc_test_case_auth_584b);
6030 test_zuc_cipher_auth_test_case_1(void)
6032 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6036 test_zuc_cipher_auth_test_case_2(void)
6038 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6042 test_zuc_auth_cipher_test_case_1(void)
6044 return test_zuc_auth_cipher(
6045 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6049 test_zuc_auth_cipher_test_case_1_oop(void)
6051 return test_zuc_auth_cipher(
6052 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6056 test_zuc_auth_cipher_test_case_1_sgl(void)
6058 return test_zuc_auth_cipher_sgl(
6059 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6063 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6065 return test_zuc_auth_cipher_sgl(
6066 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6070 test_zuc_auth_cipher_verify_test_case_1(void)
6072 return test_zuc_auth_cipher(
6073 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6077 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6079 return test_zuc_auth_cipher(
6080 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6084 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6086 return test_zuc_auth_cipher_sgl(
6087 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6091 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6093 return test_zuc_auth_cipher_sgl(
6094 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6098 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6100 uint8_t dev_id = testsuite_params.valid_devs[0];
6102 struct rte_cryptodev_sym_capability_idx cap_idx;
6104 /* Check if device supports particular cipher algorithm */
6105 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6106 cap_idx.algo.cipher = tdata->cipher_algo;
6107 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6110 /* Check if device supports particular hash algorithm */
6111 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6112 cap_idx.algo.auth = tdata->auth_algo;
6113 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6120 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6121 uint8_t op_mode, uint8_t verify)
6123 struct crypto_testsuite_params *ts_params = &testsuite_params;
6124 struct crypto_unittest_params *ut_params = &unittest_params;
6128 uint8_t *plaintext = NULL, *ciphertext = NULL;
6129 unsigned int plaintext_pad_len;
6130 unsigned int plaintext_len;
6131 unsigned int ciphertext_pad_len;
6132 unsigned int ciphertext_len;
6134 struct rte_cryptodev_info dev_info;
6135 struct rte_crypto_op *op;
6137 /* Check if device supports particular algorithms separately */
6138 if (test_mixed_check_if_unsupported(tdata))
6141 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6143 uint64_t feat_flags = dev_info.feature_flags;
6145 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6146 printf("Device doesn't support digest encrypted.\n");
6150 /* Create the session */
6152 retval = create_wireless_algo_cipher_auth_session(
6153 ts_params->valid_devs[0],
6154 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6155 RTE_CRYPTO_AUTH_OP_VERIFY,
6158 tdata->auth_key.data, tdata->auth_key.len,
6159 tdata->auth_iv.len, tdata->digest_enc.len,
6160 tdata->cipher_iv.len);
6162 retval = create_wireless_algo_auth_cipher_session(
6163 ts_params->valid_devs[0],
6164 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6165 RTE_CRYPTO_AUTH_OP_GENERATE,
6168 tdata->auth_key.data, tdata->auth_key.len,
6169 tdata->auth_iv.len, tdata->digest_enc.len,
6170 tdata->cipher_iv.len);
6174 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6175 if (op_mode == OUT_OF_PLACE)
6176 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6178 /* clear mbuf payload */
6179 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6180 rte_pktmbuf_tailroom(ut_params->ibuf));
6181 if (op_mode == OUT_OF_PLACE)
6182 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6183 rte_pktmbuf_tailroom(ut_params->obuf));
6185 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6186 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6187 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6188 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6191 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6192 ciphertext_pad_len);
6193 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6194 if (op_mode == OUT_OF_PLACE)
6195 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6196 debug_hexdump(stdout, "ciphertext:", ciphertext,
6199 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6201 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6202 if (op_mode == OUT_OF_PLACE)
6203 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6204 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6207 /* Create the operation */
6208 retval = create_wireless_algo_auth_cipher_operation(
6209 tdata->digest_enc.data, tdata->digest_enc.len,
6210 tdata->cipher_iv.data, tdata->cipher_iv.len,
6211 tdata->auth_iv.data, tdata->auth_iv.len,
6212 (tdata->digest_enc.offset == 0 ?
6214 : tdata->digest_enc.offset),
6215 tdata->validCipherLen.len_bits,
6216 tdata->cipher.offset_bits,
6217 tdata->validAuthLen.len_bits,
6218 tdata->auth.offset_bits,
6219 op_mode, 0, verify);
6224 op = process_crypto_request(ts_params->valid_devs[0],
6227 /* Check if the op failed because the device doesn't */
6228 /* support this particular combination of algorithms */
6229 if (op == NULL && ut_params->op->status ==
6230 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6231 printf("Device doesn't support this mixed combination. "
6237 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6239 ut_params->obuf = (op_mode == IN_PLACE ?
6240 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6243 if (ut_params->obuf)
6244 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6247 plaintext = ciphertext +
6248 (tdata->cipher.offset_bits >> 3);
6250 debug_hexdump(stdout, "plaintext:", plaintext,
6251 tdata->plaintext.len_bits >> 3);
6252 debug_hexdump(stdout, "plaintext expected:",
6253 tdata->plaintext.data,
6254 tdata->plaintext.len_bits >> 3);
6256 if (ut_params->obuf)
6257 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6260 ciphertext = plaintext;
6262 debug_hexdump(stdout, "ciphertext:", ciphertext,
6264 debug_hexdump(stdout, "ciphertext expected:",
6265 tdata->ciphertext.data,
6266 tdata->ciphertext.len_bits >> 3);
6268 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6269 + (tdata->digest_enc.offset == 0 ?
6270 plaintext_pad_len : tdata->digest_enc.offset);
6272 debug_hexdump(stdout, "digest:", ut_params->digest,
6273 tdata->digest_enc.len);
6274 debug_hexdump(stdout, "digest expected:",
6275 tdata->digest_enc.data,
6276 tdata->digest_enc.len);
6281 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6283 tdata->plaintext.data,
6284 tdata->plaintext.len_bits >> 3,
6285 "Plaintext data not as expected");
6287 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6289 tdata->ciphertext.data,
6290 tdata->validDataLen.len_bits,
6291 "Ciphertext data not as expected");
6293 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6295 tdata->digest_enc.data,
6296 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6297 "Generated auth tag not as expected");
6300 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6301 "crypto op processing failed");
6307 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6308 uint8_t op_mode, uint8_t verify)
6310 struct crypto_testsuite_params *ts_params = &testsuite_params;
6311 struct crypto_unittest_params *ut_params = &unittest_params;
6315 const uint8_t *plaintext = NULL;
6316 const uint8_t *ciphertext = NULL;
6317 const uint8_t *digest = NULL;
6318 unsigned int plaintext_pad_len;
6319 unsigned int plaintext_len;
6320 unsigned int ciphertext_pad_len;
6321 unsigned int ciphertext_len;
6322 uint8_t buffer[10000];
6323 uint8_t digest_buffer[10000];
6325 struct rte_cryptodev_info dev_info;
6326 struct rte_crypto_op *op;
6328 /* Check if device supports particular algorithms */
6329 if (test_mixed_check_if_unsupported(tdata))
6332 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6334 uint64_t feat_flags = dev_info.feature_flags;
6336 if (op_mode == IN_PLACE) {
6337 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6338 printf("Device doesn't support in-place scatter-gather "
6339 "in both input and output mbufs.\n");
6343 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6344 printf("Device doesn't support out-of-place scatter-gather "
6345 "in both input and output mbufs.\n");
6348 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6349 printf("Device doesn't support digest encrypted.\n");
6354 /* Create the session */
6356 retval = create_wireless_algo_cipher_auth_session(
6357 ts_params->valid_devs[0],
6358 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6359 RTE_CRYPTO_AUTH_OP_VERIFY,
6362 tdata->auth_key.data, tdata->auth_key.len,
6363 tdata->auth_iv.len, tdata->digest_enc.len,
6364 tdata->cipher_iv.len);
6366 retval = create_wireless_algo_auth_cipher_session(
6367 ts_params->valid_devs[0],
6368 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6369 RTE_CRYPTO_AUTH_OP_GENERATE,
6372 tdata->auth_key.data, tdata->auth_key.len,
6373 tdata->auth_iv.len, tdata->digest_enc.len,
6374 tdata->cipher_iv.len);
6378 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6379 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6380 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6381 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6383 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6384 ciphertext_pad_len, 15, 0);
6385 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6386 "Failed to allocate input buffer in mempool");
6388 if (op_mode == OUT_OF_PLACE) {
6389 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6390 plaintext_pad_len, 15, 0);
6391 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6392 "Failed to allocate output buffer in mempool");
6396 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6397 tdata->ciphertext.data);
6398 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6399 ciphertext_len, buffer);
6400 debug_hexdump(stdout, "ciphertext:", ciphertext,
6403 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6404 tdata->plaintext.data);
6405 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6406 plaintext_len, buffer);
6407 debug_hexdump(stdout, "plaintext:", plaintext,
6410 memset(buffer, 0, sizeof(buffer));
6412 /* Create the operation */
6413 retval = create_wireless_algo_auth_cipher_operation(
6414 tdata->digest_enc.data, tdata->digest_enc.len,
6415 tdata->cipher_iv.data, tdata->cipher_iv.len,
6416 tdata->auth_iv.data, tdata->auth_iv.len,
6417 (tdata->digest_enc.offset == 0 ?
6419 : tdata->digest_enc.offset),
6420 tdata->validCipherLen.len_bits,
6421 tdata->cipher.offset_bits,
6422 tdata->validAuthLen.len_bits,
6423 tdata->auth.offset_bits,
6424 op_mode, 1, verify);
6429 op = process_crypto_request(ts_params->valid_devs[0],
6432 /* Check if the op failed because the device doesn't */
6433 /* support this particular combination of algorithms */
6434 if (op == NULL && ut_params->op->status ==
6435 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6436 printf("Device doesn't support this mixed combination. "
6443 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6445 ut_params->obuf = (op_mode == IN_PLACE ?
6446 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6449 if (ut_params->obuf)
6450 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6451 plaintext_len, buffer);
6453 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6454 plaintext_len, buffer);
6456 debug_hexdump(stdout, "plaintext:", plaintext,
6457 (tdata->plaintext.len_bits >> 3) -
6458 tdata->digest_enc.len);
6459 debug_hexdump(stdout, "plaintext expected:",
6460 tdata->plaintext.data,
6461 (tdata->plaintext.len_bits >> 3) -
6462 tdata->digest_enc.len);
6464 if (ut_params->obuf)
6465 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6466 ciphertext_len, buffer);
6468 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6469 ciphertext_len, buffer);
6471 debug_hexdump(stdout, "ciphertext:", ciphertext,
6473 debug_hexdump(stdout, "ciphertext expected:",
6474 tdata->ciphertext.data,
6475 tdata->ciphertext.len_bits >> 3);
6477 if (ut_params->obuf)
6478 digest = rte_pktmbuf_read(ut_params->obuf,
6479 (tdata->digest_enc.offset == 0 ?
6481 tdata->digest_enc.offset),
6482 tdata->digest_enc.len, digest_buffer);
6484 digest = rte_pktmbuf_read(ut_params->ibuf,
6485 (tdata->digest_enc.offset == 0 ?
6487 tdata->digest_enc.offset),
6488 tdata->digest_enc.len, digest_buffer);
6490 debug_hexdump(stdout, "digest:", digest,
6491 tdata->digest_enc.len);
6492 debug_hexdump(stdout, "digest expected:",
6493 tdata->digest_enc.data, tdata->digest_enc.len);
6498 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6500 tdata->plaintext.data,
6501 tdata->plaintext.len_bits >> 3,
6502 "Plaintext data not as expected");
6504 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6506 tdata->ciphertext.data,
6507 tdata->validDataLen.len_bits,
6508 "Ciphertext data not as expected");
6509 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6511 tdata->digest_enc.data,
6512 tdata->digest_enc.len,
6513 "Generated auth tag not as expected");
6516 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6517 "crypto op processing failed");
6522 /** AUTH AES CMAC + CIPHER AES CTR */
6525 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
6527 return test_mixed_auth_cipher(
6528 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
6532 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
6534 return test_mixed_auth_cipher(
6535 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6539 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
6541 return test_mixed_auth_cipher_sgl(
6542 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
6546 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
6548 return test_mixed_auth_cipher_sgl(
6549 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6553 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
6555 return test_mixed_auth_cipher(
6556 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
6560 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
6562 return test_mixed_auth_cipher(
6563 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6567 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
6569 return test_mixed_auth_cipher_sgl(
6570 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
6574 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
6576 return test_mixed_auth_cipher_sgl(
6577 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6580 /** MIXED AUTH + CIPHER */
6583 test_auth_zuc_cipher_snow_test_case_1(void)
6585 return test_mixed_auth_cipher(
6586 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6590 test_verify_auth_zuc_cipher_snow_test_case_1(void)
6592 return test_mixed_auth_cipher(
6593 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6597 test_auth_aes_cmac_cipher_snow_test_case_1(void)
6599 return test_mixed_auth_cipher(
6600 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6604 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
6606 return test_mixed_auth_cipher(
6607 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6611 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
6613 return test_mixed_auth_cipher(
6614 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6618 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
6620 return test_mixed_auth_cipher(
6621 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6625 test_auth_snow_cipher_aes_ctr_test_case_1(void)
6627 return test_mixed_auth_cipher(
6628 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6632 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
6634 return test_mixed_auth_cipher(
6635 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6639 test_auth_snow_cipher_zuc_test_case_1(void)
6641 return test_mixed_auth_cipher(
6642 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6646 test_verify_auth_snow_cipher_zuc_test_case_1(void)
6648 return test_mixed_auth_cipher(
6649 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6653 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
6655 return test_mixed_auth_cipher(
6656 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6660 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
6662 return test_mixed_auth_cipher(
6663 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6667 test_auth_null_cipher_snow_test_case_1(void)
6669 return test_mixed_auth_cipher(
6670 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6674 test_verify_auth_null_cipher_snow_test_case_1(void)
6676 return test_mixed_auth_cipher(
6677 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6681 test_auth_null_cipher_zuc_test_case_1(void)
6683 return test_mixed_auth_cipher(
6684 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6688 test_verify_auth_null_cipher_zuc_test_case_1(void)
6690 return test_mixed_auth_cipher(
6691 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6695 test_auth_snow_cipher_null_test_case_1(void)
6697 return test_mixed_auth_cipher(
6698 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6702 test_verify_auth_snow_cipher_null_test_case_1(void)
6704 return test_mixed_auth_cipher(
6705 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6709 test_auth_zuc_cipher_null_test_case_1(void)
6711 return test_mixed_auth_cipher(
6712 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6716 test_verify_auth_zuc_cipher_null_test_case_1(void)
6718 return test_mixed_auth_cipher(
6719 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6723 test_auth_null_cipher_aes_ctr_test_case_1(void)
6725 return test_mixed_auth_cipher(
6726 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6730 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
6732 return test_mixed_auth_cipher(
6733 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6737 test_auth_aes_cmac_cipher_null_test_case_1(void)
6739 return test_mixed_auth_cipher(
6740 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6744 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
6746 return test_mixed_auth_cipher(
6747 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6750 /* ***** AEAD algorithm Tests ***** */
6753 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
6754 enum rte_crypto_aead_operation op,
6755 const uint8_t *key, const uint8_t key_len,
6756 const uint16_t aad_len, const uint8_t auth_len,
6759 uint8_t aead_key[key_len];
6761 struct crypto_testsuite_params *ts_params = &testsuite_params;
6762 struct crypto_unittest_params *ut_params = &unittest_params;
6764 memcpy(aead_key, key, key_len);
6766 /* Setup AEAD Parameters */
6767 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
6768 ut_params->aead_xform.next = NULL;
6769 ut_params->aead_xform.aead.algo = algo;
6770 ut_params->aead_xform.aead.op = op;
6771 ut_params->aead_xform.aead.key.data = aead_key;
6772 ut_params->aead_xform.aead.key.length = key_len;
6773 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
6774 ut_params->aead_xform.aead.iv.length = iv_len;
6775 ut_params->aead_xform.aead.digest_length = auth_len;
6776 ut_params->aead_xform.aead.aad_length = aad_len;
6778 debug_hexdump(stdout, "key:", key, key_len);
6780 /* Create Crypto session*/
6781 ut_params->sess = rte_cryptodev_sym_session_create(
6782 ts_params->session_mpool);
6784 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6785 &ut_params->aead_xform,
6786 ts_params->session_priv_mpool);
6788 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6794 create_aead_xform(struct rte_crypto_op *op,
6795 enum rte_crypto_aead_algorithm algo,
6796 enum rte_crypto_aead_operation aead_op,
6797 uint8_t *key, const uint8_t key_len,
6798 const uint8_t aad_len, const uint8_t auth_len,
6801 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
6802 "failed to allocate space for crypto transform");
6804 struct rte_crypto_sym_op *sym_op = op->sym;
6806 /* Setup AEAD Parameters */
6807 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
6808 sym_op->xform->next = NULL;
6809 sym_op->xform->aead.algo = algo;
6810 sym_op->xform->aead.op = aead_op;
6811 sym_op->xform->aead.key.data = key;
6812 sym_op->xform->aead.key.length = key_len;
6813 sym_op->xform->aead.iv.offset = IV_OFFSET;
6814 sym_op->xform->aead.iv.length = iv_len;
6815 sym_op->xform->aead.digest_length = auth_len;
6816 sym_op->xform->aead.aad_length = aad_len;
6818 debug_hexdump(stdout, "key:", key, key_len);
6824 create_aead_operation(enum rte_crypto_aead_operation op,
6825 const struct aead_test_data *tdata)
6827 struct crypto_testsuite_params *ts_params = &testsuite_params;
6828 struct crypto_unittest_params *ut_params = &unittest_params;
6830 uint8_t *plaintext, *ciphertext;
6831 unsigned int aad_pad_len, plaintext_pad_len;
6833 /* Generate Crypto op data structure */
6834 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6835 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6836 TEST_ASSERT_NOT_NULL(ut_params->op,
6837 "Failed to allocate symmetric crypto operation struct");
6839 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6841 /* Append aad data */
6842 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
6843 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
6844 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6846 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6847 "no room to append aad");
6849 sym_op->aead.aad.phys_addr =
6850 rte_pktmbuf_iova(ut_params->ibuf);
6851 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
6852 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
6853 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6856 /* Append IV at the end of the crypto operation*/
6857 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6858 uint8_t *, IV_OFFSET);
6860 /* Copy IV 1 byte after the IV pointer, according to the API */
6861 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
6862 debug_hexdump(stdout, "iv:", iv_ptr,
6865 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6866 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6868 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6869 "no room to append aad");
6871 sym_op->aead.aad.phys_addr =
6872 rte_pktmbuf_iova(ut_params->ibuf);
6873 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
6874 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6877 /* Append IV at the end of the crypto operation*/
6878 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6879 uint8_t *, IV_OFFSET);
6881 if (tdata->iv.len == 0) {
6882 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
6883 debug_hexdump(stdout, "iv:", iv_ptr,
6886 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
6887 debug_hexdump(stdout, "iv:", iv_ptr,
6892 /* Append plaintext/ciphertext */
6893 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6894 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6895 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6897 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6899 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6900 debug_hexdump(stdout, "plaintext:", plaintext,
6901 tdata->plaintext.len);
6903 if (ut_params->obuf) {
6904 ciphertext = (uint8_t *)rte_pktmbuf_append(
6906 plaintext_pad_len + aad_pad_len);
6907 TEST_ASSERT_NOT_NULL(ciphertext,
6908 "no room to append ciphertext");
6910 memset(ciphertext + aad_pad_len, 0,
6911 tdata->ciphertext.len);
6914 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
6915 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6917 TEST_ASSERT_NOT_NULL(ciphertext,
6918 "no room to append ciphertext");
6920 memcpy(ciphertext, tdata->ciphertext.data,
6921 tdata->ciphertext.len);
6922 debug_hexdump(stdout, "ciphertext:", ciphertext,
6923 tdata->ciphertext.len);
6925 if (ut_params->obuf) {
6926 plaintext = (uint8_t *)rte_pktmbuf_append(
6928 plaintext_pad_len + aad_pad_len);
6929 TEST_ASSERT_NOT_NULL(plaintext,
6930 "no room to append plaintext");
6932 memset(plaintext + aad_pad_len, 0,
6933 tdata->plaintext.len);
6937 /* Append digest data */
6938 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6939 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6940 ut_params->obuf ? ut_params->obuf :
6942 tdata->auth_tag.len);
6943 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6944 "no room to append digest");
6945 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
6946 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6947 ut_params->obuf ? ut_params->obuf :
6952 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6953 ut_params->ibuf, tdata->auth_tag.len);
6954 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6955 "no room to append digest");
6956 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6958 plaintext_pad_len + aad_pad_len);
6960 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
6961 tdata->auth_tag.len);
6962 debug_hexdump(stdout, "digest:",
6963 sym_op->aead.digest.data,
6964 tdata->auth_tag.len);
6967 sym_op->aead.data.length = tdata->plaintext.len;
6968 sym_op->aead.data.offset = aad_pad_len;
6974 test_authenticated_encryption(const struct aead_test_data *tdata)
6976 struct crypto_testsuite_params *ts_params = &testsuite_params;
6977 struct crypto_unittest_params *ut_params = &unittest_params;
6980 uint8_t *ciphertext, *auth_tag;
6981 uint16_t plaintext_pad_len;
6984 /* Verify the capabilities */
6985 struct rte_cryptodev_sym_capability_idx cap_idx;
6986 const struct rte_cryptodev_symmetric_capability *capability;
6987 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
6988 cap_idx.algo.aead = tdata->algo;
6989 capability = rte_cryptodev_sym_capability_get(
6990 ts_params->valid_devs[0], &cap_idx);
6991 if (capability == NULL)
6993 if (rte_cryptodev_sym_capability_check_aead(
6994 capability, tdata->key.len, tdata->auth_tag.len,
6995 tdata->aad.len, tdata->iv.len))
6998 /* Create AEAD session */
6999 retval = create_aead_session(ts_params->valid_devs[0],
7001 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7002 tdata->key.data, tdata->key.len,
7003 tdata->aad.len, tdata->auth_tag.len,
7008 if (tdata->aad.len > MBUF_SIZE) {
7009 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7010 /* Populate full size of add data */
7011 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7012 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7014 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7016 /* clear mbuf payload */
7017 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7018 rte_pktmbuf_tailroom(ut_params->ibuf));
7020 /* Create AEAD operation */
7021 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7025 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7027 ut_params->op->sym->m_src = ut_params->ibuf;
7029 /* Process crypto operation */
7030 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7031 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7033 TEST_ASSERT_NOT_NULL(
7034 process_crypto_request(ts_params->valid_devs[0],
7035 ut_params->op), "failed to process sym crypto op");
7037 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7038 "crypto op processing failed");
7040 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7042 if (ut_params->op->sym->m_dst) {
7043 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7045 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7046 uint8_t *, plaintext_pad_len);
7048 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7050 ut_params->op->sym->cipher.data.offset);
7051 auth_tag = ciphertext + plaintext_pad_len;
7054 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7055 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7058 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7060 tdata->ciphertext.data,
7061 tdata->ciphertext.len,
7062 "Ciphertext data not as expected");
7064 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7066 tdata->auth_tag.data,
7067 tdata->auth_tag.len,
7068 "Generated auth tag not as expected");
7074 #ifdef RTE_LIBRTE_SECURITY
7076 security_proto_supported(enum rte_security_session_protocol proto)
7078 struct crypto_testsuite_params *ts_params = &testsuite_params;
7080 const struct rte_security_capability *capabilities;
7081 const struct rte_security_capability *capability;
7084 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7085 rte_cryptodev_get_sec_ctx(
7086 ts_params->valid_devs[0]);
7089 capabilities = rte_security_capabilities_get(ctx);
7091 if (capabilities == NULL)
7094 while ((capability = &capabilities[i++])->action !=
7095 RTE_SECURITY_ACTION_TYPE_NONE) {
7096 if (capability->protocol == proto)
7103 /* Basic algorithm run function for async inplace mode.
7104 * Creates a session from input parameters and runs one operation
7105 * on input_vec. Checks the output of the crypto operation against
7109 test_pdcp_proto(int i, int oop,
7110 enum rte_crypto_cipher_operation opc,
7111 enum rte_crypto_auth_operation opa,
7113 unsigned int input_vec_len,
7114 uint8_t *output_vec,
7115 unsigned int output_vec_len)
7117 struct crypto_testsuite_params *ts_params = &testsuite_params;
7118 struct crypto_unittest_params *ut_params = &unittest_params;
7120 int ret = TEST_SUCCESS;
7121 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7122 rte_cryptodev_get_sec_ctx(
7123 ts_params->valid_devs[0]);
7125 /* Verify the capabilities */
7126 struct rte_security_capability_idx sec_cap_idx;
7128 sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7129 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7130 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7131 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7134 /* Generate test mbuf data */
7135 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7137 /* clear mbuf payload */
7138 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7139 rte_pktmbuf_tailroom(ut_params->ibuf));
7141 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7143 memcpy(plaintext, input_vec, input_vec_len);
7145 /* Out of place support */
7148 * For out-op-place we need to alloc another mbuf
7150 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7151 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7154 /* Set crypto type as IPSEC */
7155 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7157 /* Setup Cipher Parameters */
7158 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7159 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7160 ut_params->cipher_xform.cipher.op = opc;
7161 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7162 ut_params->cipher_xform.cipher.key.length =
7163 pdcp_test_params[i].cipher_key_len;
7164 ut_params->cipher_xform.cipher.iv.length = 0;
7166 /* Setup HMAC Parameters if ICV header is required */
7167 if (pdcp_test_params[i].auth_alg != 0) {
7168 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7169 ut_params->auth_xform.next = NULL;
7170 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7171 ut_params->auth_xform.auth.op = opa;
7172 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7173 ut_params->auth_xform.auth.key.length =
7174 pdcp_test_params[i].auth_key_len;
7176 ut_params->cipher_xform.next = &ut_params->auth_xform;
7178 ut_params->cipher_xform.next = NULL;
7181 struct rte_security_session_conf sess_conf = {
7182 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7183 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7185 .bearer = pdcp_test_bearer[i],
7186 .domain = pdcp_test_params[i].domain,
7187 .pkt_dir = pdcp_test_packet_direction[i],
7188 .sn_size = pdcp_test_data_sn_size[i],
7189 .hfn = pdcp_test_hfn[i],
7190 .hfn_threshold = pdcp_test_hfn_threshold[i],
7192 .crypto_xform = &ut_params->cipher_xform
7195 /* Create security session */
7196 ut_params->sec_session = rte_security_session_create(ctx,
7197 &sess_conf, ts_params->session_priv_mpool);
7199 if (!ut_params->sec_session) {
7200 printf("TestCase %s()-%d line %d failed %s: ",
7201 __func__, i, __LINE__, "Failed to allocate session");
7206 /* Generate crypto op data structure */
7207 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7208 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7209 if (!ut_params->op) {
7210 printf("TestCase %s()-%d line %d failed %s: ",
7211 __func__, i, __LINE__,
7212 "Failed to allocate symmetric crypto operation struct");
7217 rte_security_attach_session(ut_params->op, ut_params->sec_session);
7219 /* set crypto operation source mbuf */
7220 ut_params->op->sym->m_src = ut_params->ibuf;
7222 ut_params->op->sym->m_dst = ut_params->obuf;
7224 /* Process crypto operation */
7225 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7227 printf("TestCase %s()-%d line %d failed %s: ",
7228 __func__, i, __LINE__,
7229 "failed to process sym crypto op");
7234 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7235 printf("TestCase %s()-%d line %d failed %s: ",
7236 __func__, i, __LINE__, "crypto op processing failed");
7242 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7245 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7249 if (memcmp(ciphertext, output_vec, output_vec_len)) {
7250 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7251 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7252 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7258 rte_crypto_op_free(ut_params->op);
7259 ut_params->op = NULL;
7261 if (ut_params->sec_session)
7262 rte_security_session_destroy(ctx, ut_params->sec_session);
7263 ut_params->sec_session = NULL;
7265 rte_pktmbuf_free(ut_params->ibuf);
7266 ut_params->ibuf = NULL;
7268 rte_pktmbuf_free(ut_params->obuf);
7269 ut_params->obuf = NULL;
7276 test_pdcp_proto_SGL(int i, int oop,
7277 enum rte_crypto_cipher_operation opc,
7278 enum rte_crypto_auth_operation opa,
7280 unsigned int input_vec_len,
7281 uint8_t *output_vec,
7282 unsigned int output_vec_len,
7284 uint32_t fragsz_oop)
7286 struct crypto_testsuite_params *ts_params = &testsuite_params;
7287 struct crypto_unittest_params *ut_params = &unittest_params;
7289 struct rte_mbuf *buf, *buf_oop = NULL;
7290 int ret = TEST_SUCCESS;
7294 unsigned int trn_data = 0;
7295 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7296 rte_cryptodev_get_sec_ctx(
7297 ts_params->valid_devs[0]);
7299 /* Verify the capabilities */
7300 struct rte_security_capability_idx sec_cap_idx;
7302 sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7303 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7304 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7305 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7308 if (fragsz > input_vec_len)
7309 fragsz = input_vec_len;
7311 uint16_t plaintext_len = fragsz;
7312 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7314 if (fragsz_oop > output_vec_len)
7315 frag_size_oop = output_vec_len;
7318 if (input_vec_len % fragsz != 0) {
7319 if (input_vec_len / fragsz + 1 > 16)
7321 } else if (input_vec_len / fragsz > 16)
7324 /* Out of place support */
7327 * For out-op-place we need to alloc another mbuf
7329 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7330 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7331 buf_oop = ut_params->obuf;
7334 /* Generate test mbuf data */
7335 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7337 /* clear mbuf payload */
7338 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7339 rte_pktmbuf_tailroom(ut_params->ibuf));
7341 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7343 memcpy(plaintext, input_vec, plaintext_len);
7344 trn_data += plaintext_len;
7346 buf = ut_params->ibuf;
7349 * Loop until no more fragments
7352 while (trn_data < input_vec_len) {
7354 to_trn = (input_vec_len - trn_data < fragsz) ?
7355 (input_vec_len - trn_data) : fragsz;
7357 to_trn_tbl[ecx++] = to_trn;
7359 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7362 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7363 rte_pktmbuf_tailroom(buf));
7366 if (oop && !fragsz_oop) {
7368 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7369 buf_oop = buf_oop->next;
7370 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7371 0, rte_pktmbuf_tailroom(buf_oop));
7372 rte_pktmbuf_append(buf_oop, to_trn);
7375 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7378 memcpy(plaintext, input_vec + trn_data, to_trn);
7382 ut_params->ibuf->nb_segs = segs;
7385 if (fragsz_oop && oop) {
7389 trn_data = frag_size_oop;
7390 while (trn_data < output_vec_len) {
7393 (output_vec_len - trn_data <
7395 (output_vec_len - trn_data) :
7398 to_trn_tbl[ecx++] = to_trn;
7401 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7402 buf_oop = buf_oop->next;
7403 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7404 0, rte_pktmbuf_tailroom(buf_oop));
7405 rte_pktmbuf_append(buf_oop, to_trn);
7409 ut_params->obuf->nb_segs = segs;
7412 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7414 /* Setup Cipher Parameters */
7415 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7416 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7417 ut_params->cipher_xform.cipher.op = opc;
7418 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7419 ut_params->cipher_xform.cipher.key.length =
7420 pdcp_test_params[i].cipher_key_len;
7421 ut_params->cipher_xform.cipher.iv.length = 0;
7423 /* Setup HMAC Parameters if ICV header is required */
7424 if (pdcp_test_params[i].auth_alg != 0) {
7425 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7426 ut_params->auth_xform.next = NULL;
7427 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7428 ut_params->auth_xform.auth.op = opa;
7429 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7430 ut_params->auth_xform.auth.key.length =
7431 pdcp_test_params[i].auth_key_len;
7433 ut_params->cipher_xform.next = &ut_params->auth_xform;
7435 ut_params->cipher_xform.next = NULL;
7438 struct rte_security_session_conf sess_conf = {
7439 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7440 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7442 .bearer = pdcp_test_bearer[i],
7443 .domain = pdcp_test_params[i].domain,
7444 .pkt_dir = pdcp_test_packet_direction[i],
7445 .sn_size = pdcp_test_data_sn_size[i],
7446 .hfn = pdcp_test_hfn[i],
7447 .hfn_threshold = pdcp_test_hfn_threshold[i],
7449 .crypto_xform = &ut_params->cipher_xform
7452 /* Create security session */
7453 ut_params->sec_session = rte_security_session_create(ctx,
7454 &sess_conf, ts_params->session_priv_mpool);
7456 if (!ut_params->sec_session) {
7457 printf("TestCase %s()-%d line %d failed %s: ",
7458 __func__, i, __LINE__, "Failed to allocate session");
7463 /* Generate crypto op data structure */
7464 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7465 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7466 if (!ut_params->op) {
7467 printf("TestCase %s()-%d line %d failed %s: ",
7468 __func__, i, __LINE__,
7469 "Failed to allocate symmetric crypto operation struct");
7474 rte_security_attach_session(ut_params->op, ut_params->sec_session);
7476 /* set crypto operation source mbuf */
7477 ut_params->op->sym->m_src = ut_params->ibuf;
7479 ut_params->op->sym->m_dst = ut_params->obuf;
7481 /* Process crypto operation */
7482 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7484 printf("TestCase %s()-%d line %d failed %s: ",
7485 __func__, i, __LINE__,
7486 "failed to process sym crypto op");
7491 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7492 printf("TestCase %s()-%d line %d failed %s: ",
7493 __func__, i, __LINE__, "crypto op processing failed");
7499 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7502 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7506 fragsz = frag_size_oop;
7507 if (memcmp(ciphertext, output_vec, fragsz)) {
7508 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7509 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
7510 rte_hexdump(stdout, "reference", output_vec, fragsz);
7515 buf = ut_params->op->sym->m_src->next;
7517 buf = ut_params->op->sym->m_dst->next;
7519 unsigned int off = fragsz;
7523 ciphertext = rte_pktmbuf_mtod(buf,
7525 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
7526 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7527 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
7528 rte_hexdump(stdout, "reference", output_vec + off,
7533 off += to_trn_tbl[ecx++];
7537 rte_crypto_op_free(ut_params->op);
7538 ut_params->op = NULL;
7540 if (ut_params->sec_session)
7541 rte_security_session_destroy(ctx, ut_params->sec_session);
7542 ut_params->sec_session = NULL;
7544 rte_pktmbuf_free(ut_params->ibuf);
7545 ut_params->ibuf = NULL;
7547 rte_pktmbuf_free(ut_params->obuf);
7548 ut_params->obuf = NULL;
7555 test_pdcp_proto_cplane_encap(int i)
7557 return test_pdcp_proto(i, 0,
7558 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7559 RTE_CRYPTO_AUTH_OP_GENERATE,
7560 pdcp_test_data_in[i],
7561 pdcp_test_data_in_len[i],
7562 pdcp_test_data_out[i],
7563 pdcp_test_data_in_len[i]+4);
7567 test_pdcp_proto_uplane_encap(int i)
7569 return test_pdcp_proto(i, 0,
7570 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7571 RTE_CRYPTO_AUTH_OP_GENERATE,
7572 pdcp_test_data_in[i],
7573 pdcp_test_data_in_len[i],
7574 pdcp_test_data_out[i],
7575 pdcp_test_data_in_len[i]);
7580 test_pdcp_proto_uplane_encap_with_int(int i)
7582 return test_pdcp_proto(i, 0,
7583 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7584 RTE_CRYPTO_AUTH_OP_GENERATE,
7585 pdcp_test_data_in[i],
7586 pdcp_test_data_in_len[i],
7587 pdcp_test_data_out[i],
7588 pdcp_test_data_in_len[i] + 4);
7592 test_pdcp_proto_cplane_decap(int i)
7594 return test_pdcp_proto(i, 0,
7595 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7596 RTE_CRYPTO_AUTH_OP_VERIFY,
7597 pdcp_test_data_out[i],
7598 pdcp_test_data_in_len[i] + 4,
7599 pdcp_test_data_in[i],
7600 pdcp_test_data_in_len[i]);
7604 test_pdcp_proto_uplane_decap(int i)
7606 return test_pdcp_proto(i, 0,
7607 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7608 RTE_CRYPTO_AUTH_OP_VERIFY,
7609 pdcp_test_data_out[i],
7610 pdcp_test_data_in_len[i],
7611 pdcp_test_data_in[i],
7612 pdcp_test_data_in_len[i]);
7616 test_pdcp_proto_uplane_decap_with_int(int i)
7618 return test_pdcp_proto(i, 0,
7619 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7620 RTE_CRYPTO_AUTH_OP_VERIFY,
7621 pdcp_test_data_out[i],
7622 pdcp_test_data_in_len[i] + 4,
7623 pdcp_test_data_in[i],
7624 pdcp_test_data_in_len[i]);
7628 test_PDCP_PROTO_SGL_in_place_32B(void)
7630 /* i can be used for running any PDCP case
7631 * In this case it is uplane 12-bit AES-SNOW DL encap
7633 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
7634 return test_pdcp_proto_SGL(i, IN_PLACE,
7635 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7636 RTE_CRYPTO_AUTH_OP_GENERATE,
7637 pdcp_test_data_in[i],
7638 pdcp_test_data_in_len[i],
7639 pdcp_test_data_out[i],
7640 pdcp_test_data_in_len[i]+4,
7644 test_PDCP_PROTO_SGL_oop_32B_128B(void)
7646 /* i can be used for running any PDCP case
7647 * In this case it is uplane 18-bit NULL-NULL DL encap
7649 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
7650 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7651 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7652 RTE_CRYPTO_AUTH_OP_GENERATE,
7653 pdcp_test_data_in[i],
7654 pdcp_test_data_in_len[i],
7655 pdcp_test_data_out[i],
7656 pdcp_test_data_in_len[i]+4,
7660 test_PDCP_PROTO_SGL_oop_32B_40B(void)
7662 /* i can be used for running any PDCP case
7663 * In this case it is uplane 18-bit AES DL encap
7665 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
7667 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7668 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7669 RTE_CRYPTO_AUTH_OP_GENERATE,
7670 pdcp_test_data_in[i],
7671 pdcp_test_data_in_len[i],
7672 pdcp_test_data_out[i],
7673 pdcp_test_data_in_len[i],
7677 test_PDCP_PROTO_SGL_oop_128B_32B(void)
7679 /* i can be used for running any PDCP case
7680 * In this case it is cplane 12-bit AES-ZUC DL encap
7682 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
7683 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7684 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7685 RTE_CRYPTO_AUTH_OP_GENERATE,
7686 pdcp_test_data_in[i],
7687 pdcp_test_data_in_len[i],
7688 pdcp_test_data_out[i],
7689 pdcp_test_data_in_len[i]+4,
7694 test_PDCP_PROTO_all(void)
7696 struct crypto_testsuite_params *ts_params = &testsuite_params;
7697 struct rte_cryptodev_info dev_info;
7700 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7701 uint64_t feat_flags = dev_info.feature_flags;
7703 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
7706 if (security_proto_supported(RTE_SECURITY_PROTOCOL_PDCP) < 0)
7709 status = test_PDCP_PROTO_cplane_encap_all();
7710 status += test_PDCP_PROTO_cplane_decap_all();
7711 status += test_PDCP_PROTO_uplane_encap_all();
7712 status += test_PDCP_PROTO_uplane_decap_all();
7713 status += test_PDCP_PROTO_SGL_in_place_32B();
7714 status += test_PDCP_PROTO_SGL_oop_32B_128B();
7715 status += test_PDCP_PROTO_SGL_oop_32B_40B();
7716 status += test_PDCP_PROTO_SGL_oop_128B_32B();
7721 return TEST_SUCCESS;
7725 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
7727 struct crypto_testsuite_params *ts_params = &testsuite_params;
7728 struct crypto_unittest_params *ut_params = &unittest_params;
7729 uint8_t *plaintext, *ciphertext;
7731 int32_t cipher_len, crc_len;
7732 uint32_t crc_data_len;
7733 int ret = TEST_SUCCESS;
7735 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7736 rte_cryptodev_get_sec_ctx(
7737 ts_params->valid_devs[0]);
7739 /* Verify the capabilities */
7740 struct rte_security_capability_idx sec_cap_idx;
7741 const struct rte_security_capability *sec_cap;
7742 const struct rte_cryptodev_capabilities *crypto_cap;
7743 const struct rte_cryptodev_symmetric_capability *sym_cap;
7746 sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7747 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
7748 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
7750 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
7751 if (sec_cap == NULL)
7754 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
7755 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
7756 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
7757 crypto_cap->sym.xform_type ==
7758 RTE_CRYPTO_SYM_XFORM_CIPHER &&
7759 crypto_cap->sym.cipher.algo ==
7760 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
7761 sym_cap = &crypto_cap->sym;
7762 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
7769 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
7772 /* Setup source mbuf payload */
7773 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7774 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7775 rte_pktmbuf_tailroom(ut_params->ibuf));
7777 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7778 d_td->ciphertext.len);
7780 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
7782 /* Set session action type */
7783 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7785 /* Setup cipher session parameters */
7786 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7787 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
7788 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
7789 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
7790 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
7791 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
7792 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7793 ut_params->cipher_xform.next = NULL;
7795 /* Setup DOCSIS session parameters */
7796 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
7798 struct rte_security_session_conf sess_conf = {
7799 .action_type = ut_params->type,
7800 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
7801 .docsis = ut_params->docsis_xform,
7802 .crypto_xform = &ut_params->cipher_xform,
7805 /* Create security session */
7806 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
7807 ts_params->session_priv_mpool);
7809 if (!ut_params->sec_session) {
7810 printf("TestCase %s(%d) line %d: %s\n",
7811 __func__, i, __LINE__, "failed to allocate session");
7816 /* Generate crypto op data structure */
7817 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7818 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7819 if (!ut_params->op) {
7820 printf("TestCase %s(%d) line %d: %s\n",
7821 __func__, i, __LINE__,
7822 "failed to allocate symmetric crypto operation");
7827 /* Setup CRC operation parameters */
7828 crc_len = d_td->ciphertext.no_crc == false ?
7829 (d_td->ciphertext.len -
7830 d_td->ciphertext.crc_offset -
7831 RTE_ETHER_CRC_LEN) :
7833 crc_len = crc_len > 0 ? crc_len : 0;
7834 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
7835 ut_params->op->sym->auth.data.length = crc_len;
7836 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
7838 /* Setup cipher operation parameters */
7839 cipher_len = d_td->ciphertext.no_cipher == false ?
7840 (d_td->ciphertext.len -
7841 d_td->ciphertext.cipher_offset) :
7843 cipher_len = cipher_len > 0 ? cipher_len : 0;
7844 ut_params->op->sym->cipher.data.length = cipher_len;
7845 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
7847 /* Setup cipher IV */
7848 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
7849 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
7851 /* Attach session to operation */
7852 rte_security_attach_session(ut_params->op, ut_params->sec_session);
7854 /* Set crypto operation mbufs */
7855 ut_params->op->sym->m_src = ut_params->ibuf;
7856 ut_params->op->sym->m_dst = NULL;
7858 /* Process crypto operation */
7859 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
7861 printf("TestCase %s(%d) line %d: %s\n",
7862 __func__, i, __LINE__,
7863 "failed to process security crypto op");
7868 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7869 printf("TestCase %s(%d) line %d: %s\n",
7870 __func__, i, __LINE__, "crypto op processing failed");
7875 /* Validate plaintext */
7876 plaintext = ciphertext;
7878 if (memcmp(plaintext, d_td->plaintext.data,
7879 d_td->plaintext.len - crc_data_len)) {
7880 printf("TestCase %s(%d) line %d: %s\n",
7881 __func__, i, __LINE__, "plaintext not as expected\n");
7882 rte_hexdump(stdout, "expected", d_td->plaintext.data,
7883 d_td->plaintext.len);
7884 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
7890 rte_crypto_op_free(ut_params->op);
7891 ut_params->op = NULL;
7893 if (ut_params->sec_session)
7894 rte_security_session_destroy(ctx, ut_params->sec_session);
7895 ut_params->sec_session = NULL;
7897 rte_pktmbuf_free(ut_params->ibuf);
7898 ut_params->ibuf = NULL;
7904 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
7906 struct crypto_testsuite_params *ts_params = &testsuite_params;
7907 struct crypto_unittest_params *ut_params = &unittest_params;
7908 uint8_t *plaintext, *ciphertext;
7910 int32_t cipher_len, crc_len;
7911 int ret = TEST_SUCCESS;
7913 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7914 rte_cryptodev_get_sec_ctx(
7915 ts_params->valid_devs[0]);
7917 /* Verify the capabilities */
7918 struct rte_security_capability_idx sec_cap_idx;
7919 const struct rte_security_capability *sec_cap;
7920 const struct rte_cryptodev_capabilities *crypto_cap;
7921 const struct rte_cryptodev_symmetric_capability *sym_cap;
7924 sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7925 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
7926 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
7928 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
7929 if (sec_cap == NULL)
7932 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
7933 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
7934 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
7935 crypto_cap->sym.xform_type ==
7936 RTE_CRYPTO_SYM_XFORM_CIPHER &&
7937 crypto_cap->sym.cipher.algo ==
7938 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
7939 sym_cap = &crypto_cap->sym;
7940 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
7947 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
7950 /* Setup source mbuf payload */
7951 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7952 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7953 rte_pktmbuf_tailroom(ut_params->ibuf));
7955 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7956 d_td->plaintext.len);
7958 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
7960 /* Set session action type */
7961 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7963 /* Setup cipher session parameters */
7964 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7965 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
7966 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
7967 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
7968 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
7969 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
7970 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7971 ut_params->cipher_xform.next = NULL;
7973 /* Setup DOCSIS session parameters */
7974 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
7976 struct rte_security_session_conf sess_conf = {
7977 .action_type = ut_params->type,
7978 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
7979 .docsis = ut_params->docsis_xform,
7980 .crypto_xform = &ut_params->cipher_xform,
7983 /* Create security session */
7984 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
7985 ts_params->session_priv_mpool);
7987 if (!ut_params->sec_session) {
7988 printf("TestCase %s(%d) line %d: %s\n",
7989 __func__, i, __LINE__, "failed to allocate session");
7994 /* Generate crypto op data structure */
7995 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7996 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7997 if (!ut_params->op) {
7998 printf("TestCase %s(%d) line %d: %s\n",
7999 __func__, i, __LINE__,
8000 "failed to allocate security crypto operation");
8005 /* Setup CRC operation parameters */
8006 crc_len = d_td->plaintext.no_crc == false ?
8007 (d_td->plaintext.len -
8008 d_td->plaintext.crc_offset -
8009 RTE_ETHER_CRC_LEN) :
8011 crc_len = crc_len > 0 ? crc_len : 0;
8012 ut_params->op->sym->auth.data.length = crc_len;
8013 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
8015 /* Setup cipher operation parameters */
8016 cipher_len = d_td->plaintext.no_cipher == false ?
8017 (d_td->plaintext.len -
8018 d_td->plaintext.cipher_offset) :
8020 cipher_len = cipher_len > 0 ? cipher_len : 0;
8021 ut_params->op->sym->cipher.data.length = cipher_len;
8022 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
8024 /* Setup cipher IV */
8025 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8026 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8028 /* Attach session to operation */
8029 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8031 /* Set crypto operation mbufs */
8032 ut_params->op->sym->m_src = ut_params->ibuf;
8033 ut_params->op->sym->m_dst = NULL;
8035 /* Process crypto operation */
8036 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8038 printf("TestCase %s(%d) line %d: %s\n",
8039 __func__, i, __LINE__,
8040 "failed to process security crypto op");
8045 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8046 printf("TestCase %s(%d) line %d: %s\n",
8047 __func__, i, __LINE__, "crypto op processing failed");
8052 /* Validate ciphertext */
8053 ciphertext = plaintext;
8055 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
8056 printf("TestCase %s(%d) line %d: %s\n",
8057 __func__, i, __LINE__, "ciphertext not as expected\n");
8058 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
8059 d_td->ciphertext.len);
8060 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
8066 rte_crypto_op_free(ut_params->op);
8067 ut_params->op = NULL;
8069 if (ut_params->sec_session)
8070 rte_security_session_destroy(ctx, ut_params->sec_session);
8071 ut_params->sec_session = NULL;
8073 rte_pktmbuf_free(ut_params->ibuf);
8074 ut_params->ibuf = NULL;
8079 #define TEST_DOCSIS_COUNT(func) do { \
8081 if (ret == TEST_SUCCESS) { \
8082 printf("\t%2d)", n++); \
8083 printf("+++++ PASSED:" #func"\n"); \
8085 } else if (ret == -ENOTSUP) { \
8086 printf("\t%2d)", n++); \
8087 printf("~~~~~ UNSUPP:" #func"\n"); \
8090 printf("\t%2d)", n++); \
8091 printf("----- FAILED:" #func"\n"); \
8097 test_DOCSIS_PROTO_uplink_all(void)
8099 int p = 0, u = 0, f = 0, n = 0;
8101 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
8102 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
8103 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
8104 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
8105 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
8106 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
8107 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
8108 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
8109 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
8110 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
8111 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
8112 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
8113 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
8114 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
8115 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
8116 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
8117 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
8118 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
8119 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
8120 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
8121 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
8122 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
8123 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
8124 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
8125 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
8126 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
8129 printf("## %s: %d passed out of %d (%d unsupported)\n",
8136 test_DOCSIS_PROTO_downlink_all(void)
8138 int p = 0, u = 0, f = 0, n = 0;
8140 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
8141 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
8142 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
8143 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
8144 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
8145 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
8146 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
8147 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
8148 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
8149 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
8150 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
8151 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
8152 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
8153 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
8154 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
8155 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
8156 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
8157 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
8158 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
8159 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
8160 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
8161 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
8162 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
8163 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
8164 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
8165 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
8168 printf("## %s: %d passed out of %d (%d unsupported)\n",
8175 test_DOCSIS_PROTO_all(void)
8177 struct crypto_testsuite_params *ts_params = &testsuite_params;
8178 struct rte_cryptodev_info dev_info;
8181 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8182 uint64_t feat_flags = dev_info.feature_flags;
8184 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8187 if (security_proto_supported(RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
8190 status = test_DOCSIS_PROTO_uplink_all();
8191 status += test_DOCSIS_PROTO_downlink_all();
8196 return TEST_SUCCESS;
8201 test_AES_GCM_authenticated_encryption_test_case_1(void)
8203 return test_authenticated_encryption(&gcm_test_case_1);
8207 test_AES_GCM_authenticated_encryption_test_case_2(void)
8209 return test_authenticated_encryption(&gcm_test_case_2);
8213 test_AES_GCM_authenticated_encryption_test_case_3(void)
8215 return test_authenticated_encryption(&gcm_test_case_3);
8219 test_AES_GCM_authenticated_encryption_test_case_4(void)
8221 return test_authenticated_encryption(&gcm_test_case_4);
8225 test_AES_GCM_authenticated_encryption_test_case_5(void)
8227 return test_authenticated_encryption(&gcm_test_case_5);
8231 test_AES_GCM_authenticated_encryption_test_case_6(void)
8233 return test_authenticated_encryption(&gcm_test_case_6);
8237 test_AES_GCM_authenticated_encryption_test_case_7(void)
8239 return test_authenticated_encryption(&gcm_test_case_7);
8243 test_AES_GCM_authenticated_encryption_test_case_8(void)
8245 return test_authenticated_encryption(&gcm_test_case_8);
8249 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
8251 return test_authenticated_encryption(&gcm_J0_test_case_1);
8255 test_AES_GCM_auth_encryption_test_case_192_1(void)
8257 return test_authenticated_encryption(&gcm_test_case_192_1);
8261 test_AES_GCM_auth_encryption_test_case_192_2(void)
8263 return test_authenticated_encryption(&gcm_test_case_192_2);
8267 test_AES_GCM_auth_encryption_test_case_192_3(void)
8269 return test_authenticated_encryption(&gcm_test_case_192_3);
8273 test_AES_GCM_auth_encryption_test_case_192_4(void)
8275 return test_authenticated_encryption(&gcm_test_case_192_4);
8279 test_AES_GCM_auth_encryption_test_case_192_5(void)
8281 return test_authenticated_encryption(&gcm_test_case_192_5);
8285 test_AES_GCM_auth_encryption_test_case_192_6(void)
8287 return test_authenticated_encryption(&gcm_test_case_192_6);
8291 test_AES_GCM_auth_encryption_test_case_192_7(void)
8293 return test_authenticated_encryption(&gcm_test_case_192_7);
8297 test_AES_GCM_auth_encryption_test_case_256_1(void)
8299 return test_authenticated_encryption(&gcm_test_case_256_1);
8303 test_AES_GCM_auth_encryption_test_case_256_2(void)
8305 return test_authenticated_encryption(&gcm_test_case_256_2);
8309 test_AES_GCM_auth_encryption_test_case_256_3(void)
8311 return test_authenticated_encryption(&gcm_test_case_256_3);
8315 test_AES_GCM_auth_encryption_test_case_256_4(void)
8317 return test_authenticated_encryption(&gcm_test_case_256_4);
8321 test_AES_GCM_auth_encryption_test_case_256_5(void)
8323 return test_authenticated_encryption(&gcm_test_case_256_5);
8327 test_AES_GCM_auth_encryption_test_case_256_6(void)
8329 return test_authenticated_encryption(&gcm_test_case_256_6);
8333 test_AES_GCM_auth_encryption_test_case_256_7(void)
8335 return test_authenticated_encryption(&gcm_test_case_256_7);
8339 test_AES_GCM_auth_encryption_test_case_aad_1(void)
8341 return test_authenticated_encryption(&gcm_test_case_aad_1);
8345 test_AES_GCM_auth_encryption_test_case_aad_2(void)
8347 return test_authenticated_encryption(&gcm_test_case_aad_2);
8351 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
8353 struct aead_test_data tdata;
8356 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8357 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8358 tdata.iv.data[0] += 1;
8359 res = test_authenticated_encryption(&tdata);
8360 if (res == -ENOTSUP)
8362 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8363 return TEST_SUCCESS;
8367 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
8369 struct aead_test_data tdata;
8372 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8373 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8374 tdata.plaintext.data[0] += 1;
8375 res = test_authenticated_encryption(&tdata);
8376 if (res == -ENOTSUP)
8378 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8379 return TEST_SUCCESS;
8383 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
8385 struct aead_test_data tdata;
8388 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8389 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8390 tdata.ciphertext.data[0] += 1;
8391 res = test_authenticated_encryption(&tdata);
8392 if (res == -ENOTSUP)
8394 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8395 return TEST_SUCCESS;
8399 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
8401 struct aead_test_data tdata;
8404 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8405 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8407 res = test_authenticated_encryption(&tdata);
8408 if (res == -ENOTSUP)
8410 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8411 return TEST_SUCCESS;
8415 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
8417 struct aead_test_data tdata;
8418 uint8_t aad[gcm_test_case_7.aad.len];
8421 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8422 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8423 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
8425 tdata.aad.data = aad;
8426 res = test_authenticated_encryption(&tdata);
8427 if (res == -ENOTSUP)
8429 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8430 return TEST_SUCCESS;
8434 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
8436 struct aead_test_data tdata;
8439 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8440 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8441 tdata.auth_tag.data[0] += 1;
8442 res = test_authenticated_encryption(&tdata);
8443 if (res == -ENOTSUP)
8445 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8446 return TEST_SUCCESS;
8450 test_authenticated_decryption(const struct aead_test_data *tdata)
8452 struct crypto_testsuite_params *ts_params = &testsuite_params;
8453 struct crypto_unittest_params *ut_params = &unittest_params;
8459 /* Verify the capabilities */
8460 struct rte_cryptodev_sym_capability_idx cap_idx;
8461 const struct rte_cryptodev_symmetric_capability *capability;
8462 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8463 cap_idx.algo.aead = tdata->algo;
8464 capability = rte_cryptodev_sym_capability_get(
8465 ts_params->valid_devs[0], &cap_idx);
8466 if (capability == NULL)
8468 if (rte_cryptodev_sym_capability_check_aead(
8469 capability, tdata->key.len, tdata->auth_tag.len,
8470 tdata->aad.len, tdata->iv.len))
8473 /* Create AEAD session */
8474 retval = create_aead_session(ts_params->valid_devs[0],
8476 RTE_CRYPTO_AEAD_OP_DECRYPT,
8477 tdata->key.data, tdata->key.len,
8478 tdata->aad.len, tdata->auth_tag.len,
8483 /* alloc mbuf and set payload */
8484 if (tdata->aad.len > MBUF_SIZE) {
8485 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8486 /* Populate full size of add data */
8487 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8488 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8490 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8492 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8493 rte_pktmbuf_tailroom(ut_params->ibuf));
8495 /* Create AEAD operation */
8496 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8500 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8502 ut_params->op->sym->m_src = ut_params->ibuf;
8504 /* Process crypto operation */
8505 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8506 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8508 TEST_ASSERT_NOT_NULL(
8509 process_crypto_request(ts_params->valid_devs[0],
8510 ut_params->op), "failed to process sym crypto op");
8512 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8513 "crypto op processing failed");
8515 if (ut_params->op->sym->m_dst)
8516 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8519 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8521 ut_params->op->sym->cipher.data.offset);
8523 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8526 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8528 tdata->plaintext.data,
8529 tdata->plaintext.len,
8530 "Plaintext data not as expected");
8532 TEST_ASSERT_EQUAL(ut_params->op->status,
8533 RTE_CRYPTO_OP_STATUS_SUCCESS,
8534 "Authentication failed");
8540 test_AES_GCM_authenticated_decryption_test_case_1(void)
8542 return test_authenticated_decryption(&gcm_test_case_1);
8546 test_AES_GCM_authenticated_decryption_test_case_2(void)
8548 return test_authenticated_decryption(&gcm_test_case_2);
8552 test_AES_GCM_authenticated_decryption_test_case_3(void)
8554 return test_authenticated_decryption(&gcm_test_case_3);
8558 test_AES_GCM_authenticated_decryption_test_case_4(void)
8560 return test_authenticated_decryption(&gcm_test_case_4);
8564 test_AES_GCM_authenticated_decryption_test_case_5(void)
8566 return test_authenticated_decryption(&gcm_test_case_5);
8570 test_AES_GCM_authenticated_decryption_test_case_6(void)
8572 return test_authenticated_decryption(&gcm_test_case_6);
8576 test_AES_GCM_authenticated_decryption_test_case_7(void)
8578 return test_authenticated_decryption(&gcm_test_case_7);
8582 test_AES_GCM_authenticated_decryption_test_case_8(void)
8584 return test_authenticated_decryption(&gcm_test_case_8);
8588 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
8590 return test_authenticated_decryption(&gcm_J0_test_case_1);
8594 test_AES_GCM_auth_decryption_test_case_192_1(void)
8596 return test_authenticated_decryption(&gcm_test_case_192_1);
8600 test_AES_GCM_auth_decryption_test_case_192_2(void)
8602 return test_authenticated_decryption(&gcm_test_case_192_2);
8606 test_AES_GCM_auth_decryption_test_case_192_3(void)
8608 return test_authenticated_decryption(&gcm_test_case_192_3);
8612 test_AES_GCM_auth_decryption_test_case_192_4(void)
8614 return test_authenticated_decryption(&gcm_test_case_192_4);
8618 test_AES_GCM_auth_decryption_test_case_192_5(void)
8620 return test_authenticated_decryption(&gcm_test_case_192_5);
8624 test_AES_GCM_auth_decryption_test_case_192_6(void)
8626 return test_authenticated_decryption(&gcm_test_case_192_6);
8630 test_AES_GCM_auth_decryption_test_case_192_7(void)
8632 return test_authenticated_decryption(&gcm_test_case_192_7);
8636 test_AES_GCM_auth_decryption_test_case_256_1(void)
8638 return test_authenticated_decryption(&gcm_test_case_256_1);
8642 test_AES_GCM_auth_decryption_test_case_256_2(void)
8644 return test_authenticated_decryption(&gcm_test_case_256_2);
8648 test_AES_GCM_auth_decryption_test_case_256_3(void)
8650 return test_authenticated_decryption(&gcm_test_case_256_3);
8654 test_AES_GCM_auth_decryption_test_case_256_4(void)
8656 return test_authenticated_decryption(&gcm_test_case_256_4);
8660 test_AES_GCM_auth_decryption_test_case_256_5(void)
8662 return test_authenticated_decryption(&gcm_test_case_256_5);
8666 test_AES_GCM_auth_decryption_test_case_256_6(void)
8668 return test_authenticated_decryption(&gcm_test_case_256_6);
8672 test_AES_GCM_auth_decryption_test_case_256_7(void)
8674 return test_authenticated_decryption(&gcm_test_case_256_7);
8678 test_AES_GCM_auth_decryption_test_case_aad_1(void)
8680 return test_authenticated_decryption(&gcm_test_case_aad_1);
8684 test_AES_GCM_auth_decryption_test_case_aad_2(void)
8686 return test_authenticated_decryption(&gcm_test_case_aad_2);
8690 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
8692 struct aead_test_data tdata;
8695 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8696 tdata.iv.data[0] += 1;
8697 res = test_authenticated_decryption(&tdata);
8698 if (res == -ENOTSUP)
8700 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8701 return TEST_SUCCESS;
8705 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
8707 struct aead_test_data tdata;
8710 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8711 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8712 tdata.plaintext.data[0] += 1;
8713 res = test_authenticated_decryption(&tdata);
8714 if (res == -ENOTSUP)
8716 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8717 return TEST_SUCCESS;
8721 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
8723 struct aead_test_data tdata;
8726 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8727 tdata.ciphertext.data[0] += 1;
8728 res = test_authenticated_decryption(&tdata);
8729 if (res == -ENOTSUP)
8731 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8732 return TEST_SUCCESS;
8736 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
8738 struct aead_test_data tdata;
8741 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8743 res = test_authenticated_decryption(&tdata);
8744 if (res == -ENOTSUP)
8746 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8747 return TEST_SUCCESS;
8751 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
8753 struct aead_test_data tdata;
8754 uint8_t aad[gcm_test_case_7.aad.len];
8757 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8758 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
8760 tdata.aad.data = aad;
8761 res = test_authenticated_decryption(&tdata);
8762 if (res == -ENOTSUP)
8764 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8765 return TEST_SUCCESS;
8769 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
8771 struct aead_test_data tdata;
8774 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8775 tdata.auth_tag.data[0] += 1;
8776 res = test_authenticated_decryption(&tdata);
8777 if (res == -ENOTSUP)
8779 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
8780 return TEST_SUCCESS;
8784 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
8786 struct crypto_testsuite_params *ts_params = &testsuite_params;
8787 struct crypto_unittest_params *ut_params = &unittest_params;
8790 uint8_t *ciphertext, *auth_tag;
8791 uint16_t plaintext_pad_len;
8793 /* Verify the capabilities */
8794 struct rte_cryptodev_sym_capability_idx cap_idx;
8795 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8796 cap_idx.algo.aead = tdata->algo;
8797 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8801 /* not supported with CPU crypto */
8802 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8805 /* Create AEAD session */
8806 retval = create_aead_session(ts_params->valid_devs[0],
8808 RTE_CRYPTO_AEAD_OP_ENCRYPT,
8809 tdata->key.data, tdata->key.len,
8810 tdata->aad.len, tdata->auth_tag.len,
8815 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8816 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8818 /* clear mbuf payload */
8819 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8820 rte_pktmbuf_tailroom(ut_params->ibuf));
8821 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
8822 rte_pktmbuf_tailroom(ut_params->obuf));
8824 /* Create AEAD operation */
8825 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8829 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8831 ut_params->op->sym->m_src = ut_params->ibuf;
8832 ut_params->op->sym->m_dst = ut_params->obuf;
8834 /* Process crypto operation */
8835 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8836 ut_params->op), "failed to process sym crypto op");
8838 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8839 "crypto op processing failed");
8841 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8843 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
8844 ut_params->op->sym->cipher.data.offset);
8845 auth_tag = ciphertext + plaintext_pad_len;
8847 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8848 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8851 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8853 tdata->ciphertext.data,
8854 tdata->ciphertext.len,
8855 "Ciphertext data not as expected");
8857 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8859 tdata->auth_tag.data,
8860 tdata->auth_tag.len,
8861 "Generated auth tag not as expected");
8868 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
8870 return test_authenticated_encryption_oop(&gcm_test_case_5);
8874 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
8876 struct crypto_testsuite_params *ts_params = &testsuite_params;
8877 struct crypto_unittest_params *ut_params = &unittest_params;
8882 /* Verify the capabilities */
8883 struct rte_cryptodev_sym_capability_idx cap_idx;
8884 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8885 cap_idx.algo.aead = tdata->algo;
8886 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8890 /* not supported with CPU crypto */
8891 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8894 /* Create AEAD session */
8895 retval = create_aead_session(ts_params->valid_devs[0],
8897 RTE_CRYPTO_AEAD_OP_DECRYPT,
8898 tdata->key.data, tdata->key.len,
8899 tdata->aad.len, tdata->auth_tag.len,
8904 /* alloc mbuf and set payload */
8905 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8906 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8908 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8909 rte_pktmbuf_tailroom(ut_params->ibuf));
8910 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
8911 rte_pktmbuf_tailroom(ut_params->obuf));
8913 /* Create AEAD operation */
8914 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8918 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8920 ut_params->op->sym->m_src = ut_params->ibuf;
8921 ut_params->op->sym->m_dst = ut_params->obuf;
8923 /* Process crypto operation */
8924 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8925 ut_params->op), "failed to process sym crypto op");
8927 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8928 "crypto op processing failed");
8930 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
8931 ut_params->op->sym->cipher.data.offset);
8933 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8936 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8938 tdata->plaintext.data,
8939 tdata->plaintext.len,
8940 "Plaintext data not as expected");
8942 TEST_ASSERT_EQUAL(ut_params->op->status,
8943 RTE_CRYPTO_OP_STATUS_SUCCESS,
8944 "Authentication failed");
8949 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
8951 return test_authenticated_decryption_oop(&gcm_test_case_5);
8955 test_authenticated_encryption_sessionless(
8956 const struct aead_test_data *tdata)
8958 struct crypto_testsuite_params *ts_params = &testsuite_params;
8959 struct crypto_unittest_params *ut_params = &unittest_params;
8962 uint8_t *ciphertext, *auth_tag;
8963 uint16_t plaintext_pad_len;
8964 uint8_t key[tdata->key.len + 1];
8965 struct rte_cryptodev_info dev_info;
8967 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8968 uint64_t feat_flags = dev_info.feature_flags;
8970 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
8971 printf("Device doesn't support Sessionless ops.\n");
8975 /* not supported with CPU crypto */
8976 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8979 /* Verify the capabilities */
8980 struct rte_cryptodev_sym_capability_idx cap_idx;
8981 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8982 cap_idx.algo.aead = tdata->algo;
8983 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8987 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8989 /* clear mbuf payload */
8990 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8991 rte_pktmbuf_tailroom(ut_params->ibuf));
8993 /* Create AEAD operation */
8994 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8998 /* Create GCM xform */
8999 memcpy(key, tdata->key.data, tdata->key.len);
9000 retval = create_aead_xform(ut_params->op,
9002 RTE_CRYPTO_AEAD_OP_ENCRYPT,
9003 key, tdata->key.len,
9004 tdata->aad.len, tdata->auth_tag.len,
9009 ut_params->op->sym->m_src = ut_params->ibuf;
9011 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9012 RTE_CRYPTO_OP_SESSIONLESS,
9013 "crypto op session type not sessionless");
9015 /* Process crypto operation */
9016 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9017 ut_params->op), "failed to process sym crypto op");
9019 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9021 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9022 "crypto op status not success");
9024 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9026 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9027 ut_params->op->sym->cipher.data.offset);
9028 auth_tag = ciphertext + plaintext_pad_len;
9030 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9031 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9034 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9036 tdata->ciphertext.data,
9037 tdata->ciphertext.len,
9038 "Ciphertext data not as expected");
9040 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9042 tdata->auth_tag.data,
9043 tdata->auth_tag.len,
9044 "Generated auth tag not as expected");
9051 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9053 return test_authenticated_encryption_sessionless(
9058 test_authenticated_decryption_sessionless(
9059 const struct aead_test_data *tdata)
9061 struct crypto_testsuite_params *ts_params = &testsuite_params;
9062 struct crypto_unittest_params *ut_params = &unittest_params;
9066 uint8_t key[tdata->key.len + 1];
9067 struct rte_cryptodev_info dev_info;
9069 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9070 uint64_t feat_flags = dev_info.feature_flags;
9072 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9073 printf("Device doesn't support Sessionless ops.\n");
9077 /* not supported with CPU crypto */
9078 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9081 /* Verify the capabilities */
9082 struct rte_cryptodev_sym_capability_idx cap_idx;
9083 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9084 cap_idx.algo.aead = tdata->algo;
9085 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9089 /* alloc mbuf and set payload */
9090 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9092 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9093 rte_pktmbuf_tailroom(ut_params->ibuf));
9095 /* Create AEAD operation */
9096 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9100 /* Create AEAD xform */
9101 memcpy(key, tdata->key.data, tdata->key.len);
9102 retval = create_aead_xform(ut_params->op,
9104 RTE_CRYPTO_AEAD_OP_DECRYPT,
9105 key, tdata->key.len,
9106 tdata->aad.len, tdata->auth_tag.len,
9111 ut_params->op->sym->m_src = ut_params->ibuf;
9113 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9114 RTE_CRYPTO_OP_SESSIONLESS,
9115 "crypto op session type not sessionless");
9117 /* Process crypto operation */
9118 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9119 ut_params->op), "failed to process sym crypto op");
9121 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9123 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9124 "crypto op status not success");
9126 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9127 ut_params->op->sym->cipher.data.offset);
9129 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9132 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9134 tdata->plaintext.data,
9135 tdata->plaintext.len,
9136 "Plaintext data not as expected");
9138 TEST_ASSERT_EQUAL(ut_params->op->status,
9139 RTE_CRYPTO_OP_STATUS_SUCCESS,
9140 "Authentication failed");
9145 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9147 return test_authenticated_decryption_sessionless(
9152 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9154 return test_authenticated_encryption(&ccm_test_case_128_1);
9158 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9160 return test_authenticated_encryption(&ccm_test_case_128_2);
9164 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9166 return test_authenticated_encryption(&ccm_test_case_128_3);
9170 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9172 return test_authenticated_decryption(&ccm_test_case_128_1);
9176 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9178 return test_authenticated_decryption(&ccm_test_case_128_2);
9182 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9184 return test_authenticated_decryption(&ccm_test_case_128_3);
9188 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9190 return test_authenticated_encryption(&ccm_test_case_192_1);
9194 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9196 return test_authenticated_encryption(&ccm_test_case_192_2);
9200 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
9202 return test_authenticated_encryption(&ccm_test_case_192_3);
9206 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
9208 return test_authenticated_decryption(&ccm_test_case_192_1);
9212 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
9214 return test_authenticated_decryption(&ccm_test_case_192_2);
9218 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
9220 return test_authenticated_decryption(&ccm_test_case_192_3);
9224 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
9226 return test_authenticated_encryption(&ccm_test_case_256_1);
9230 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
9232 return test_authenticated_encryption(&ccm_test_case_256_2);
9236 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
9238 return test_authenticated_encryption(&ccm_test_case_256_3);
9242 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
9244 return test_authenticated_decryption(&ccm_test_case_256_1);
9248 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
9250 return test_authenticated_decryption(&ccm_test_case_256_2);
9254 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
9256 return test_authenticated_decryption(&ccm_test_case_256_3);
9262 struct crypto_testsuite_params *ts_params = &testsuite_params;
9263 struct rte_cryptodev_stats stats;
9265 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9268 /* Verify the capabilities */
9269 struct rte_cryptodev_sym_capability_idx cap_idx;
9270 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9271 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
9272 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9275 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9276 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
9277 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9281 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
9285 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
9286 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
9287 &stats) == -ENODEV),
9288 "rte_cryptodev_stats_get invalid dev failed");
9289 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
9290 "rte_cryptodev_stats_get invalid Param failed");
9292 /* Test expected values */
9294 test_AES_CBC_HMAC_SHA1_encrypt_digest();
9296 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9298 "rte_cryptodev_stats_get failed");
9299 TEST_ASSERT((stats.enqueued_count == 1),
9300 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9301 TEST_ASSERT((stats.dequeued_count == 1),
9302 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9303 TEST_ASSERT((stats.enqueue_err_count == 0),
9304 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9305 TEST_ASSERT((stats.dequeue_err_count == 0),
9306 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9308 /* invalid device but should ignore and not reset device stats*/
9309 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
9310 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9312 "rte_cryptodev_stats_get failed");
9313 TEST_ASSERT((stats.enqueued_count == 1),
9314 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9316 /* check that a valid reset clears stats */
9317 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
9318 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9320 "rte_cryptodev_stats_get failed");
9321 TEST_ASSERT((stats.enqueued_count == 0),
9322 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9323 TEST_ASSERT((stats.dequeued_count == 0),
9324 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9326 return TEST_SUCCESS;
9329 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
9330 struct crypto_unittest_params *ut_params,
9331 enum rte_crypto_auth_operation op,
9332 const struct HMAC_MD5_vector *test_case)
9336 memcpy(key, test_case->key.data, test_case->key.len);
9338 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9339 ut_params->auth_xform.next = NULL;
9340 ut_params->auth_xform.auth.op = op;
9342 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
9344 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
9345 ut_params->auth_xform.auth.key.length = test_case->key.len;
9346 ut_params->auth_xform.auth.key.data = key;
9348 ut_params->sess = rte_cryptodev_sym_session_create(
9349 ts_params->session_mpool);
9351 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9352 ut_params->sess, &ut_params->auth_xform,
9353 ts_params->session_priv_mpool);
9355 if (ut_params->sess == NULL)
9358 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9360 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9361 rte_pktmbuf_tailroom(ut_params->ibuf));
9366 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
9367 const struct HMAC_MD5_vector *test_case,
9368 uint8_t **plaintext)
9370 uint16_t plaintext_pad_len;
9372 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9374 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
9377 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9379 memcpy(*plaintext, test_case->plaintext.data,
9380 test_case->plaintext.len);
9382 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9383 ut_params->ibuf, MD5_DIGEST_LEN);
9384 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9385 "no room to append digest");
9386 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9387 ut_params->ibuf, plaintext_pad_len);
9389 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
9390 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
9391 test_case->auth_tag.len);
9394 sym_op->auth.data.offset = 0;
9395 sym_op->auth.data.length = test_case->plaintext.len;
9397 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9398 ut_params->op->sym->m_src = ut_params->ibuf;
9404 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
9406 uint16_t plaintext_pad_len;
9407 uint8_t *plaintext, *auth_tag;
9409 struct crypto_testsuite_params *ts_params = &testsuite_params;
9410 struct crypto_unittest_params *ut_params = &unittest_params;
9412 /* Verify the capabilities */
9413 struct rte_cryptodev_sym_capability_idx cap_idx;
9414 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9415 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
9416 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9420 if (MD5_HMAC_create_session(ts_params, ut_params,
9421 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
9424 /* Generate Crypto op data structure */
9425 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9426 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9427 TEST_ASSERT_NOT_NULL(ut_params->op,
9428 "Failed to allocate symmetric crypto operation struct");
9430 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
9433 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
9436 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9437 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
9440 TEST_ASSERT_NOT_NULL(
9441 process_crypto_request(ts_params->valid_devs[0],
9443 "failed to process sym crypto op");
9445 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9446 "crypto op processing failed");
9448 if (ut_params->op->sym->m_dst) {
9449 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
9450 uint8_t *, plaintext_pad_len);
9452 auth_tag = plaintext + plaintext_pad_len;
9455 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9457 test_case->auth_tag.data,
9458 test_case->auth_tag.len,
9459 "HMAC_MD5 generated tag not as expected");
9461 return TEST_SUCCESS;
9465 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
9469 struct crypto_testsuite_params *ts_params = &testsuite_params;
9470 struct crypto_unittest_params *ut_params = &unittest_params;
9472 /* Verify the capabilities */
9473 struct rte_cryptodev_sym_capability_idx cap_idx;
9474 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9475 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
9476 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9480 if (MD5_HMAC_create_session(ts_params, ut_params,
9481 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
9485 /* Generate Crypto op data structure */
9486 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9487 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9488 TEST_ASSERT_NOT_NULL(ut_params->op,
9489 "Failed to allocate symmetric crypto operation struct");
9491 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
9494 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9495 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
9498 TEST_ASSERT_NOT_NULL(
9499 process_crypto_request(ts_params->valid_devs[0],
9501 "failed to process sym crypto op");
9503 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9504 "HMAC_MD5 crypto op processing failed");
9506 return TEST_SUCCESS;
9510 test_MD5_HMAC_generate_case_1(void)
9512 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
9516 test_MD5_HMAC_verify_case_1(void)
9518 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
9522 test_MD5_HMAC_generate_case_2(void)
9524 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
9528 test_MD5_HMAC_verify_case_2(void)
9530 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
9534 test_multi_session(void)
9536 struct crypto_testsuite_params *ts_params = &testsuite_params;
9537 struct crypto_unittest_params *ut_params = &unittest_params;
9539 struct rte_cryptodev_info dev_info;
9540 struct rte_cryptodev_sym_session **sessions;
9544 /* Verify the capabilities */
9545 struct rte_cryptodev_sym_capability_idx cap_idx;
9546 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9547 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
9548 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9551 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9552 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
9553 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9557 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
9558 aes_cbc_key, hmac_sha512_key);
9561 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9563 sessions = rte_malloc(NULL,
9564 (sizeof(struct rte_cryptodev_sym_session *) *
9565 MAX_NB_SESSIONS) + 1, 0);
9567 /* Create multiple crypto sessions*/
9568 for (i = 0; i < MAX_NB_SESSIONS; i++) {
9570 sessions[i] = rte_cryptodev_sym_session_create(
9571 ts_params->session_mpool);
9573 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9574 sessions[i], &ut_params->auth_xform,
9575 ts_params->session_priv_mpool);
9576 TEST_ASSERT_NOT_NULL(sessions[i],
9577 "Session creation failed at session number %u",
9580 /* Attempt to send a request on each session */
9581 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
9585 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
9586 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
9588 "Failed to perform decrypt on request number %u.", i);
9589 /* free crypto operation structure */
9591 rte_crypto_op_free(ut_params->op);
9594 * free mbuf - both obuf and ibuf are usually the same,
9595 * so check if they point at the same address is necessary,
9596 * to avoid freeing the mbuf twice.
9598 if (ut_params->obuf) {
9599 rte_pktmbuf_free(ut_params->obuf);
9600 if (ut_params->ibuf == ut_params->obuf)
9601 ut_params->ibuf = 0;
9602 ut_params->obuf = 0;
9604 if (ut_params->ibuf) {
9605 rte_pktmbuf_free(ut_params->ibuf);
9606 ut_params->ibuf = 0;
9610 /* Next session create should fail */
9611 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9612 sessions[i], &ut_params->auth_xform,
9613 ts_params->session_priv_mpool);
9614 TEST_ASSERT_NULL(sessions[i],
9615 "Session creation succeeded unexpectedly!");
9617 for (i = 0; i < MAX_NB_SESSIONS; i++) {
9618 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9620 rte_cryptodev_sym_session_free(sessions[i]);
9625 return TEST_SUCCESS;
9628 struct multi_session_params {
9629 struct crypto_unittest_params ut_params;
9630 uint8_t *cipher_key;
9632 const uint8_t *cipher;
9633 const uint8_t *digest;
9637 #define MB_SESSION_NUMBER 3
9640 test_multi_session_random_usage(void)
9642 struct crypto_testsuite_params *ts_params = &testsuite_params;
9643 struct rte_cryptodev_info dev_info;
9644 struct rte_cryptodev_sym_session **sessions;
9646 struct multi_session_params ut_paramz[] = {
9649 .cipher_key = ms_aes_cbc_key0,
9650 .hmac_key = ms_hmac_key0,
9651 .cipher = ms_aes_cbc_cipher0,
9652 .digest = ms_hmac_digest0,
9653 .iv = ms_aes_cbc_iv0
9656 .cipher_key = ms_aes_cbc_key1,
9657 .hmac_key = ms_hmac_key1,
9658 .cipher = ms_aes_cbc_cipher1,
9659 .digest = ms_hmac_digest1,
9660 .iv = ms_aes_cbc_iv1
9663 .cipher_key = ms_aes_cbc_key2,
9664 .hmac_key = ms_hmac_key2,
9665 .cipher = ms_aes_cbc_cipher2,
9666 .digest = ms_hmac_digest2,
9667 .iv = ms_aes_cbc_iv2
9672 /* Verify the capabilities */
9673 struct rte_cryptodev_sym_capability_idx cap_idx;
9674 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9675 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
9676 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9679 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9680 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
9681 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9685 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9687 sessions = rte_malloc(NULL,
9688 (sizeof(struct rte_cryptodev_sym_session *)
9689 * MAX_NB_SESSIONS) + 1, 0);
9691 for (i = 0; i < MB_SESSION_NUMBER; i++) {
9692 sessions[i] = rte_cryptodev_sym_session_create(
9693 ts_params->session_mpool);
9695 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
9696 sizeof(struct crypto_unittest_params));
9698 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
9699 &ut_paramz[i].ut_params,
9700 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
9702 /* Create multiple crypto sessions*/
9703 rte_cryptodev_sym_session_init(
9704 ts_params->valid_devs[0],
9706 &ut_paramz[i].ut_params.auth_xform,
9707 ts_params->session_priv_mpool);
9709 TEST_ASSERT_NOT_NULL(sessions[i],
9710 "Session creation failed at session number %u",
9716 for (i = 0; i < 40000; i++) {
9718 j = rand() % MB_SESSION_NUMBER;
9720 TEST_ASSERT_SUCCESS(
9721 test_AES_CBC_HMAC_SHA512_decrypt_perform(
9723 &ut_paramz[j].ut_params,
9724 ts_params, ut_paramz[j].cipher,
9725 ut_paramz[j].digest,
9727 "Failed to perform decrypt on request number %u.", i);
9729 if (ut_paramz[j].ut_params.op)
9730 rte_crypto_op_free(ut_paramz[j].ut_params.op);
9733 * free mbuf - both obuf and ibuf are usually the same,
9734 * so check if they point at the same address is necessary,
9735 * to avoid freeing the mbuf twice.
9737 if (ut_paramz[j].ut_params.obuf) {
9738 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
9739 if (ut_paramz[j].ut_params.ibuf
9740 == ut_paramz[j].ut_params.obuf)
9741 ut_paramz[j].ut_params.ibuf = 0;
9742 ut_paramz[j].ut_params.obuf = 0;
9744 if (ut_paramz[j].ut_params.ibuf) {
9745 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
9746 ut_paramz[j].ut_params.ibuf = 0;
9750 for (i = 0; i < MB_SESSION_NUMBER; i++) {
9751 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9753 rte_cryptodev_sym_session_free(sessions[i]);
9758 return TEST_SUCCESS;
9762 test_null_cipher_only_operation(void)
9764 struct crypto_testsuite_params *ts_params = &testsuite_params;
9765 struct crypto_unittest_params *ut_params = &unittest_params;
9767 /* Verify the capabilities */
9768 struct rte_cryptodev_sym_capability_idx cap_idx;
9769 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9770 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
9771 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9775 /* Generate test mbuf data and space for digest */
9776 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9777 catch_22_quote, QUOTE_512_BYTES, 0);
9779 /* Setup Cipher Parameters */
9780 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9781 ut_params->cipher_xform.next = NULL;
9783 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9784 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9786 ut_params->sess = rte_cryptodev_sym_session_create(
9787 ts_params->session_mpool);
9789 /* Create Crypto session*/
9790 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9792 &ut_params->cipher_xform,
9793 ts_params->session_priv_mpool);
9794 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9796 /* Generate Crypto op data structure */
9797 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9798 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9799 TEST_ASSERT_NOT_NULL(ut_params->op,
9800 "Failed to allocate symmetric crypto operation struct");
9802 /* Set crypto operation data parameters */
9803 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9805 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9807 /* set crypto operation source mbuf */
9808 sym_op->m_src = ut_params->ibuf;
9810 sym_op->cipher.data.offset = 0;
9811 sym_op->cipher.data.length = QUOTE_512_BYTES;
9813 /* Process crypto operation */
9814 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9816 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9818 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9819 "crypto operation processing failed");
9822 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9823 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
9826 "Ciphertext data not as expected");
9828 return TEST_SUCCESS;
9830 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
9831 0xab, 0xab, 0xab, 0xab,
9832 0xab, 0xab, 0xab, 0xab,
9833 0xab, 0xab, 0xab, 0xab};
9835 test_null_auth_only_operation(void)
9837 struct crypto_testsuite_params *ts_params = &testsuite_params;
9838 struct crypto_unittest_params *ut_params = &unittest_params;
9841 /* Verify the capabilities */
9842 struct rte_cryptodev_sym_capability_idx cap_idx;
9843 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9844 cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
9845 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9849 /* Generate test mbuf data and space for digest */
9850 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9851 catch_22_quote, QUOTE_512_BYTES, 0);
9853 /* create a pointer for digest, but don't expect anything to be written
9854 * here in a NULL auth algo so no mbuf append done.
9856 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9858 /* prefill the memory pointed to by digest */
9859 memcpy(digest, orig_data, sizeof(orig_data));
9861 /* Setup HMAC Parameters */
9862 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9863 ut_params->auth_xform.next = NULL;
9865 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9866 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9868 ut_params->sess = rte_cryptodev_sym_session_create(
9869 ts_params->session_mpool);
9871 /* Create Crypto session*/
9872 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9873 ut_params->sess, &ut_params->auth_xform,
9874 ts_params->session_priv_mpool);
9875 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9877 /* Generate Crypto op data structure */
9878 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9879 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9880 TEST_ASSERT_NOT_NULL(ut_params->op,
9881 "Failed to allocate symmetric crypto operation struct");
9883 /* Set crypto operation data parameters */
9884 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9886 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9888 sym_op->m_src = ut_params->ibuf;
9890 sym_op->auth.data.offset = 0;
9891 sym_op->auth.data.length = QUOTE_512_BYTES;
9892 sym_op->auth.digest.data = digest;
9893 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9896 /* Process crypto operation */
9897 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9899 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9901 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9902 "crypto operation processing failed");
9903 /* Make sure memory pointed to by digest hasn't been overwritten */
9904 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9908 "Memory at digest ptr overwritten unexpectedly");
9910 return TEST_SUCCESS;
9915 test_null_cipher_auth_operation(void)
9917 struct crypto_testsuite_params *ts_params = &testsuite_params;
9918 struct crypto_unittest_params *ut_params = &unittest_params;
9921 /* Verify the capabilities */
9922 struct rte_cryptodev_sym_capability_idx cap_idx;
9923 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9924 cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
9925 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9928 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9929 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
9930 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9934 /* Generate test mbuf data and space for digest */
9935 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9936 catch_22_quote, QUOTE_512_BYTES, 0);
9938 /* create a pointer for digest, but don't expect anything to be written
9939 * here in a NULL auth algo so no mbuf append done.
9941 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9943 /* prefill the memory pointed to by digest */
9944 memcpy(digest, orig_data, sizeof(orig_data));
9946 /* Setup Cipher Parameters */
9947 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9948 ut_params->cipher_xform.next = &ut_params->auth_xform;
9950 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9951 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9953 /* Setup HMAC Parameters */
9954 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9955 ut_params->auth_xform.next = NULL;
9957 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9958 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9960 ut_params->sess = rte_cryptodev_sym_session_create(
9961 ts_params->session_mpool);
9963 /* Create Crypto session*/
9964 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9965 ut_params->sess, &ut_params->cipher_xform,
9966 ts_params->session_priv_mpool);
9967 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9969 /* Generate Crypto op data structure */
9970 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9971 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9972 TEST_ASSERT_NOT_NULL(ut_params->op,
9973 "Failed to allocate symmetric crypto operation struct");
9975 /* Set crypto operation data parameters */
9976 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9978 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9980 sym_op->m_src = ut_params->ibuf;
9982 sym_op->cipher.data.offset = 0;
9983 sym_op->cipher.data.length = QUOTE_512_BYTES;
9985 sym_op->auth.data.offset = 0;
9986 sym_op->auth.data.length = QUOTE_512_BYTES;
9987 sym_op->auth.digest.data = digest;
9988 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9991 /* Process crypto operation */
9992 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9994 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9996 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9997 "crypto operation processing failed");
10000 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10001 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
10004 "Ciphertext data not as expected");
10005 /* Make sure memory pointed to by digest hasn't been overwritten */
10006 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10010 "Memory at digest ptr overwritten unexpectedly");
10012 return TEST_SUCCESS;
10016 test_null_auth_cipher_operation(void)
10018 struct crypto_testsuite_params *ts_params = &testsuite_params;
10019 struct crypto_unittest_params *ut_params = &unittest_params;
10022 /* Verify the capabilities */
10023 struct rte_cryptodev_sym_capability_idx cap_idx;
10024 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10025 cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
10026 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10029 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10030 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
10031 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10035 /* Generate test mbuf data */
10036 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
10037 catch_22_quote, QUOTE_512_BYTES, 0);
10039 /* create a pointer for digest, but don't expect anything to be written
10040 * here in a NULL auth algo so no mbuf append done.
10042 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10044 /* prefill the memory pointed to by digest */
10045 memcpy(digest, orig_data, sizeof(orig_data));
10047 /* Setup Cipher Parameters */
10048 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10049 ut_params->cipher_xform.next = NULL;
10051 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10052 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10054 /* Setup HMAC Parameters */
10055 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10056 ut_params->auth_xform.next = &ut_params->cipher_xform;
10058 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10059 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10061 ut_params->sess = rte_cryptodev_sym_session_create(
10062 ts_params->session_mpool);
10064 /* Create Crypto session*/
10065 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10066 ut_params->sess, &ut_params->cipher_xform,
10067 ts_params->session_priv_mpool);
10068 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10070 /* Generate Crypto op data structure */
10071 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10072 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10073 TEST_ASSERT_NOT_NULL(ut_params->op,
10074 "Failed to allocate symmetric crypto operation struct");
10076 /* Set crypto operation data parameters */
10077 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10079 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10081 sym_op->m_src = ut_params->ibuf;
10083 sym_op->cipher.data.offset = 0;
10084 sym_op->cipher.data.length = QUOTE_512_BYTES;
10086 sym_op->auth.data.offset = 0;
10087 sym_op->auth.data.length = QUOTE_512_BYTES;
10088 sym_op->auth.digest.data = digest;
10089 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
10092 /* Process crypto operation */
10093 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10095 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
10097 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10098 "crypto operation processing failed");
10100 /* Validate obuf */
10101 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10102 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
10105 "Ciphertext data not as expected");
10106 /* Make sure memory pointed to by digest hasn't been overwritten */
10107 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10111 "Memory at digest ptr overwritten unexpectedly");
10113 return TEST_SUCCESS;
10118 test_null_invalid_operation(void)
10120 struct crypto_testsuite_params *ts_params = &testsuite_params;
10121 struct crypto_unittest_params *ut_params = &unittest_params;
10124 /* This test is for NULL PMD only */
10125 if (gbl_driver_id != rte_cryptodev_driver_id_get(
10126 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10129 /* Setup Cipher Parameters */
10130 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10131 ut_params->cipher_xform.next = NULL;
10133 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10134 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10136 ut_params->sess = rte_cryptodev_sym_session_create(
10137 ts_params->session_mpool);
10139 /* Create Crypto session*/
10140 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10141 ut_params->sess, &ut_params->cipher_xform,
10142 ts_params->session_priv_mpool);
10143 TEST_ASSERT(ret < 0,
10144 "Session creation succeeded unexpectedly");
10147 /* Setup HMAC Parameters */
10148 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10149 ut_params->auth_xform.next = NULL;
10151 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10152 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10154 ut_params->sess = rte_cryptodev_sym_session_create(
10155 ts_params->session_mpool);
10157 /* Create Crypto session*/
10158 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10159 ut_params->sess, &ut_params->auth_xform,
10160 ts_params->session_priv_mpool);
10161 TEST_ASSERT(ret < 0,
10162 "Session creation succeeded unexpectedly");
10164 return TEST_SUCCESS;
10168 #define NULL_BURST_LENGTH (32)
10171 test_null_burst_operation(void)
10173 struct crypto_testsuite_params *ts_params = &testsuite_params;
10174 struct crypto_unittest_params *ut_params = &unittest_params;
10176 unsigned i, burst_len = NULL_BURST_LENGTH;
10178 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10179 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10181 /* This test is for NULL PMD only */
10182 if (gbl_driver_id != rte_cryptodev_driver_id_get(
10183 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10186 /* Setup Cipher Parameters */
10187 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10188 ut_params->cipher_xform.next = &ut_params->auth_xform;
10190 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10191 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10193 /* Setup HMAC Parameters */
10194 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10195 ut_params->auth_xform.next = NULL;
10197 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10198 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10200 ut_params->sess = rte_cryptodev_sym_session_create(
10201 ts_params->session_mpool);
10203 /* Create Crypto session*/
10204 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10205 ut_params->sess, &ut_params->cipher_xform,
10206 ts_params->session_priv_mpool);
10207 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10209 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10210 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10211 burst_len, "failed to generate burst of crypto ops");
10213 /* Generate an operation for each mbuf in burst */
10214 for (i = 0; i < burst_len; i++) {
10215 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10217 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10219 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10223 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10225 burst[i]->sym->m_src = m;
10228 /* Process crypto operation */
10229 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10230 0, burst, burst_len),
10232 "Error enqueuing burst");
10234 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10235 0, burst_dequeued, burst_len),
10237 "Error dequeuing burst");
10240 for (i = 0; i < burst_len; i++) {
10242 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10243 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10245 "data not as expected");
10247 rte_pktmbuf_free(burst[i]->sym->m_src);
10248 rte_crypto_op_free(burst[i]);
10251 return TEST_SUCCESS;
10255 generate_gmac_large_plaintext(uint8_t *data)
10259 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10260 memcpy(&data[i], &data[0], 32);
10264 create_gmac_operation(enum rte_crypto_auth_operation op,
10265 const struct gmac_test_data *tdata)
10267 struct crypto_testsuite_params *ts_params = &testsuite_params;
10268 struct crypto_unittest_params *ut_params = &unittest_params;
10269 struct rte_crypto_sym_op *sym_op;
10271 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10273 /* Generate Crypto op data structure */
10274 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10275 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10276 TEST_ASSERT_NOT_NULL(ut_params->op,
10277 "Failed to allocate symmetric crypto operation struct");
10279 sym_op = ut_params->op->sym;
10281 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10282 ut_params->ibuf, tdata->gmac_tag.len);
10283 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10284 "no room to append digest");
10286 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10287 ut_params->ibuf, plaintext_pad_len);
10289 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10290 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10291 tdata->gmac_tag.len);
10292 debug_hexdump(stdout, "digest:",
10293 sym_op->auth.digest.data,
10294 tdata->gmac_tag.len);
10297 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10298 uint8_t *, IV_OFFSET);
10300 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10302 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10304 sym_op->cipher.data.length = 0;
10305 sym_op->cipher.data.offset = 0;
10307 sym_op->auth.data.offset = 0;
10308 sym_op->auth.data.length = tdata->plaintext.len;
10313 static int create_gmac_session(uint8_t dev_id,
10314 const struct gmac_test_data *tdata,
10315 enum rte_crypto_auth_operation auth_op)
10317 uint8_t auth_key[tdata->key.len];
10319 struct crypto_testsuite_params *ts_params = &testsuite_params;
10320 struct crypto_unittest_params *ut_params = &unittest_params;
10322 memcpy(auth_key, tdata->key.data, tdata->key.len);
10324 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10325 ut_params->auth_xform.next = NULL;
10327 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
10328 ut_params->auth_xform.auth.op = auth_op;
10329 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
10330 ut_params->auth_xform.auth.key.length = tdata->key.len;
10331 ut_params->auth_xform.auth.key.data = auth_key;
10332 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10333 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
10336 ut_params->sess = rte_cryptodev_sym_session_create(
10337 ts_params->session_mpool);
10339 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10340 &ut_params->auth_xform,
10341 ts_params->session_priv_mpool);
10343 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10349 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
10351 struct crypto_testsuite_params *ts_params = &testsuite_params;
10352 struct crypto_unittest_params *ut_params = &unittest_params;
10356 uint8_t *auth_tag, *plaintext;
10357 uint16_t plaintext_pad_len;
10359 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10360 "No GMAC length in the source data");
10362 /* Verify the capabilities */
10363 struct rte_cryptodev_sym_capability_idx cap_idx;
10364 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10365 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10366 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10370 retval = create_gmac_session(ts_params->valid_devs[0],
10371 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
10376 if (tdata->plaintext.len > MBUF_SIZE)
10377 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10379 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10380 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10381 "Failed to allocate input buffer in mempool");
10383 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10384 rte_pktmbuf_tailroom(ut_params->ibuf));
10386 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10388 * Runtime generate the large plain text instead of use hard code
10389 * plain text vector. It is done to avoid create huge source file
10390 * with the test vector.
10392 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10393 generate_gmac_large_plaintext(tdata->plaintext.data);
10395 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10396 plaintext_pad_len);
10397 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10399 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10400 debug_hexdump(stdout, "plaintext:", plaintext,
10401 tdata->plaintext.len);
10403 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
10409 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10411 ut_params->op->sym->m_src = ut_params->ibuf;
10413 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10414 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10417 TEST_ASSERT_NOT_NULL(
10418 process_crypto_request(ts_params->valid_devs[0],
10419 ut_params->op), "failed to process sym crypto op");
10421 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10422 "crypto op processing failed");
10424 if (ut_params->op->sym->m_dst) {
10425 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10426 uint8_t *, plaintext_pad_len);
10428 auth_tag = plaintext + plaintext_pad_len;
10431 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
10433 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10435 tdata->gmac_tag.data,
10436 tdata->gmac_tag.len,
10437 "GMAC Generated auth tag not as expected");
10443 test_AES_GMAC_authentication_test_case_1(void)
10445 return test_AES_GMAC_authentication(&gmac_test_case_1);
10449 test_AES_GMAC_authentication_test_case_2(void)
10451 return test_AES_GMAC_authentication(&gmac_test_case_2);
10455 test_AES_GMAC_authentication_test_case_3(void)
10457 return test_AES_GMAC_authentication(&gmac_test_case_3);
10461 test_AES_GMAC_authentication_test_case_4(void)
10463 return test_AES_GMAC_authentication(&gmac_test_case_4);
10467 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
10469 struct crypto_testsuite_params *ts_params = &testsuite_params;
10470 struct crypto_unittest_params *ut_params = &unittest_params;
10472 uint32_t plaintext_pad_len;
10473 uint8_t *plaintext;
10475 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10476 "No GMAC length in the source data");
10478 /* Verify the capabilities */
10479 struct rte_cryptodev_sym_capability_idx cap_idx;
10480 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10481 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10482 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10486 retval = create_gmac_session(ts_params->valid_devs[0],
10487 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
10492 if (tdata->plaintext.len > MBUF_SIZE)
10493 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10495 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10496 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10497 "Failed to allocate input buffer in mempool");
10499 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10500 rte_pktmbuf_tailroom(ut_params->ibuf));
10502 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10505 * Runtime generate the large plain text instead of use hard code
10506 * plain text vector. It is done to avoid create huge source file
10507 * with the test vector.
10509 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10510 generate_gmac_large_plaintext(tdata->plaintext.data);
10512 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10513 plaintext_pad_len);
10514 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10516 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10517 debug_hexdump(stdout, "plaintext:", plaintext,
10518 tdata->plaintext.len);
10520 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
10526 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10528 ut_params->op->sym->m_src = ut_params->ibuf;
10530 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10531 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10534 TEST_ASSERT_NOT_NULL(
10535 process_crypto_request(ts_params->valid_devs[0],
10536 ut_params->op), "failed to process sym crypto op");
10538 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10539 "crypto op processing failed");
10546 test_AES_GMAC_authentication_verify_test_case_1(void)
10548 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
10552 test_AES_GMAC_authentication_verify_test_case_2(void)
10554 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
10558 test_AES_GMAC_authentication_verify_test_case_3(void)
10560 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
10564 test_AES_GMAC_authentication_verify_test_case_4(void)
10566 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
10569 struct test_crypto_vector {
10570 enum rte_crypto_cipher_algorithm crypto_algo;
10571 unsigned int cipher_offset;
10572 unsigned int cipher_len;
10585 const uint8_t *data;
10590 const uint8_t *data;
10594 enum rte_crypto_auth_algorithm auth_algo;
10595 unsigned int auth_offset;
10603 const uint8_t *data;
10613 static const struct test_crypto_vector
10614 hmac_sha1_test_crypto_vector = {
10615 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10617 .data = plaintext_hash,
10622 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10623 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10624 0xDE, 0xF4, 0xDE, 0xAD
10630 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
10631 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
10632 0x3F, 0x91, 0x64, 0x59
10638 static const struct test_crypto_vector
10639 aes128_gmac_test_vector = {
10640 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
10642 .data = plaintext_hash,
10647 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10648 0x08, 0x09, 0x0A, 0x0B
10654 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10655 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
10661 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
10662 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
10668 static const struct test_crypto_vector
10669 aes128cbc_hmac_sha1_test_vector = {
10670 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10671 .cipher_offset = 0,
10675 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10676 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10682 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10683 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10688 .data = plaintext_hash,
10692 .data = ciphertext512_aes128cbc,
10695 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10699 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10700 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10701 0xDE, 0xF4, 0xDE, 0xAD
10707 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
10708 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10709 0x18, 0x8C, 0x1D, 0x32
10715 static const struct test_crypto_vector
10716 aes128cbc_hmac_sha1_aad_test_vector = {
10717 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10718 .cipher_offset = 12,
10722 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10723 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10729 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10730 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10735 .data = plaintext_hash,
10739 .data = ciphertext512_aes128cbc_aad,
10742 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10746 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10747 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10748 0xDE, 0xF4, 0xDE, 0xAD
10754 0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
10755 0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
10756 0x62, 0x8D, 0x62, 0x65
10763 data_corruption(uint8_t *data)
10769 tag_corruption(uint8_t *data, unsigned int tag_offset)
10771 data[tag_offset] += 1;
10775 create_auth_session(struct crypto_unittest_params *ut_params,
10777 const struct test_crypto_vector *reference,
10778 enum rte_crypto_auth_operation auth_op)
10780 struct crypto_testsuite_params *ts_params = &testsuite_params;
10781 uint8_t auth_key[reference->auth_key.len + 1];
10783 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10785 /* Setup Authentication Parameters */
10786 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10787 ut_params->auth_xform.auth.op = auth_op;
10788 ut_params->auth_xform.next = NULL;
10789 ut_params->auth_xform.auth.algo = reference->auth_algo;
10790 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10791 ut_params->auth_xform.auth.key.data = auth_key;
10792 ut_params->auth_xform.auth.digest_length = reference->digest.len;
10794 /* Create Crypto session*/
10795 ut_params->sess = rte_cryptodev_sym_session_create(
10796 ts_params->session_mpool);
10798 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10799 &ut_params->auth_xform,
10800 ts_params->session_priv_mpool);
10802 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10808 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
10810 const struct test_crypto_vector *reference,
10811 enum rte_crypto_auth_operation auth_op,
10812 enum rte_crypto_cipher_operation cipher_op)
10814 struct crypto_testsuite_params *ts_params = &testsuite_params;
10815 uint8_t cipher_key[reference->cipher_key.len + 1];
10816 uint8_t auth_key[reference->auth_key.len + 1];
10818 memcpy(cipher_key, reference->cipher_key.data,
10819 reference->cipher_key.len);
10820 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10822 /* Setup Authentication Parameters */
10823 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10824 ut_params->auth_xform.auth.op = auth_op;
10825 ut_params->auth_xform.auth.algo = reference->auth_algo;
10826 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10827 ut_params->auth_xform.auth.key.data = auth_key;
10828 ut_params->auth_xform.auth.digest_length = reference->digest.len;
10830 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
10831 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10832 ut_params->auth_xform.auth.iv.length = reference->iv.len;
10834 ut_params->auth_xform.next = &ut_params->cipher_xform;
10836 /* Setup Cipher Parameters */
10837 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10838 ut_params->cipher_xform.next = NULL;
10839 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
10840 ut_params->cipher_xform.cipher.op = cipher_op;
10841 ut_params->cipher_xform.cipher.key.data = cipher_key;
10842 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
10843 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10844 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
10847 /* Create Crypto session*/
10848 ut_params->sess = rte_cryptodev_sym_session_create(
10849 ts_params->session_mpool);
10851 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10852 &ut_params->auth_xform,
10853 ts_params->session_priv_mpool);
10855 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10861 create_auth_operation(struct crypto_testsuite_params *ts_params,
10862 struct crypto_unittest_params *ut_params,
10863 const struct test_crypto_vector *reference,
10864 unsigned int auth_generate)
10866 /* Generate Crypto op data structure */
10867 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10868 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10869 TEST_ASSERT_NOT_NULL(ut_params->op,
10870 "Failed to allocate pktmbuf offload");
10872 /* Set crypto operation data parameters */
10873 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10875 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10877 /* set crypto operation source mbuf */
10878 sym_op->m_src = ut_params->ibuf;
10881 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10882 ut_params->ibuf, reference->digest.len);
10884 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10885 "no room to append auth tag");
10887 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10888 ut_params->ibuf, reference->plaintext.len);
10891 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10893 memcpy(sym_op->auth.digest.data,
10894 reference->digest.data,
10895 reference->digest.len);
10897 debug_hexdump(stdout, "digest:",
10898 sym_op->auth.digest.data,
10899 reference->digest.len);
10901 sym_op->auth.data.length = reference->plaintext.len;
10902 sym_op->auth.data.offset = 0;
10908 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
10909 struct crypto_unittest_params *ut_params,
10910 const struct test_crypto_vector *reference,
10911 unsigned int auth_generate)
10913 /* Generate Crypto op data structure */
10914 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10915 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10916 TEST_ASSERT_NOT_NULL(ut_params->op,
10917 "Failed to allocate pktmbuf offload");
10919 /* Set crypto operation data parameters */
10920 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10922 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10924 /* set crypto operation source mbuf */
10925 sym_op->m_src = ut_params->ibuf;
10928 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10929 ut_params->ibuf, reference->digest.len);
10931 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10932 "no room to append auth tag");
10934 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10935 ut_params->ibuf, reference->ciphertext.len);
10938 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10940 memcpy(sym_op->auth.digest.data,
10941 reference->digest.data,
10942 reference->digest.len);
10944 debug_hexdump(stdout, "digest:",
10945 sym_op->auth.digest.data,
10946 reference->digest.len);
10948 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
10949 reference->iv.data, reference->iv.len);
10951 sym_op->cipher.data.length = 0;
10952 sym_op->cipher.data.offset = 0;
10954 sym_op->auth.data.length = reference->plaintext.len;
10955 sym_op->auth.data.offset = 0;
10961 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
10962 struct crypto_unittest_params *ut_params,
10963 const struct test_crypto_vector *reference,
10964 unsigned int auth_generate)
10966 /* Generate Crypto op data structure */
10967 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10968 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10969 TEST_ASSERT_NOT_NULL(ut_params->op,
10970 "Failed to allocate pktmbuf offload");
10972 /* Set crypto operation data parameters */
10973 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10975 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10977 /* set crypto operation source mbuf */
10978 sym_op->m_src = ut_params->ibuf;
10981 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10982 ut_params->ibuf, reference->digest.len);
10984 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10985 "no room to append auth tag");
10987 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10988 ut_params->ibuf, reference->ciphertext.len);
10991 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10993 memcpy(sym_op->auth.digest.data,
10994 reference->digest.data,
10995 reference->digest.len);
10997 debug_hexdump(stdout, "digest:",
10998 sym_op->auth.digest.data,
10999 reference->digest.len);
11001 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11002 reference->iv.data, reference->iv.len);
11004 sym_op->cipher.data.length = reference->cipher_len;
11005 sym_op->cipher.data.offset = reference->cipher_offset;
11007 sym_op->auth.data.length = reference->plaintext.len;
11008 sym_op->auth.data.offset = reference->auth_offset;
11014 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11015 struct crypto_unittest_params *ut_params,
11016 const struct test_crypto_vector *reference)
11018 return create_auth_operation(ts_params, ut_params, reference, 0);
11022 create_auth_verify_GMAC_operation(
11023 struct crypto_testsuite_params *ts_params,
11024 struct crypto_unittest_params *ut_params,
11025 const struct test_crypto_vector *reference)
11027 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11031 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11032 struct crypto_unittest_params *ut_params,
11033 const struct test_crypto_vector *reference)
11035 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11039 test_authentication_verify_fail_when_data_corruption(
11040 struct crypto_testsuite_params *ts_params,
11041 struct crypto_unittest_params *ut_params,
11042 const struct test_crypto_vector *reference,
11043 unsigned int data_corrupted)
11047 uint8_t *plaintext;
11049 /* Verify the capabilities */
11050 struct rte_cryptodev_sym_capability_idx cap_idx;
11051 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11052 cap_idx.algo.auth = reference->auth_algo;
11053 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11057 /* Create session */
11058 retval = create_auth_session(ut_params,
11059 ts_params->valid_devs[0],
11061 RTE_CRYPTO_AUTH_OP_VERIFY);
11065 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11066 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11067 "Failed to allocate input buffer in mempool");
11069 /* clear mbuf payload */
11070 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11071 rte_pktmbuf_tailroom(ut_params->ibuf));
11073 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11074 reference->plaintext.len);
11075 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11076 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11078 debug_hexdump(stdout, "plaintext:", plaintext,
11079 reference->plaintext.len);
11081 /* Create operation */
11082 retval = create_auth_verify_operation(ts_params, ut_params, reference);
11087 if (data_corrupted)
11088 data_corruption(plaintext);
11090 tag_corruption(plaintext, reference->plaintext.len);
11092 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11093 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11095 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11096 RTE_CRYPTO_OP_STATUS_SUCCESS,
11097 "authentication not failed");
11099 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11101 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11108 test_authentication_verify_GMAC_fail_when_corruption(
11109 struct crypto_testsuite_params *ts_params,
11110 struct crypto_unittest_params *ut_params,
11111 const struct test_crypto_vector *reference,
11112 unsigned int data_corrupted)
11115 uint8_t *plaintext;
11117 /* Verify the capabilities */
11118 struct rte_cryptodev_sym_capability_idx cap_idx;
11119 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11120 cap_idx.algo.auth = reference->auth_algo;
11121 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11125 /* Create session */
11126 retval = create_auth_cipher_session(ut_params,
11127 ts_params->valid_devs[0],
11129 RTE_CRYPTO_AUTH_OP_VERIFY,
11130 RTE_CRYPTO_CIPHER_OP_DECRYPT);
11134 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11135 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11136 "Failed to allocate input buffer in mempool");
11138 /* clear mbuf payload */
11139 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11140 rte_pktmbuf_tailroom(ut_params->ibuf));
11142 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11143 reference->plaintext.len);
11144 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11145 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11147 debug_hexdump(stdout, "plaintext:", plaintext,
11148 reference->plaintext.len);
11150 /* Create operation */
11151 retval = create_auth_verify_GMAC_operation(ts_params,
11158 if (data_corrupted)
11159 data_corruption(plaintext);
11161 tag_corruption(plaintext, reference->aad.len);
11163 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11164 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11166 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11167 RTE_CRYPTO_OP_STATUS_SUCCESS,
11168 "authentication not failed");
11170 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11172 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11179 test_authenticated_decryption_fail_when_corruption(
11180 struct crypto_testsuite_params *ts_params,
11181 struct crypto_unittest_params *ut_params,
11182 const struct test_crypto_vector *reference,
11183 unsigned int data_corrupted)
11187 uint8_t *ciphertext;
11189 /* Verify the capabilities */
11190 struct rte_cryptodev_sym_capability_idx cap_idx;
11191 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11192 cap_idx.algo.auth = reference->auth_algo;
11193 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11196 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11197 cap_idx.algo.cipher = reference->crypto_algo;
11198 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11202 /* Create session */
11203 retval = create_auth_cipher_session(ut_params,
11204 ts_params->valid_devs[0],
11206 RTE_CRYPTO_AUTH_OP_VERIFY,
11207 RTE_CRYPTO_CIPHER_OP_DECRYPT);
11211 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11212 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11213 "Failed to allocate input buffer in mempool");
11215 /* clear mbuf payload */
11216 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11217 rte_pktmbuf_tailroom(ut_params->ibuf));
11219 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11220 reference->ciphertext.len);
11221 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11222 memcpy(ciphertext, reference->ciphertext.data,
11223 reference->ciphertext.len);
11225 /* Create operation */
11226 retval = create_cipher_auth_verify_operation(ts_params,
11233 if (data_corrupted)
11234 data_corruption(ciphertext);
11236 tag_corruption(ciphertext, reference->ciphertext.len);
11238 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11239 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11241 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11242 RTE_CRYPTO_OP_STATUS_SUCCESS,
11243 "authentication not failed");
11245 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11247 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11254 test_authenticated_encryt_with_esn(
11255 struct crypto_testsuite_params *ts_params,
11256 struct crypto_unittest_params *ut_params,
11257 const struct test_crypto_vector *reference)
11261 uint8_t *authciphertext, *plaintext, *auth_tag;
11262 uint16_t plaintext_pad_len;
11263 uint8_t cipher_key[reference->cipher_key.len + 1];
11264 uint8_t auth_key[reference->auth_key.len + 1];
11266 /* Verify the capabilities */
11267 struct rte_cryptodev_sym_capability_idx cap_idx;
11268 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11269 cap_idx.algo.auth = reference->auth_algo;
11270 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11273 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11274 cap_idx.algo.cipher = reference->crypto_algo;
11275 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11279 /* Create session */
11280 memcpy(cipher_key, reference->cipher_key.data,
11281 reference->cipher_key.len);
11282 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11284 /* Setup Cipher Parameters */
11285 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11286 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11287 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11288 ut_params->cipher_xform.cipher.key.data = cipher_key;
11289 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11290 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11291 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11293 ut_params->cipher_xform.next = &ut_params->auth_xform;
11295 /* Setup Authentication Parameters */
11296 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11297 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11298 ut_params->auth_xform.auth.algo = reference->auth_algo;
11299 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11300 ut_params->auth_xform.auth.key.data = auth_key;
11301 ut_params->auth_xform.auth.digest_length = reference->digest.len;
11302 ut_params->auth_xform.next = NULL;
11304 /* Create Crypto session*/
11305 ut_params->sess = rte_cryptodev_sym_session_create(
11306 ts_params->session_mpool);
11308 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11310 &ut_params->cipher_xform,
11311 ts_params->session_priv_mpool);
11313 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11315 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11316 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11317 "Failed to allocate input buffer in mempool");
11319 /* clear mbuf payload */
11320 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11321 rte_pktmbuf_tailroom(ut_params->ibuf));
11323 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11324 reference->plaintext.len);
11325 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11326 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11328 /* Create operation */
11329 retval = create_cipher_auth_operation(ts_params,
11336 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11337 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11340 ut_params->op = process_crypto_request(
11341 ts_params->valid_devs[0], ut_params->op);
11343 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
11345 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11346 "crypto op processing failed");
11348 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
11350 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11351 ut_params->op->sym->auth.data.offset);
11352 auth_tag = authciphertext + plaintext_pad_len;
11353 debug_hexdump(stdout, "ciphertext:", authciphertext,
11354 reference->ciphertext.len);
11355 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
11357 /* Validate obuf */
11358 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11360 reference->ciphertext.data,
11361 reference->ciphertext.len,
11362 "Ciphertext data not as expected");
11364 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11366 reference->digest.data,
11367 reference->digest.len,
11368 "Generated digest not as expected");
11370 return TEST_SUCCESS;
11375 test_authenticated_decrypt_with_esn(
11376 struct crypto_testsuite_params *ts_params,
11377 struct crypto_unittest_params *ut_params,
11378 const struct test_crypto_vector *reference)
11382 uint8_t *ciphertext;
11383 uint8_t cipher_key[reference->cipher_key.len + 1];
11384 uint8_t auth_key[reference->auth_key.len + 1];
11386 /* Verify the capabilities */
11387 struct rte_cryptodev_sym_capability_idx cap_idx;
11388 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11389 cap_idx.algo.auth = reference->auth_algo;
11390 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11393 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11394 cap_idx.algo.cipher = reference->crypto_algo;
11395 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11399 /* Create session */
11400 memcpy(cipher_key, reference->cipher_key.data,
11401 reference->cipher_key.len);
11402 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11404 /* Setup Authentication Parameters */
11405 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11406 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
11407 ut_params->auth_xform.auth.algo = reference->auth_algo;
11408 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11409 ut_params->auth_xform.auth.key.data = auth_key;
11410 ut_params->auth_xform.auth.digest_length = reference->digest.len;
11411 ut_params->auth_xform.next = &ut_params->cipher_xform;
11413 /* Setup Cipher Parameters */
11414 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11415 ut_params->cipher_xform.next = NULL;
11416 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11417 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
11418 ut_params->cipher_xform.cipher.key.data = cipher_key;
11419 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11420 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11421 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11423 /* Create Crypto session*/
11424 ut_params->sess = rte_cryptodev_sym_session_create(
11425 ts_params->session_mpool);
11427 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11429 &ut_params->auth_xform,
11430 ts_params->session_priv_mpool);
11432 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11434 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11435 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11436 "Failed to allocate input buffer in mempool");
11438 /* clear mbuf payload */
11439 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11440 rte_pktmbuf_tailroom(ut_params->ibuf));
11442 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11443 reference->ciphertext.len);
11444 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11445 memcpy(ciphertext, reference->ciphertext.data,
11446 reference->ciphertext.len);
11448 /* Create operation */
11449 retval = create_cipher_auth_verify_operation(ts_params,
11456 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11457 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11460 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11463 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11464 TEST_ASSERT_EQUAL(ut_params->op->status,
11465 RTE_CRYPTO_OP_STATUS_SUCCESS,
11466 "crypto op processing passed");
11468 ut_params->obuf = ut_params->op->sym->m_src;
11469 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
11475 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
11476 const struct aead_test_data *tdata,
11477 void *digest_mem, uint64_t digest_phys)
11479 struct crypto_testsuite_params *ts_params = &testsuite_params;
11480 struct crypto_unittest_params *ut_params = &unittest_params;
11482 const unsigned int auth_tag_len = tdata->auth_tag.len;
11483 const unsigned int iv_len = tdata->iv.len;
11484 unsigned int aad_len = tdata->aad.len;
11485 unsigned int aad_len_pad = 0;
11487 /* Generate Crypto op data structure */
11488 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11489 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11490 TEST_ASSERT_NOT_NULL(ut_params->op,
11491 "Failed to allocate symmetric crypto operation struct");
11493 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11495 sym_op->aead.digest.data = digest_mem;
11497 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
11498 "no room to append digest");
11500 sym_op->aead.digest.phys_addr = digest_phys;
11502 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
11503 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
11505 debug_hexdump(stdout, "digest:",
11506 sym_op->aead.digest.data,
11510 /* Append aad data */
11511 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
11512 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11513 uint8_t *, IV_OFFSET);
11515 /* Copy IV 1 byte after the IV pointer, according to the API */
11516 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
11518 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
11520 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11521 ut_params->ibuf, aad_len);
11522 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11523 "no room to prepend aad");
11524 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11527 memset(sym_op->aead.aad.data, 0, aad_len);
11528 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
11529 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11531 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11532 debug_hexdump(stdout, "aad:",
11533 sym_op->aead.aad.data, aad_len);
11535 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11536 uint8_t *, IV_OFFSET);
11538 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
11540 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
11542 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11543 ut_params->ibuf, aad_len_pad);
11544 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11545 "no room to prepend aad");
11546 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11549 memset(sym_op->aead.aad.data, 0, aad_len);
11550 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11552 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11553 debug_hexdump(stdout, "aad:",
11554 sym_op->aead.aad.data, aad_len);
11557 sym_op->aead.data.length = tdata->plaintext.len;
11558 sym_op->aead.data.offset = aad_len_pad;
11563 #define SGL_MAX_NO 16
11566 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
11567 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
11569 struct crypto_testsuite_params *ts_params = &testsuite_params;
11570 struct crypto_unittest_params *ut_params = &unittest_params;
11571 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
11574 int to_trn_tbl[SGL_MAX_NO];
11576 unsigned int trn_data = 0;
11577 uint8_t *plaintext, *ciphertext, *auth_tag;
11578 struct rte_cryptodev_info dev_info;
11580 /* Verify the capabilities */
11581 struct rte_cryptodev_sym_capability_idx cap_idx;
11582 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11583 cap_idx.algo.aead = tdata->algo;
11584 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11588 /* OOP not supported with CPU crypto */
11589 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11592 /* Detailed check for the particular SGL support flag */
11593 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11595 unsigned int sgl_in = fragsz < tdata->plaintext.len;
11596 if (sgl_in && (!(dev_info.feature_flags &
11597 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
11600 unsigned int sgl_in = fragsz < tdata->plaintext.len;
11601 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
11602 tdata->plaintext.len;
11603 if (sgl_in && !sgl_out) {
11604 if (!(dev_info.feature_flags &
11605 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
11607 } else if (!sgl_in && sgl_out) {
11608 if (!(dev_info.feature_flags &
11609 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
11611 } else if (sgl_in && sgl_out) {
11612 if (!(dev_info.feature_flags &
11613 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
11618 if (fragsz > tdata->plaintext.len)
11619 fragsz = tdata->plaintext.len;
11621 uint16_t plaintext_len = fragsz;
11622 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
11624 if (fragsz_oop > tdata->plaintext.len)
11625 frag_size_oop = tdata->plaintext.len;
11628 void *digest_mem = NULL;
11630 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
11632 if (tdata->plaintext.len % fragsz != 0) {
11633 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
11636 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
11641 * For out-op-place we need to alloc another mbuf
11644 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11645 rte_pktmbuf_append(ut_params->obuf,
11646 frag_size_oop + prepend_len);
11647 buf_oop = ut_params->obuf;
11650 /* Create AEAD session */
11651 retval = create_aead_session(ts_params->valid_devs[0],
11653 RTE_CRYPTO_AEAD_OP_ENCRYPT,
11654 tdata->key.data, tdata->key.len,
11655 tdata->aad.len, tdata->auth_tag.len,
11660 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11662 /* clear mbuf payload */
11663 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11664 rte_pktmbuf_tailroom(ut_params->ibuf));
11666 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11669 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11671 trn_data += plaintext_len;
11673 buf = ut_params->ibuf;
11676 * Loop until no more fragments
11679 while (trn_data < tdata->plaintext.len) {
11681 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11682 (tdata->plaintext.len - trn_data) : fragsz;
11684 to_trn_tbl[ecx++] = to_trn;
11686 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11689 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11690 rte_pktmbuf_tailroom(buf));
11693 if (oop && !fragsz_oop) {
11694 buf_last_oop = buf_oop->next =
11695 rte_pktmbuf_alloc(ts_params->mbuf_pool);
11696 buf_oop = buf_oop->next;
11697 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11698 0, rte_pktmbuf_tailroom(buf_oop));
11699 rte_pktmbuf_append(buf_oop, to_trn);
11702 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11705 memcpy(plaintext, tdata->plaintext.data + trn_data,
11707 trn_data += to_trn;
11708 if (trn_data == tdata->plaintext.len) {
11711 digest_mem = rte_pktmbuf_append(buf_oop,
11712 tdata->auth_tag.len);
11714 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11715 tdata->auth_tag.len);
11719 uint64_t digest_phys = 0;
11721 ut_params->ibuf->nb_segs = segs;
11724 if (fragsz_oop && oop) {
11728 if (frag_size_oop == tdata->plaintext.len) {
11729 digest_mem = rte_pktmbuf_append(ut_params->obuf,
11730 tdata->auth_tag.len);
11732 digest_phys = rte_pktmbuf_iova_offset(
11734 tdata->plaintext.len + prepend_len);
11737 trn_data = frag_size_oop;
11738 while (trn_data < tdata->plaintext.len) {
11741 (tdata->plaintext.len - trn_data <
11743 (tdata->plaintext.len - trn_data) :
11746 to_trn_tbl[ecx++] = to_trn;
11748 buf_last_oop = buf_oop->next =
11749 rte_pktmbuf_alloc(ts_params->mbuf_pool);
11750 buf_oop = buf_oop->next;
11751 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11752 0, rte_pktmbuf_tailroom(buf_oop));
11753 rte_pktmbuf_append(buf_oop, to_trn);
11755 trn_data += to_trn;
11757 if (trn_data == tdata->plaintext.len) {
11758 digest_mem = rte_pktmbuf_append(buf_oop,
11759 tdata->auth_tag.len);
11763 ut_params->obuf->nb_segs = segs;
11767 * Place digest at the end of the last buffer
11770 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11771 if (oop && buf_last_oop)
11772 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
11774 if (!digest_mem && !oop) {
11775 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11776 + tdata->auth_tag.len);
11777 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11778 tdata->plaintext.len);
11781 /* Create AEAD operation */
11782 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
11783 tdata, digest_mem, digest_phys);
11788 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11790 ut_params->op->sym->m_src = ut_params->ibuf;
11792 ut_params->op->sym->m_dst = ut_params->obuf;
11794 /* Process crypto operation */
11795 if (oop == IN_PLACE &&
11796 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11797 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
11799 TEST_ASSERT_NOT_NULL(
11800 process_crypto_request(ts_params->valid_devs[0],
11801 ut_params->op), "failed to process sym crypto op");
11803 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11804 "crypto op processing failed");
11807 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
11808 uint8_t *, prepend_len);
11810 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11811 uint8_t *, prepend_len);
11815 fragsz = fragsz_oop;
11817 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11819 tdata->ciphertext.data,
11821 "Ciphertext data not as expected");
11823 buf = ut_params->op->sym->m_src->next;
11825 buf = ut_params->op->sym->m_dst->next;
11827 unsigned int off = fragsz;
11831 ciphertext = rte_pktmbuf_mtod(buf,
11834 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11836 tdata->ciphertext.data + off,
11838 "Ciphertext data not as expected");
11840 off += to_trn_tbl[ecx++];
11844 auth_tag = digest_mem;
11845 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11847 tdata->auth_tag.data,
11848 tdata->auth_tag.len,
11849 "Generated auth tag not as expected");
11855 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
11857 return test_authenticated_encryption_SGL(
11858 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
11862 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
11864 return test_authenticated_encryption_SGL(
11865 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
11869 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
11871 return test_authenticated_encryption_SGL(
11872 &gcm_test_case_8, OUT_OF_PLACE, 400,
11873 gcm_test_case_8.plaintext.len);
11877 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
11879 /* This test is not for OPENSSL PMD */
11880 if (gbl_driver_id == rte_cryptodev_driver_id_get(
11881 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
11884 return test_authenticated_encryption_SGL(
11885 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
11889 test_authentication_verify_fail_when_data_corrupted(
11890 struct crypto_testsuite_params *ts_params,
11891 struct crypto_unittest_params *ut_params,
11892 const struct test_crypto_vector *reference)
11894 return test_authentication_verify_fail_when_data_corruption(
11895 ts_params, ut_params, reference, 1);
11899 test_authentication_verify_fail_when_tag_corrupted(
11900 struct crypto_testsuite_params *ts_params,
11901 struct crypto_unittest_params *ut_params,
11902 const struct test_crypto_vector *reference)
11904 return test_authentication_verify_fail_when_data_corruption(
11905 ts_params, ut_params, reference, 0);
11909 test_authentication_verify_GMAC_fail_when_data_corrupted(
11910 struct crypto_testsuite_params *ts_params,
11911 struct crypto_unittest_params *ut_params,
11912 const struct test_crypto_vector *reference)
11914 return test_authentication_verify_GMAC_fail_when_corruption(
11915 ts_params, ut_params, reference, 1);
11919 test_authentication_verify_GMAC_fail_when_tag_corrupted(
11920 struct crypto_testsuite_params *ts_params,
11921 struct crypto_unittest_params *ut_params,
11922 const struct test_crypto_vector *reference)
11924 return test_authentication_verify_GMAC_fail_when_corruption(
11925 ts_params, ut_params, reference, 0);
11929 test_authenticated_decryption_fail_when_data_corrupted(
11930 struct crypto_testsuite_params *ts_params,
11931 struct crypto_unittest_params *ut_params,
11932 const struct test_crypto_vector *reference)
11934 return test_authenticated_decryption_fail_when_corruption(
11935 ts_params, ut_params, reference, 1);
11939 test_authenticated_decryption_fail_when_tag_corrupted(
11940 struct crypto_testsuite_params *ts_params,
11941 struct crypto_unittest_params *ut_params,
11942 const struct test_crypto_vector *reference)
11944 return test_authenticated_decryption_fail_when_corruption(
11945 ts_params, ut_params, reference, 0);
11949 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
11951 return test_authentication_verify_fail_when_data_corrupted(
11952 &testsuite_params, &unittest_params,
11953 &hmac_sha1_test_crypto_vector);
11957 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
11959 return test_authentication_verify_fail_when_tag_corrupted(
11960 &testsuite_params, &unittest_params,
11961 &hmac_sha1_test_crypto_vector);
11965 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
11967 return test_authentication_verify_GMAC_fail_when_data_corrupted(
11968 &testsuite_params, &unittest_params,
11969 &aes128_gmac_test_vector);
11973 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
11975 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
11976 &testsuite_params, &unittest_params,
11977 &aes128_gmac_test_vector);
11981 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
11983 return test_authenticated_decryption_fail_when_data_corrupted(
11986 &aes128cbc_hmac_sha1_test_vector);
11990 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
11992 return test_authenticated_decryption_fail_when_tag_corrupted(
11995 &aes128cbc_hmac_sha1_test_vector);
11999 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12001 return test_authenticated_encryt_with_esn(
12004 &aes128cbc_hmac_sha1_aad_test_vector);
12008 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12010 return test_authenticated_decrypt_with_esn(
12013 &aes128cbc_hmac_sha1_aad_test_vector);
12016 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
12018 /* global AESNI slave IDs for the scheduler test */
12019 uint8_t aesni_ids[2];
12022 test_scheduler_attach_slave_op(void)
12024 struct crypto_testsuite_params *ts_params = &testsuite_params;
12025 uint8_t sched_id = ts_params->valid_devs[0];
12026 uint32_t nb_devs, i, nb_devs_attached = 0;
12028 char vdev_name[32];
12030 /* create 2 AESNI_MB if necessary */
12031 nb_devs = rte_cryptodev_device_count_by_driver(
12032 rte_cryptodev_driver_id_get(
12033 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
12035 for (i = nb_devs; i < 2; i++) {
12036 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
12037 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
12039 ret = rte_vdev_init(vdev_name, NULL);
12041 TEST_ASSERT(ret == 0,
12042 "Failed to create instance %u of"
12044 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12048 /* attach 2 AESNI_MB cdevs */
12049 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
12051 struct rte_cryptodev_info info;
12052 unsigned int session_size;
12054 rte_cryptodev_info_get(i, &info);
12055 if (info.driver_id != rte_cryptodev_driver_id_get(
12056 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
12059 session_size = rte_cryptodev_sym_get_private_session_size(i);
12061 * Create the session mempool again, since now there are new devices
12062 * to use the mempool.
12064 if (ts_params->session_mpool) {
12065 rte_mempool_free(ts_params->session_mpool);
12066 ts_params->session_mpool = NULL;
12068 if (ts_params->session_priv_mpool) {
12069 rte_mempool_free(ts_params->session_priv_mpool);
12070 ts_params->session_priv_mpool = NULL;
12073 if (info.sym.max_nb_sessions != 0 &&
12074 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
12075 RTE_LOG(ERR, USER1,
12076 "Device does not support "
12077 "at least %u sessions\n",
12079 return TEST_FAILED;
12082 * Create mempool with maximum number of sessions,
12083 * to include the session headers
12085 if (ts_params->session_mpool == NULL) {
12086 ts_params->session_mpool =
12087 rte_cryptodev_sym_session_pool_create(
12089 MAX_NB_SESSIONS, 0, 0, 0,
12091 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
12092 "session mempool allocation failed");
12096 * Create mempool with maximum number of sessions,
12097 * to include device specific session private data
12099 if (ts_params->session_priv_mpool == NULL) {
12100 ts_params->session_priv_mpool = rte_mempool_create(
12101 "test_sess_mp_priv",
12104 0, 0, NULL, NULL, NULL,
12105 NULL, SOCKET_ID_ANY,
12108 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
12109 "session mempool allocation failed");
12112 ts_params->qp_conf.mp_session = ts_params->session_mpool;
12113 ts_params->qp_conf.mp_session_private =
12114 ts_params->session_priv_mpool;
12116 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
12119 TEST_ASSERT(ret == 0,
12120 "Failed to attach device %u of pmd : %s", i,
12121 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12123 aesni_ids[nb_devs_attached] = (uint8_t)i;
12125 nb_devs_attached++;
12132 test_scheduler_detach_slave_op(void)
12134 struct crypto_testsuite_params *ts_params = &testsuite_params;
12135 uint8_t sched_id = ts_params->valid_devs[0];
12139 for (i = 0; i < 2; i++) {
12140 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
12142 TEST_ASSERT(ret == 0,
12143 "Failed to detach device %u", aesni_ids[i]);
12150 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
12152 struct crypto_testsuite_params *ts_params = &testsuite_params;
12153 uint8_t sched_id = ts_params->valid_devs[0];
12155 return rte_cryptodev_scheduler_mode_set(sched_id,
12160 test_scheduler_mode_roundrobin_op(void)
12162 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
12163 0, "Failed to set roundrobin mode");
12169 test_scheduler_mode_multicore_op(void)
12171 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
12172 0, "Failed to set multicore mode");
12178 test_scheduler_mode_failover_op(void)
12180 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
12181 0, "Failed to set failover mode");
12187 test_scheduler_mode_pkt_size_distr_op(void)
12189 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
12190 0, "Failed to set pktsize mode");
12195 static struct unit_test_suite cryptodev_scheduler_testsuite = {
12196 .suite_name = "Crypto Device Scheduler Unit Test Suite",
12197 .setup = testsuite_setup,
12198 .teardown = testsuite_teardown,
12199 .unit_test_cases = {
12201 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12202 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
12203 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12204 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12205 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12206 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12209 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12210 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
12211 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12212 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12213 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12214 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12217 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12218 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
12219 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12220 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12221 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12222 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12225 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12226 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
12227 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12228 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12229 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12230 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12232 TEST_CASES_END() /**< NULL terminate unit test array */
12236 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
12238 static struct unit_test_suite cryptodev_testsuite = {
12239 .suite_name = "Crypto Unit Test Suite",
12240 .setup = testsuite_setup,
12241 .teardown = testsuite_teardown,
12242 .unit_test_cases = {
12243 TEST_CASE_ST(ut_setup, ut_teardown,
12244 test_device_configure_invalid_dev_id),
12245 TEST_CASE_ST(ut_setup, ut_teardown,
12246 test_queue_pair_descriptor_setup),
12247 TEST_CASE_ST(ut_setup, ut_teardown,
12248 test_device_configure_invalid_queue_pair_ids),
12250 TEST_CASE_ST(ut_setup, ut_teardown,
12251 test_multi_session),
12252 TEST_CASE_ST(ut_setup, ut_teardown,
12253 test_multi_session_random_usage),
12255 TEST_CASE_ST(ut_setup, ut_teardown,
12256 test_null_invalid_operation),
12257 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
12259 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12260 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12261 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12262 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12263 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
12264 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
12265 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
12266 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12267 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
12269 /** AES CCM Authenticated Encryption 128 bits key */
12270 TEST_CASE_ST(ut_setup, ut_teardown,
12271 test_AES_CCM_authenticated_encryption_test_case_128_1),
12272 TEST_CASE_ST(ut_setup, ut_teardown,
12273 test_AES_CCM_authenticated_encryption_test_case_128_2),
12274 TEST_CASE_ST(ut_setup, ut_teardown,
12275 test_AES_CCM_authenticated_encryption_test_case_128_3),
12277 /** AES CCM Authenticated Decryption 128 bits key*/
12278 TEST_CASE_ST(ut_setup, ut_teardown,
12279 test_AES_CCM_authenticated_decryption_test_case_128_1),
12280 TEST_CASE_ST(ut_setup, ut_teardown,
12281 test_AES_CCM_authenticated_decryption_test_case_128_2),
12282 TEST_CASE_ST(ut_setup, ut_teardown,
12283 test_AES_CCM_authenticated_decryption_test_case_128_3),
12285 /** AES CCM Authenticated Encryption 192 bits key */
12286 TEST_CASE_ST(ut_setup, ut_teardown,
12287 test_AES_CCM_authenticated_encryption_test_case_192_1),
12288 TEST_CASE_ST(ut_setup, ut_teardown,
12289 test_AES_CCM_authenticated_encryption_test_case_192_2),
12290 TEST_CASE_ST(ut_setup, ut_teardown,
12291 test_AES_CCM_authenticated_encryption_test_case_192_3),
12293 /** AES CCM Authenticated Decryption 192 bits key*/
12294 TEST_CASE_ST(ut_setup, ut_teardown,
12295 test_AES_CCM_authenticated_decryption_test_case_192_1),
12296 TEST_CASE_ST(ut_setup, ut_teardown,
12297 test_AES_CCM_authenticated_decryption_test_case_192_2),
12298 TEST_CASE_ST(ut_setup, ut_teardown,
12299 test_AES_CCM_authenticated_decryption_test_case_192_3),
12301 /** AES CCM Authenticated Encryption 256 bits key */
12302 TEST_CASE_ST(ut_setup, ut_teardown,
12303 test_AES_CCM_authenticated_encryption_test_case_256_1),
12304 TEST_CASE_ST(ut_setup, ut_teardown,
12305 test_AES_CCM_authenticated_encryption_test_case_256_2),
12306 TEST_CASE_ST(ut_setup, ut_teardown,
12307 test_AES_CCM_authenticated_encryption_test_case_256_3),
12309 /** AES CCM Authenticated Decryption 256 bits key*/
12310 TEST_CASE_ST(ut_setup, ut_teardown,
12311 test_AES_CCM_authenticated_decryption_test_case_256_1),
12312 TEST_CASE_ST(ut_setup, ut_teardown,
12313 test_AES_CCM_authenticated_decryption_test_case_256_2),
12314 TEST_CASE_ST(ut_setup, ut_teardown,
12315 test_AES_CCM_authenticated_decryption_test_case_256_3),
12317 /** AES GCM Authenticated Encryption */
12318 TEST_CASE_ST(ut_setup, ut_teardown,
12319 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
12320 TEST_CASE_ST(ut_setup, ut_teardown,
12321 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
12322 TEST_CASE_ST(ut_setup, ut_teardown,
12323 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
12324 TEST_CASE_ST(ut_setup, ut_teardown,
12325 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
12326 TEST_CASE_ST(ut_setup, ut_teardown,
12327 test_AES_GCM_authenticated_encryption_test_case_1),
12328 TEST_CASE_ST(ut_setup, ut_teardown,
12329 test_AES_GCM_authenticated_encryption_test_case_2),
12330 TEST_CASE_ST(ut_setup, ut_teardown,
12331 test_AES_GCM_authenticated_encryption_test_case_3),
12332 TEST_CASE_ST(ut_setup, ut_teardown,
12333 test_AES_GCM_authenticated_encryption_test_case_4),
12334 TEST_CASE_ST(ut_setup, ut_teardown,
12335 test_AES_GCM_authenticated_encryption_test_case_5),
12336 TEST_CASE_ST(ut_setup, ut_teardown,
12337 test_AES_GCM_authenticated_encryption_test_case_6),
12338 TEST_CASE_ST(ut_setup, ut_teardown,
12339 test_AES_GCM_authenticated_encryption_test_case_7),
12340 TEST_CASE_ST(ut_setup, ut_teardown,
12341 test_AES_GCM_authenticated_encryption_test_case_8),
12342 TEST_CASE_ST(ut_setup, ut_teardown,
12343 test_AES_GCM_J0_authenticated_encryption_test_case_1),
12345 /** AES GCM Authenticated Decryption */
12346 TEST_CASE_ST(ut_setup, ut_teardown,
12347 test_AES_GCM_authenticated_decryption_test_case_1),
12348 TEST_CASE_ST(ut_setup, ut_teardown,
12349 test_AES_GCM_authenticated_decryption_test_case_2),
12350 TEST_CASE_ST(ut_setup, ut_teardown,
12351 test_AES_GCM_authenticated_decryption_test_case_3),
12352 TEST_CASE_ST(ut_setup, ut_teardown,
12353 test_AES_GCM_authenticated_decryption_test_case_4),
12354 TEST_CASE_ST(ut_setup, ut_teardown,
12355 test_AES_GCM_authenticated_decryption_test_case_5),
12356 TEST_CASE_ST(ut_setup, ut_teardown,
12357 test_AES_GCM_authenticated_decryption_test_case_6),
12358 TEST_CASE_ST(ut_setup, ut_teardown,
12359 test_AES_GCM_authenticated_decryption_test_case_7),
12360 TEST_CASE_ST(ut_setup, ut_teardown,
12361 test_AES_GCM_authenticated_decryption_test_case_8),
12362 TEST_CASE_ST(ut_setup, ut_teardown,
12363 test_AES_GCM_J0_authenticated_decryption_test_case_1),
12365 /** AES GCM Authenticated Encryption 192 bits key */
12366 TEST_CASE_ST(ut_setup, ut_teardown,
12367 test_AES_GCM_auth_encryption_test_case_192_1),
12368 TEST_CASE_ST(ut_setup, ut_teardown,
12369 test_AES_GCM_auth_encryption_test_case_192_2),
12370 TEST_CASE_ST(ut_setup, ut_teardown,
12371 test_AES_GCM_auth_encryption_test_case_192_3),
12372 TEST_CASE_ST(ut_setup, ut_teardown,
12373 test_AES_GCM_auth_encryption_test_case_192_4),
12374 TEST_CASE_ST(ut_setup, ut_teardown,
12375 test_AES_GCM_auth_encryption_test_case_192_5),
12376 TEST_CASE_ST(ut_setup, ut_teardown,
12377 test_AES_GCM_auth_encryption_test_case_192_6),
12378 TEST_CASE_ST(ut_setup, ut_teardown,
12379 test_AES_GCM_auth_encryption_test_case_192_7),
12381 /** AES GCM Authenticated Decryption 192 bits key */
12382 TEST_CASE_ST(ut_setup, ut_teardown,
12383 test_AES_GCM_auth_decryption_test_case_192_1),
12384 TEST_CASE_ST(ut_setup, ut_teardown,
12385 test_AES_GCM_auth_decryption_test_case_192_2),
12386 TEST_CASE_ST(ut_setup, ut_teardown,
12387 test_AES_GCM_auth_decryption_test_case_192_3),
12388 TEST_CASE_ST(ut_setup, ut_teardown,
12389 test_AES_GCM_auth_decryption_test_case_192_4),
12390 TEST_CASE_ST(ut_setup, ut_teardown,
12391 test_AES_GCM_auth_decryption_test_case_192_5),
12392 TEST_CASE_ST(ut_setup, ut_teardown,
12393 test_AES_GCM_auth_decryption_test_case_192_6),
12394 TEST_CASE_ST(ut_setup, ut_teardown,
12395 test_AES_GCM_auth_decryption_test_case_192_7),
12397 /** AES GCM Authenticated Encryption 256 bits key */
12398 TEST_CASE_ST(ut_setup, ut_teardown,
12399 test_AES_GCM_auth_encryption_test_case_256_1),
12400 TEST_CASE_ST(ut_setup, ut_teardown,
12401 test_AES_GCM_auth_encryption_test_case_256_2),
12402 TEST_CASE_ST(ut_setup, ut_teardown,
12403 test_AES_GCM_auth_encryption_test_case_256_3),
12404 TEST_CASE_ST(ut_setup, ut_teardown,
12405 test_AES_GCM_auth_encryption_test_case_256_4),
12406 TEST_CASE_ST(ut_setup, ut_teardown,
12407 test_AES_GCM_auth_encryption_test_case_256_5),
12408 TEST_CASE_ST(ut_setup, ut_teardown,
12409 test_AES_GCM_auth_encryption_test_case_256_6),
12410 TEST_CASE_ST(ut_setup, ut_teardown,
12411 test_AES_GCM_auth_encryption_test_case_256_7),
12413 /** AES GCM Authenticated Decryption 256 bits key */
12414 TEST_CASE_ST(ut_setup, ut_teardown,
12415 test_AES_GCM_auth_decryption_test_case_256_1),
12416 TEST_CASE_ST(ut_setup, ut_teardown,
12417 test_AES_GCM_auth_decryption_test_case_256_2),
12418 TEST_CASE_ST(ut_setup, ut_teardown,
12419 test_AES_GCM_auth_decryption_test_case_256_3),
12420 TEST_CASE_ST(ut_setup, ut_teardown,
12421 test_AES_GCM_auth_decryption_test_case_256_4),
12422 TEST_CASE_ST(ut_setup, ut_teardown,
12423 test_AES_GCM_auth_decryption_test_case_256_5),
12424 TEST_CASE_ST(ut_setup, ut_teardown,
12425 test_AES_GCM_auth_decryption_test_case_256_6),
12426 TEST_CASE_ST(ut_setup, ut_teardown,
12427 test_AES_GCM_auth_decryption_test_case_256_7),
12429 /** AES GCM Authenticated Encryption big aad size */
12430 TEST_CASE_ST(ut_setup, ut_teardown,
12431 test_AES_GCM_auth_encryption_test_case_aad_1),
12432 TEST_CASE_ST(ut_setup, ut_teardown,
12433 test_AES_GCM_auth_encryption_test_case_aad_2),
12435 /** AES GCM Authenticated Decryption big aad size */
12436 TEST_CASE_ST(ut_setup, ut_teardown,
12437 test_AES_GCM_auth_decryption_test_case_aad_1),
12438 TEST_CASE_ST(ut_setup, ut_teardown,
12439 test_AES_GCM_auth_decryption_test_case_aad_2),
12441 /** Out of place tests */
12442 TEST_CASE_ST(ut_setup, ut_teardown,
12443 test_AES_GCM_authenticated_encryption_oop_test_case_1),
12444 TEST_CASE_ST(ut_setup, ut_teardown,
12445 test_AES_GCM_authenticated_decryption_oop_test_case_1),
12447 /** Session-less tests */
12448 TEST_CASE_ST(ut_setup, ut_teardown,
12449 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
12450 TEST_CASE_ST(ut_setup, ut_teardown,
12451 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
12453 /** AES GMAC Authentication */
12454 TEST_CASE_ST(ut_setup, ut_teardown,
12455 test_AES_GMAC_authentication_test_case_1),
12456 TEST_CASE_ST(ut_setup, ut_teardown,
12457 test_AES_GMAC_authentication_verify_test_case_1),
12458 TEST_CASE_ST(ut_setup, ut_teardown,
12459 test_AES_GMAC_authentication_test_case_2),
12460 TEST_CASE_ST(ut_setup, ut_teardown,
12461 test_AES_GMAC_authentication_verify_test_case_2),
12462 TEST_CASE_ST(ut_setup, ut_teardown,
12463 test_AES_GMAC_authentication_test_case_3),
12464 TEST_CASE_ST(ut_setup, ut_teardown,
12465 test_AES_GMAC_authentication_verify_test_case_3),
12466 TEST_CASE_ST(ut_setup, ut_teardown,
12467 test_AES_GMAC_authentication_test_case_4),
12468 TEST_CASE_ST(ut_setup, ut_teardown,
12469 test_AES_GMAC_authentication_verify_test_case_4),
12471 /** SNOW 3G encrypt only (UEA2) */
12472 TEST_CASE_ST(ut_setup, ut_teardown,
12473 test_snow3g_encryption_test_case_1),
12474 TEST_CASE_ST(ut_setup, ut_teardown,
12475 test_snow3g_encryption_test_case_2),
12476 TEST_CASE_ST(ut_setup, ut_teardown,
12477 test_snow3g_encryption_test_case_3),
12478 TEST_CASE_ST(ut_setup, ut_teardown,
12479 test_snow3g_encryption_test_case_4),
12480 TEST_CASE_ST(ut_setup, ut_teardown,
12481 test_snow3g_encryption_test_case_5),
12483 TEST_CASE_ST(ut_setup, ut_teardown,
12484 test_snow3g_encryption_test_case_1_oop),
12485 TEST_CASE_ST(ut_setup, ut_teardown,
12486 test_snow3g_encryption_test_case_1_oop_sgl),
12487 TEST_CASE_ST(ut_setup, ut_teardown,
12488 test_snow3g_encryption_test_case_1_offset_oop),
12489 TEST_CASE_ST(ut_setup, ut_teardown,
12490 test_snow3g_decryption_test_case_1_oop),
12492 /** SNOW 3G generate auth, then encrypt (UEA2) */
12493 TEST_CASE_ST(ut_setup, ut_teardown,
12494 test_snow3g_auth_cipher_test_case_1),
12495 TEST_CASE_ST(ut_setup, ut_teardown,
12496 test_snow3g_auth_cipher_test_case_2),
12497 TEST_CASE_ST(ut_setup, ut_teardown,
12498 test_snow3g_auth_cipher_test_case_2_oop),
12499 TEST_CASE_ST(ut_setup, ut_teardown,
12500 test_snow3g_auth_cipher_part_digest_enc),
12501 TEST_CASE_ST(ut_setup, ut_teardown,
12502 test_snow3g_auth_cipher_part_digest_enc_oop),
12503 TEST_CASE_ST(ut_setup, ut_teardown,
12504 test_snow3g_auth_cipher_test_case_3_sgl),
12505 TEST_CASE_ST(ut_setup, ut_teardown,
12506 test_snow3g_auth_cipher_test_case_3_oop_sgl),
12507 TEST_CASE_ST(ut_setup, ut_teardown,
12508 test_snow3g_auth_cipher_part_digest_enc_sgl),
12509 TEST_CASE_ST(ut_setup, ut_teardown,
12510 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
12512 /** SNOW 3G decrypt (UEA2), then verify auth */
12513 TEST_CASE_ST(ut_setup, ut_teardown,
12514 test_snow3g_auth_cipher_verify_test_case_1),
12515 TEST_CASE_ST(ut_setup, ut_teardown,
12516 test_snow3g_auth_cipher_verify_test_case_2),
12517 TEST_CASE_ST(ut_setup, ut_teardown,
12518 test_snow3g_auth_cipher_verify_test_case_2_oop),
12519 TEST_CASE_ST(ut_setup, ut_teardown,
12520 test_snow3g_auth_cipher_verify_part_digest_enc),
12521 TEST_CASE_ST(ut_setup, ut_teardown,
12522 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
12523 TEST_CASE_ST(ut_setup, ut_teardown,
12524 test_snow3g_auth_cipher_verify_test_case_3_sgl),
12525 TEST_CASE_ST(ut_setup, ut_teardown,
12526 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
12527 TEST_CASE_ST(ut_setup, ut_teardown,
12528 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
12529 TEST_CASE_ST(ut_setup, ut_teardown,
12530 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
12532 /** SNOW 3G decrypt only (UEA2) */
12533 TEST_CASE_ST(ut_setup, ut_teardown,
12534 test_snow3g_decryption_test_case_1),
12535 TEST_CASE_ST(ut_setup, ut_teardown,
12536 test_snow3g_decryption_test_case_2),
12537 TEST_CASE_ST(ut_setup, ut_teardown,
12538 test_snow3g_decryption_test_case_3),
12539 TEST_CASE_ST(ut_setup, ut_teardown,
12540 test_snow3g_decryption_test_case_4),
12541 TEST_CASE_ST(ut_setup, ut_teardown,
12542 test_snow3g_decryption_test_case_5),
12543 TEST_CASE_ST(ut_setup, ut_teardown,
12544 test_snow3g_decryption_with_digest_test_case_1),
12545 TEST_CASE_ST(ut_setup, ut_teardown,
12546 test_snow3g_hash_generate_test_case_1),
12547 TEST_CASE_ST(ut_setup, ut_teardown,
12548 test_snow3g_hash_generate_test_case_2),
12549 TEST_CASE_ST(ut_setup, ut_teardown,
12550 test_snow3g_hash_generate_test_case_3),
12551 /* Tests with buffers which length is not byte-aligned */
12552 TEST_CASE_ST(ut_setup, ut_teardown,
12553 test_snow3g_hash_generate_test_case_4),
12554 TEST_CASE_ST(ut_setup, ut_teardown,
12555 test_snow3g_hash_generate_test_case_5),
12556 TEST_CASE_ST(ut_setup, ut_teardown,
12557 test_snow3g_hash_generate_test_case_6),
12558 TEST_CASE_ST(ut_setup, ut_teardown,
12559 test_snow3g_hash_verify_test_case_1),
12560 TEST_CASE_ST(ut_setup, ut_teardown,
12561 test_snow3g_hash_verify_test_case_2),
12562 TEST_CASE_ST(ut_setup, ut_teardown,
12563 test_snow3g_hash_verify_test_case_3),
12564 /* Tests with buffers which length is not byte-aligned */
12565 TEST_CASE_ST(ut_setup, ut_teardown,
12566 test_snow3g_hash_verify_test_case_4),
12567 TEST_CASE_ST(ut_setup, ut_teardown,
12568 test_snow3g_hash_verify_test_case_5),
12569 TEST_CASE_ST(ut_setup, ut_teardown,
12570 test_snow3g_hash_verify_test_case_6),
12571 TEST_CASE_ST(ut_setup, ut_teardown,
12572 test_snow3g_cipher_auth_test_case_1),
12573 TEST_CASE_ST(ut_setup, ut_teardown,
12574 test_snow3g_auth_cipher_with_digest_test_case_1),
12576 /** ZUC encrypt only (EEA3) */
12577 TEST_CASE_ST(ut_setup, ut_teardown,
12578 test_zuc_encryption_test_case_1),
12579 TEST_CASE_ST(ut_setup, ut_teardown,
12580 test_zuc_encryption_test_case_2),
12581 TEST_CASE_ST(ut_setup, ut_teardown,
12582 test_zuc_encryption_test_case_3),
12583 TEST_CASE_ST(ut_setup, ut_teardown,
12584 test_zuc_encryption_test_case_4),
12585 TEST_CASE_ST(ut_setup, ut_teardown,
12586 test_zuc_encryption_test_case_5),
12587 TEST_CASE_ST(ut_setup, ut_teardown,
12588 test_zuc_encryption_test_case_6_sgl),
12590 /** ZUC authenticate (EIA3) */
12591 TEST_CASE_ST(ut_setup, ut_teardown,
12592 test_zuc_hash_generate_test_case_1),
12593 TEST_CASE_ST(ut_setup, ut_teardown,
12594 test_zuc_hash_generate_test_case_2),
12595 TEST_CASE_ST(ut_setup, ut_teardown,
12596 test_zuc_hash_generate_test_case_3),
12597 TEST_CASE_ST(ut_setup, ut_teardown,
12598 test_zuc_hash_generate_test_case_4),
12599 TEST_CASE_ST(ut_setup, ut_teardown,
12600 test_zuc_hash_generate_test_case_5),
12601 TEST_CASE_ST(ut_setup, ut_teardown,
12602 test_zuc_hash_generate_test_case_6),
12603 TEST_CASE_ST(ut_setup, ut_teardown,
12604 test_zuc_hash_generate_test_case_7),
12605 TEST_CASE_ST(ut_setup, ut_teardown,
12606 test_zuc_hash_generate_test_case_8),
12608 /** ZUC alg-chain (EEA3/EIA3) */
12609 TEST_CASE_ST(ut_setup, ut_teardown,
12610 test_zuc_cipher_auth_test_case_1),
12611 TEST_CASE_ST(ut_setup, ut_teardown,
12612 test_zuc_cipher_auth_test_case_2),
12614 /** ZUC generate auth, then encrypt (EEA3) */
12615 TEST_CASE_ST(ut_setup, ut_teardown,
12616 test_zuc_auth_cipher_test_case_1),
12617 TEST_CASE_ST(ut_setup, ut_teardown,
12618 test_zuc_auth_cipher_test_case_1_oop),
12619 TEST_CASE_ST(ut_setup, ut_teardown,
12620 test_zuc_auth_cipher_test_case_1_sgl),
12621 TEST_CASE_ST(ut_setup, ut_teardown,
12622 test_zuc_auth_cipher_test_case_1_oop_sgl),
12624 /** ZUC decrypt (EEA3), then verify auth */
12625 TEST_CASE_ST(ut_setup, ut_teardown,
12626 test_zuc_auth_cipher_verify_test_case_1),
12627 TEST_CASE_ST(ut_setup, ut_teardown,
12628 test_zuc_auth_cipher_verify_test_case_1_oop),
12629 TEST_CASE_ST(ut_setup, ut_teardown,
12630 test_zuc_auth_cipher_verify_test_case_1_sgl),
12631 TEST_CASE_ST(ut_setup, ut_teardown,
12632 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
12634 /** HMAC_MD5 Authentication */
12635 TEST_CASE_ST(ut_setup, ut_teardown,
12636 test_MD5_HMAC_generate_case_1),
12637 TEST_CASE_ST(ut_setup, ut_teardown,
12638 test_MD5_HMAC_verify_case_1),
12639 TEST_CASE_ST(ut_setup, ut_teardown,
12640 test_MD5_HMAC_generate_case_2),
12641 TEST_CASE_ST(ut_setup, ut_teardown,
12642 test_MD5_HMAC_verify_case_2),
12644 /** KASUMI hash only (UIA1) */
12645 TEST_CASE_ST(ut_setup, ut_teardown,
12646 test_kasumi_hash_generate_test_case_1),
12647 TEST_CASE_ST(ut_setup, ut_teardown,
12648 test_kasumi_hash_generate_test_case_2),
12649 TEST_CASE_ST(ut_setup, ut_teardown,
12650 test_kasumi_hash_generate_test_case_3),
12651 TEST_CASE_ST(ut_setup, ut_teardown,
12652 test_kasumi_hash_generate_test_case_4),
12653 TEST_CASE_ST(ut_setup, ut_teardown,
12654 test_kasumi_hash_generate_test_case_5),
12655 TEST_CASE_ST(ut_setup, ut_teardown,
12656 test_kasumi_hash_generate_test_case_6),
12658 TEST_CASE_ST(ut_setup, ut_teardown,
12659 test_kasumi_hash_verify_test_case_1),
12660 TEST_CASE_ST(ut_setup, ut_teardown,
12661 test_kasumi_hash_verify_test_case_2),
12662 TEST_CASE_ST(ut_setup, ut_teardown,
12663 test_kasumi_hash_verify_test_case_3),
12664 TEST_CASE_ST(ut_setup, ut_teardown,
12665 test_kasumi_hash_verify_test_case_4),
12666 TEST_CASE_ST(ut_setup, ut_teardown,
12667 test_kasumi_hash_verify_test_case_5),
12669 /** KASUMI encrypt only (UEA1) */
12670 TEST_CASE_ST(ut_setup, ut_teardown,
12671 test_kasumi_encryption_test_case_1),
12672 TEST_CASE_ST(ut_setup, ut_teardown,
12673 test_kasumi_encryption_test_case_1_sgl),
12674 TEST_CASE_ST(ut_setup, ut_teardown,
12675 test_kasumi_encryption_test_case_1_oop),
12676 TEST_CASE_ST(ut_setup, ut_teardown,
12677 test_kasumi_encryption_test_case_1_oop_sgl),
12678 TEST_CASE_ST(ut_setup, ut_teardown,
12679 test_kasumi_encryption_test_case_2),
12680 TEST_CASE_ST(ut_setup, ut_teardown,
12681 test_kasumi_encryption_test_case_3),
12682 TEST_CASE_ST(ut_setup, ut_teardown,
12683 test_kasumi_encryption_test_case_4),
12684 TEST_CASE_ST(ut_setup, ut_teardown,
12685 test_kasumi_encryption_test_case_5),
12687 /** KASUMI decrypt only (UEA1) */
12688 TEST_CASE_ST(ut_setup, ut_teardown,
12689 test_kasumi_decryption_test_case_1),
12690 TEST_CASE_ST(ut_setup, ut_teardown,
12691 test_kasumi_decryption_test_case_2),
12692 TEST_CASE_ST(ut_setup, ut_teardown,
12693 test_kasumi_decryption_test_case_3),
12694 TEST_CASE_ST(ut_setup, ut_teardown,
12695 test_kasumi_decryption_test_case_4),
12696 TEST_CASE_ST(ut_setup, ut_teardown,
12697 test_kasumi_decryption_test_case_5),
12698 TEST_CASE_ST(ut_setup, ut_teardown,
12699 test_kasumi_decryption_test_case_1_oop),
12701 TEST_CASE_ST(ut_setup, ut_teardown,
12702 test_kasumi_cipher_auth_test_case_1),
12704 /** KASUMI generate auth, then encrypt (F8) */
12705 TEST_CASE_ST(ut_setup, ut_teardown,
12706 test_kasumi_auth_cipher_test_case_1),
12707 TEST_CASE_ST(ut_setup, ut_teardown,
12708 test_kasumi_auth_cipher_test_case_2),
12709 TEST_CASE_ST(ut_setup, ut_teardown,
12710 test_kasumi_auth_cipher_test_case_2_oop),
12711 TEST_CASE_ST(ut_setup, ut_teardown,
12712 test_kasumi_auth_cipher_test_case_2_sgl),
12713 TEST_CASE_ST(ut_setup, ut_teardown,
12714 test_kasumi_auth_cipher_test_case_2_oop_sgl),
12716 /** KASUMI decrypt (F8), then verify auth */
12717 TEST_CASE_ST(ut_setup, ut_teardown,
12718 test_kasumi_auth_cipher_verify_test_case_1),
12719 TEST_CASE_ST(ut_setup, ut_teardown,
12720 test_kasumi_auth_cipher_verify_test_case_2),
12721 TEST_CASE_ST(ut_setup, ut_teardown,
12722 test_kasumi_auth_cipher_verify_test_case_2_oop),
12723 TEST_CASE_ST(ut_setup, ut_teardown,
12724 test_kasumi_auth_cipher_verify_test_case_2_sgl),
12725 TEST_CASE_ST(ut_setup, ut_teardown,
12726 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
12728 /** ESN Testcase */
12729 TEST_CASE_ST(ut_setup, ut_teardown,
12730 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
12731 TEST_CASE_ST(ut_setup, ut_teardown,
12732 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
12734 /** Negative tests */
12735 TEST_CASE_ST(ut_setup, ut_teardown,
12736 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12737 TEST_CASE_ST(ut_setup, ut_teardown,
12738 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12739 TEST_CASE_ST(ut_setup, ut_teardown,
12740 test_AES_GCM_auth_encryption_fail_iv_corrupt),
12741 TEST_CASE_ST(ut_setup, ut_teardown,
12742 test_AES_GCM_auth_encryption_fail_in_data_corrupt),
12743 TEST_CASE_ST(ut_setup, ut_teardown,
12744 test_AES_GCM_auth_encryption_fail_out_data_corrupt),
12745 TEST_CASE_ST(ut_setup, ut_teardown,
12746 test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
12747 TEST_CASE_ST(ut_setup, ut_teardown,
12748 test_AES_GCM_auth_encryption_fail_aad_corrupt),
12749 TEST_CASE_ST(ut_setup, ut_teardown,
12750 test_AES_GCM_auth_encryption_fail_tag_corrupt),
12751 TEST_CASE_ST(ut_setup, ut_teardown,
12752 test_AES_GCM_auth_decryption_fail_iv_corrupt),
12753 TEST_CASE_ST(ut_setup, ut_teardown,
12754 test_AES_GCM_auth_decryption_fail_in_data_corrupt),
12755 TEST_CASE_ST(ut_setup, ut_teardown,
12756 test_AES_GCM_auth_decryption_fail_out_data_corrupt),
12757 TEST_CASE_ST(ut_setup, ut_teardown,
12758 test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
12759 TEST_CASE_ST(ut_setup, ut_teardown,
12760 test_AES_GCM_auth_decryption_fail_aad_corrupt),
12761 TEST_CASE_ST(ut_setup, ut_teardown,
12762 test_AES_GCM_auth_decryption_fail_tag_corrupt),
12763 TEST_CASE_ST(ut_setup, ut_teardown,
12764 authentication_verify_AES128_GMAC_fail_data_corrupt),
12765 TEST_CASE_ST(ut_setup, ut_teardown,
12766 authentication_verify_AES128_GMAC_fail_tag_corrupt),
12767 TEST_CASE_ST(ut_setup, ut_teardown,
12768 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12769 TEST_CASE_ST(ut_setup, ut_teardown,
12770 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12772 /** Mixed CIPHER + HASH algorithms */
12773 /** AUTH AES CMAC + CIPHER AES CTR */
12774 TEST_CASE_ST(ut_setup, ut_teardown,
12775 test_aes_cmac_aes_ctr_digest_enc_test_case_1),
12776 TEST_CASE_ST(ut_setup, ut_teardown,
12777 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12778 TEST_CASE_ST(ut_setup, ut_teardown,
12779 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12780 TEST_CASE_ST(ut_setup, ut_teardown,
12781 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12782 TEST_CASE_ST(ut_setup, ut_teardown,
12783 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
12784 TEST_CASE_ST(ut_setup, ut_teardown,
12785 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12786 TEST_CASE_ST(ut_setup, ut_teardown,
12787 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12788 TEST_CASE_ST(ut_setup, ut_teardown,
12789 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12791 /** AUTH ZUC + CIPHER SNOW3G */
12792 TEST_CASE_ST(ut_setup, ut_teardown,
12793 test_auth_zuc_cipher_snow_test_case_1),
12794 TEST_CASE_ST(ut_setup, ut_teardown,
12795 test_verify_auth_zuc_cipher_snow_test_case_1),
12796 /** AUTH AES CMAC + CIPHER SNOW3G */
12797 TEST_CASE_ST(ut_setup, ut_teardown,
12798 test_auth_aes_cmac_cipher_snow_test_case_1),
12799 TEST_CASE_ST(ut_setup, ut_teardown,
12800 test_verify_auth_aes_cmac_cipher_snow_test_case_1),
12801 /** AUTH ZUC + CIPHER AES CTR */
12802 TEST_CASE_ST(ut_setup, ut_teardown,
12803 test_auth_zuc_cipher_aes_ctr_test_case_1),
12804 TEST_CASE_ST(ut_setup, ut_teardown,
12805 test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
12806 /** AUTH SNOW3G + CIPHER AES CTR */
12807 TEST_CASE_ST(ut_setup, ut_teardown,
12808 test_auth_snow_cipher_aes_ctr_test_case_1),
12809 TEST_CASE_ST(ut_setup, ut_teardown,
12810 test_verify_auth_snow_cipher_aes_ctr_test_case_1),
12811 /** AUTH SNOW3G + CIPHER ZUC */
12812 TEST_CASE_ST(ut_setup, ut_teardown,
12813 test_auth_snow_cipher_zuc_test_case_1),
12814 TEST_CASE_ST(ut_setup, ut_teardown,
12815 test_verify_auth_snow_cipher_zuc_test_case_1),
12816 /** AUTH AES CMAC + CIPHER ZUC */
12817 TEST_CASE_ST(ut_setup, ut_teardown,
12818 test_auth_aes_cmac_cipher_zuc_test_case_1),
12819 TEST_CASE_ST(ut_setup, ut_teardown,
12820 test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
12822 /** AUTH NULL + CIPHER SNOW3G */
12823 TEST_CASE_ST(ut_setup, ut_teardown,
12824 test_auth_null_cipher_snow_test_case_1),
12825 TEST_CASE_ST(ut_setup, ut_teardown,
12826 test_verify_auth_null_cipher_snow_test_case_1),
12827 /** AUTH NULL + CIPHER ZUC */
12828 TEST_CASE_ST(ut_setup, ut_teardown,
12829 test_auth_null_cipher_zuc_test_case_1),
12830 TEST_CASE_ST(ut_setup, ut_teardown,
12831 test_verify_auth_null_cipher_zuc_test_case_1),
12832 /** AUTH SNOW3G + CIPHER NULL */
12833 TEST_CASE_ST(ut_setup, ut_teardown,
12834 test_auth_snow_cipher_null_test_case_1),
12835 TEST_CASE_ST(ut_setup, ut_teardown,
12836 test_verify_auth_snow_cipher_null_test_case_1),
12837 /** AUTH ZUC + CIPHER NULL */
12838 TEST_CASE_ST(ut_setup, ut_teardown,
12839 test_auth_zuc_cipher_null_test_case_1),
12840 TEST_CASE_ST(ut_setup, ut_teardown,
12841 test_verify_auth_zuc_cipher_null_test_case_1),
12842 /** AUTH NULL + CIPHER AES CTR */
12843 TEST_CASE_ST(ut_setup, ut_teardown,
12844 test_auth_null_cipher_aes_ctr_test_case_1),
12845 TEST_CASE_ST(ut_setup, ut_teardown,
12846 test_verify_auth_null_cipher_aes_ctr_test_case_1),
12847 /** AUTH AES CMAC + CIPHER NULL */
12848 TEST_CASE_ST(ut_setup, ut_teardown,
12849 test_auth_aes_cmac_cipher_null_test_case_1),
12850 TEST_CASE_ST(ut_setup, ut_teardown,
12851 test_verify_auth_aes_cmac_cipher_null_test_case_1),
12853 #ifdef RTE_LIBRTE_SECURITY
12854 TEST_CASE_ST(ut_setup, ut_teardown,
12855 test_PDCP_PROTO_all),
12856 TEST_CASE_ST(ut_setup, ut_teardown,
12857 test_DOCSIS_PROTO_all),
12859 TEST_CASES_END() /**< NULL terminate unit test array */
12863 static struct unit_test_suite cryptodev_virtio_testsuite = {
12864 .suite_name = "Crypto VIRTIO Unit Test Suite",
12865 .setup = testsuite_setup,
12866 .teardown = testsuite_teardown,
12867 .unit_test_cases = {
12868 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12870 TEST_CASES_END() /**< NULL terminate unit test array */
12874 static struct unit_test_suite cryptodev_caam_jr_testsuite = {
12875 .suite_name = "Crypto CAAM JR Unit Test Suite",
12876 .setup = testsuite_setup,
12877 .teardown = testsuite_teardown,
12878 .unit_test_cases = {
12879 TEST_CASE_ST(ut_setup, ut_teardown,
12880 test_device_configure_invalid_dev_id),
12881 TEST_CASE_ST(ut_setup, ut_teardown,
12882 test_multi_session),
12884 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12885 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12886 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12887 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12888 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12890 TEST_CASES_END() /**< NULL terminate unit test array */
12894 static struct unit_test_suite cryptodev_armv8_testsuite = {
12895 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
12896 .setup = testsuite_setup,
12897 .teardown = testsuite_teardown,
12898 .unit_test_cases = {
12899 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12901 /** Negative tests */
12902 TEST_CASE_ST(ut_setup, ut_teardown,
12903 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12904 TEST_CASE_ST(ut_setup, ut_teardown,
12905 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12907 TEST_CASES_END() /**< NULL terminate unit test array */
12911 static struct unit_test_suite cryptodev_mrvl_testsuite = {
12912 .suite_name = "Crypto Device Marvell Component Test Suite",
12913 .setup = testsuite_setup,
12914 .teardown = testsuite_teardown,
12915 .unit_test_cases = {
12916 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
12917 TEST_CASE_ST(ut_setup, ut_teardown,
12918 test_multi_session_random_usage),
12919 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12920 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12921 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12922 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12923 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12925 /** Negative tests */
12926 TEST_CASE_ST(ut_setup, ut_teardown,
12927 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12928 TEST_CASE_ST(ut_setup, ut_teardown,
12929 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12930 TEST_CASE_ST(ut_setup, ut_teardown,
12931 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12932 TEST_CASE_ST(ut_setup, ut_teardown,
12933 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12935 TEST_CASES_END() /**< NULL terminate unit test array */
12939 static struct unit_test_suite cryptodev_ccp_testsuite = {
12940 .suite_name = "Crypto Device CCP Unit Test Suite",
12941 .setup = testsuite_setup,
12942 .teardown = testsuite_teardown,
12943 .unit_test_cases = {
12944 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
12945 TEST_CASE_ST(ut_setup, ut_teardown,
12946 test_multi_session_random_usage),
12947 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12948 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12949 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12950 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12951 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12953 /** Negative tests */
12954 TEST_CASE_ST(ut_setup, ut_teardown,
12955 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12956 TEST_CASE_ST(ut_setup, ut_teardown,
12957 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12958 TEST_CASE_ST(ut_setup, ut_teardown,
12959 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12960 TEST_CASE_ST(ut_setup, ut_teardown,
12961 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12963 TEST_CASES_END() /**< NULL terminate unit test array */
12967 static struct unit_test_suite cryptodev_octeontx_testsuite = {
12968 .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
12969 .setup = testsuite_setup,
12970 .teardown = testsuite_teardown,
12971 .unit_test_cases = {
12972 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12973 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12974 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12975 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12976 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12978 /** AES GCM Authenticated Encryption */
12979 TEST_CASE_ST(ut_setup, ut_teardown,
12980 test_AES_GCM_authenticated_encryption_test_case_1),
12981 TEST_CASE_ST(ut_setup, ut_teardown,
12982 test_AES_GCM_authenticated_encryption_test_case_2),
12983 TEST_CASE_ST(ut_setup, ut_teardown,
12984 test_AES_GCM_authenticated_encryption_test_case_3),
12985 TEST_CASE_ST(ut_setup, ut_teardown,
12986 test_AES_GCM_authenticated_encryption_test_case_4),
12987 TEST_CASE_ST(ut_setup, ut_teardown,
12988 test_AES_GCM_authenticated_encryption_test_case_5),
12989 TEST_CASE_ST(ut_setup, ut_teardown,
12990 test_AES_GCM_authenticated_encryption_test_case_6),
12991 TEST_CASE_ST(ut_setup, ut_teardown,
12992 test_AES_GCM_authenticated_encryption_test_case_7),
12994 /** AES GCM Authenticated Decryption */
12995 TEST_CASE_ST(ut_setup, ut_teardown,
12996 test_AES_GCM_authenticated_decryption_test_case_1),
12997 TEST_CASE_ST(ut_setup, ut_teardown,
12998 test_AES_GCM_authenticated_decryption_test_case_2),
12999 TEST_CASE_ST(ut_setup, ut_teardown,
13000 test_AES_GCM_authenticated_decryption_test_case_3),
13001 TEST_CASE_ST(ut_setup, ut_teardown,
13002 test_AES_GCM_authenticated_decryption_test_case_4),
13003 TEST_CASE_ST(ut_setup, ut_teardown,
13004 test_AES_GCM_authenticated_decryption_test_case_5),
13005 TEST_CASE_ST(ut_setup, ut_teardown,
13006 test_AES_GCM_authenticated_decryption_test_case_6),
13007 TEST_CASE_ST(ut_setup, ut_teardown,
13008 test_AES_GCM_authenticated_decryption_test_case_7),
13009 /** AES GMAC Authentication */
13010 TEST_CASE_ST(ut_setup, ut_teardown,
13011 test_AES_GMAC_authentication_test_case_1),
13012 TEST_CASE_ST(ut_setup, ut_teardown,
13013 test_AES_GMAC_authentication_verify_test_case_1),
13014 TEST_CASE_ST(ut_setup, ut_teardown,
13015 test_AES_GMAC_authentication_test_case_2),
13016 TEST_CASE_ST(ut_setup, ut_teardown,
13017 test_AES_GMAC_authentication_verify_test_case_2),
13018 TEST_CASE_ST(ut_setup, ut_teardown,
13019 test_AES_GMAC_authentication_test_case_3),
13020 TEST_CASE_ST(ut_setup, ut_teardown,
13021 test_AES_GMAC_authentication_verify_test_case_3),
13023 /** SNOW 3G encrypt only (UEA2) */
13024 TEST_CASE_ST(ut_setup, ut_teardown,
13025 test_snow3g_encryption_test_case_1),
13026 TEST_CASE_ST(ut_setup, ut_teardown,
13027 test_snow3g_encryption_test_case_2),
13028 TEST_CASE_ST(ut_setup, ut_teardown,
13029 test_snow3g_encryption_test_case_3),
13030 TEST_CASE_ST(ut_setup, ut_teardown,
13031 test_snow3g_encryption_test_case_4),
13032 TEST_CASE_ST(ut_setup, ut_teardown,
13033 test_snow3g_encryption_test_case_5),
13035 TEST_CASE_ST(ut_setup, ut_teardown,
13036 test_snow3g_encryption_test_case_1_oop),
13037 TEST_CASE_ST(ut_setup, ut_teardown,
13038 test_snow3g_decryption_test_case_1_oop),
13039 TEST_CASE_ST(ut_setup, ut_teardown,
13040 test_snow3g_encryption_test_case_1_oop_sgl),
13042 /** SNOW 3G decrypt only (UEA2) */
13043 TEST_CASE_ST(ut_setup, ut_teardown,
13044 test_snow3g_decryption_test_case_1),
13045 TEST_CASE_ST(ut_setup, ut_teardown,
13046 test_snow3g_decryption_test_case_2),
13047 TEST_CASE_ST(ut_setup, ut_teardown,
13048 test_snow3g_decryption_test_case_3),
13049 TEST_CASE_ST(ut_setup, ut_teardown,
13050 test_snow3g_decryption_test_case_4),
13051 TEST_CASE_ST(ut_setup, ut_teardown,
13052 test_snow3g_decryption_test_case_5),
13054 TEST_CASE_ST(ut_setup, ut_teardown,
13055 test_snow3g_hash_generate_test_case_1),
13056 TEST_CASE_ST(ut_setup, ut_teardown,
13057 test_snow3g_hash_generate_test_case_2),
13058 TEST_CASE_ST(ut_setup, ut_teardown,
13059 test_snow3g_hash_generate_test_case_3),
13060 TEST_CASE_ST(ut_setup, ut_teardown,
13061 test_snow3g_hash_verify_test_case_1),
13062 TEST_CASE_ST(ut_setup, ut_teardown,
13063 test_snow3g_hash_verify_test_case_2),
13064 TEST_CASE_ST(ut_setup, ut_teardown,
13065 test_snow3g_hash_verify_test_case_3),
13067 /** ZUC encrypt only (EEA3) */
13068 TEST_CASE_ST(ut_setup, ut_teardown,
13069 test_zuc_encryption_test_case_1),
13070 TEST_CASE_ST(ut_setup, ut_teardown,
13071 test_zuc_encryption_test_case_2),
13072 TEST_CASE_ST(ut_setup, ut_teardown,
13073 test_zuc_encryption_test_case_3),
13074 TEST_CASE_ST(ut_setup, ut_teardown,
13075 test_zuc_encryption_test_case_4),
13076 TEST_CASE_ST(ut_setup, ut_teardown,
13077 test_zuc_encryption_test_case_5),
13078 TEST_CASE_ST(ut_setup, ut_teardown,
13079 test_zuc_hash_generate_test_case_1),
13080 TEST_CASE_ST(ut_setup, ut_teardown,
13081 test_zuc_hash_generate_test_case_2),
13082 TEST_CASE_ST(ut_setup, ut_teardown,
13083 test_zuc_hash_generate_test_case_3),
13084 TEST_CASE_ST(ut_setup, ut_teardown,
13085 test_zuc_hash_generate_test_case_4),
13086 TEST_CASE_ST(ut_setup, ut_teardown,
13087 test_zuc_hash_generate_test_case_5),
13088 TEST_CASE_ST(ut_setup, ut_teardown,
13089 test_zuc_encryption_test_case_6_sgl),
13091 /** KASUMI encrypt only (UEA1) */
13092 TEST_CASE_ST(ut_setup, ut_teardown,
13093 test_kasumi_encryption_test_case_1),
13094 TEST_CASE_ST(ut_setup, ut_teardown,
13095 test_kasumi_encryption_test_case_2),
13096 TEST_CASE_ST(ut_setup, ut_teardown,
13097 test_kasumi_encryption_test_case_3),
13098 TEST_CASE_ST(ut_setup, ut_teardown,
13099 test_kasumi_encryption_test_case_4),
13100 TEST_CASE_ST(ut_setup, ut_teardown,
13101 test_kasumi_encryption_test_case_5),
13102 TEST_CASE_ST(ut_setup, ut_teardown,
13103 test_kasumi_encryption_test_case_1_sgl),
13104 TEST_CASE_ST(ut_setup, ut_teardown,
13105 test_kasumi_encryption_test_case_1_oop_sgl),
13106 /** KASUMI decrypt only (UEA1) */
13107 TEST_CASE_ST(ut_setup, ut_teardown,
13108 test_kasumi_decryption_test_case_1),
13109 TEST_CASE_ST(ut_setup, ut_teardown,
13110 test_kasumi_decryption_test_case_2),
13111 TEST_CASE_ST(ut_setup, ut_teardown,
13112 test_kasumi_decryption_test_case_3),
13113 TEST_CASE_ST(ut_setup, ut_teardown,
13114 test_kasumi_decryption_test_case_4),
13115 TEST_CASE_ST(ut_setup, ut_teardown,
13116 test_kasumi_decryption_test_case_5),
13118 TEST_CASE_ST(ut_setup, ut_teardown,
13119 test_kasumi_encryption_test_case_1_oop),
13120 TEST_CASE_ST(ut_setup, ut_teardown,
13121 test_kasumi_decryption_test_case_1_oop),
13123 /** KASUMI hash only (UIA1) */
13124 TEST_CASE_ST(ut_setup, ut_teardown,
13125 test_kasumi_hash_generate_test_case_1),
13126 TEST_CASE_ST(ut_setup, ut_teardown,
13127 test_kasumi_hash_generate_test_case_2),
13128 TEST_CASE_ST(ut_setup, ut_teardown,
13129 test_kasumi_hash_generate_test_case_3),
13130 TEST_CASE_ST(ut_setup, ut_teardown,
13131 test_kasumi_hash_generate_test_case_4),
13132 TEST_CASE_ST(ut_setup, ut_teardown,
13133 test_kasumi_hash_generate_test_case_5),
13134 TEST_CASE_ST(ut_setup, ut_teardown,
13135 test_kasumi_hash_generate_test_case_6),
13136 TEST_CASE_ST(ut_setup, ut_teardown,
13137 test_kasumi_hash_verify_test_case_1),
13138 TEST_CASE_ST(ut_setup, ut_teardown,
13139 test_kasumi_hash_verify_test_case_2),
13140 TEST_CASE_ST(ut_setup, ut_teardown,
13141 test_kasumi_hash_verify_test_case_3),
13142 TEST_CASE_ST(ut_setup, ut_teardown,
13143 test_kasumi_hash_verify_test_case_4),
13144 TEST_CASE_ST(ut_setup, ut_teardown,
13145 test_kasumi_hash_verify_test_case_5),
13148 TEST_CASE_ST(ut_setup, ut_teardown,
13149 test_null_cipher_only_operation),
13150 TEST_CASE_ST(ut_setup, ut_teardown,
13151 test_null_auth_only_operation),
13152 TEST_CASE_ST(ut_setup, ut_teardown,
13153 test_null_cipher_auth_operation),
13154 TEST_CASE_ST(ut_setup, ut_teardown,
13155 test_null_auth_cipher_operation),
13157 /** Negative tests */
13158 TEST_CASE_ST(ut_setup, ut_teardown,
13159 authentication_verify_HMAC_SHA1_fail_data_corrupt),
13160 TEST_CASE_ST(ut_setup, ut_teardown,
13161 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13162 TEST_CASE_ST(ut_setup, ut_teardown,
13163 authentication_verify_AES128_GMAC_fail_data_corrupt),
13164 TEST_CASE_ST(ut_setup, ut_teardown,
13165 authentication_verify_AES128_GMAC_fail_tag_corrupt),
13166 TEST_CASE_ST(ut_setup, ut_teardown,
13167 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13168 TEST_CASE_ST(ut_setup, ut_teardown,
13169 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13170 TEST_CASES_END() /**< NULL terminate unit test array */
13174 static struct unit_test_suite cryptodev_nitrox_testsuite = {
13175 .suite_name = "Crypto NITROX Unit Test Suite",
13176 .setup = testsuite_setup,
13177 .teardown = testsuite_teardown,
13178 .unit_test_cases = {
13179 TEST_CASE_ST(ut_setup, ut_teardown,
13180 test_device_configure_invalid_dev_id),
13181 TEST_CASE_ST(ut_setup, ut_teardown,
13182 test_device_configure_invalid_queue_pair_ids),
13183 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13184 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13186 TEST_CASES_END() /**< NULL terminate unit test array */
13190 static struct unit_test_suite cryptodev_octeontx2_testsuite = {
13191 .suite_name = "Crypto Device OCTEON TX2 Unit Test Suite",
13192 .setup = testsuite_setup,
13193 .teardown = testsuite_teardown,
13194 .unit_test_cases = {
13195 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13196 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13197 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13198 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13199 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13201 /** AES GCM Authenticated Encryption */
13202 TEST_CASE_ST(ut_setup, ut_teardown,
13203 test_AES_GCM_authenticated_encryption_test_case_1),
13204 TEST_CASE_ST(ut_setup, ut_teardown,
13205 test_AES_GCM_authenticated_encryption_test_case_2),
13206 TEST_CASE_ST(ut_setup, ut_teardown,
13207 test_AES_GCM_authenticated_encryption_test_case_3),
13208 TEST_CASE_ST(ut_setup, ut_teardown,
13209 test_AES_GCM_authenticated_encryption_test_case_4),
13210 TEST_CASE_ST(ut_setup, ut_teardown,
13211 test_AES_GCM_authenticated_encryption_test_case_5),
13212 TEST_CASE_ST(ut_setup, ut_teardown,
13213 test_AES_GCM_authenticated_encryption_test_case_6),
13214 TEST_CASE_ST(ut_setup, ut_teardown,
13215 test_AES_GCM_authenticated_encryption_test_case_7),
13217 /** AES GCM Authenticated Decryption */
13218 TEST_CASE_ST(ut_setup, ut_teardown,
13219 test_AES_GCM_authenticated_decryption_test_case_1),
13220 TEST_CASE_ST(ut_setup, ut_teardown,
13221 test_AES_GCM_authenticated_decryption_test_case_2),
13222 TEST_CASE_ST(ut_setup, ut_teardown,
13223 test_AES_GCM_authenticated_decryption_test_case_3),
13224 TEST_CASE_ST(ut_setup, ut_teardown,
13225 test_AES_GCM_authenticated_decryption_test_case_4),
13226 TEST_CASE_ST(ut_setup, ut_teardown,
13227 test_AES_GCM_authenticated_decryption_test_case_5),
13228 TEST_CASE_ST(ut_setup, ut_teardown,
13229 test_AES_GCM_authenticated_decryption_test_case_6),
13230 TEST_CASE_ST(ut_setup, ut_teardown,
13231 test_AES_GCM_authenticated_decryption_test_case_7),
13232 /** AES GMAC Authentication */
13233 TEST_CASE_ST(ut_setup, ut_teardown,
13234 test_AES_GMAC_authentication_test_case_1),
13235 TEST_CASE_ST(ut_setup, ut_teardown,
13236 test_AES_GMAC_authentication_verify_test_case_1),
13237 TEST_CASE_ST(ut_setup, ut_teardown,
13238 test_AES_GMAC_authentication_test_case_2),
13239 TEST_CASE_ST(ut_setup, ut_teardown,
13240 test_AES_GMAC_authentication_verify_test_case_2),
13241 TEST_CASE_ST(ut_setup, ut_teardown,
13242 test_AES_GMAC_authentication_test_case_3),
13243 TEST_CASE_ST(ut_setup, ut_teardown,
13244 test_AES_GMAC_authentication_verify_test_case_3),
13246 /** SNOW 3G encrypt only (UEA2) */
13247 TEST_CASE_ST(ut_setup, ut_teardown,
13248 test_snow3g_encryption_test_case_1),
13249 TEST_CASE_ST(ut_setup, ut_teardown,
13250 test_snow3g_encryption_test_case_2),
13251 TEST_CASE_ST(ut_setup, ut_teardown,
13252 test_snow3g_encryption_test_case_3),
13253 TEST_CASE_ST(ut_setup, ut_teardown,
13254 test_snow3g_encryption_test_case_4),
13255 TEST_CASE_ST(ut_setup, ut_teardown,
13256 test_snow3g_encryption_test_case_5),
13258 TEST_CASE_ST(ut_setup, ut_teardown,
13259 test_snow3g_encryption_test_case_1_oop),
13260 TEST_CASE_ST(ut_setup, ut_teardown,
13261 test_snow3g_decryption_test_case_1_oop),
13262 TEST_CASE_ST(ut_setup, ut_teardown,
13263 test_snow3g_encryption_test_case_1_oop_sgl),
13265 /** SNOW 3G decrypt only (UEA2) */
13266 TEST_CASE_ST(ut_setup, ut_teardown,
13267 test_snow3g_decryption_test_case_1),
13268 TEST_CASE_ST(ut_setup, ut_teardown,
13269 test_snow3g_decryption_test_case_2),
13270 TEST_CASE_ST(ut_setup, ut_teardown,
13271 test_snow3g_decryption_test_case_3),
13272 TEST_CASE_ST(ut_setup, ut_teardown,
13273 test_snow3g_decryption_test_case_4),
13274 TEST_CASE_ST(ut_setup, ut_teardown,
13275 test_snow3g_decryption_test_case_5),
13277 TEST_CASE_ST(ut_setup, ut_teardown,
13278 test_snow3g_hash_generate_test_case_1),
13279 TEST_CASE_ST(ut_setup, ut_teardown,
13280 test_snow3g_hash_generate_test_case_2),
13281 TEST_CASE_ST(ut_setup, ut_teardown,
13282 test_snow3g_hash_generate_test_case_3),
13283 TEST_CASE_ST(ut_setup, ut_teardown,
13284 test_snow3g_hash_verify_test_case_1),
13285 TEST_CASE_ST(ut_setup, ut_teardown,
13286 test_snow3g_hash_verify_test_case_2),
13287 TEST_CASE_ST(ut_setup, ut_teardown,
13288 test_snow3g_hash_verify_test_case_3),
13290 /** ZUC encrypt only (EEA3) */
13291 TEST_CASE_ST(ut_setup, ut_teardown,
13292 test_zuc_encryption_test_case_1),
13293 TEST_CASE_ST(ut_setup, ut_teardown,
13294 test_zuc_encryption_test_case_2),
13295 TEST_CASE_ST(ut_setup, ut_teardown,
13296 test_zuc_encryption_test_case_3),
13297 TEST_CASE_ST(ut_setup, ut_teardown,
13298 test_zuc_encryption_test_case_4),
13299 TEST_CASE_ST(ut_setup, ut_teardown,
13300 test_zuc_encryption_test_case_5),
13301 TEST_CASE_ST(ut_setup, ut_teardown,
13302 test_zuc_hash_generate_test_case_1),
13303 TEST_CASE_ST(ut_setup, ut_teardown,
13304 test_zuc_hash_generate_test_case_2),
13305 TEST_CASE_ST(ut_setup, ut_teardown,
13306 test_zuc_hash_generate_test_case_3),
13307 TEST_CASE_ST(ut_setup, ut_teardown,
13308 test_zuc_hash_generate_test_case_4),
13309 TEST_CASE_ST(ut_setup, ut_teardown,
13310 test_zuc_hash_generate_test_case_5),
13311 TEST_CASE_ST(ut_setup, ut_teardown,
13312 test_zuc_encryption_test_case_6_sgl),
13314 /** KASUMI encrypt only (UEA1) */
13315 TEST_CASE_ST(ut_setup, ut_teardown,
13316 test_kasumi_encryption_test_case_1),
13317 TEST_CASE_ST(ut_setup, ut_teardown,
13318 test_kasumi_encryption_test_case_2),
13319 TEST_CASE_ST(ut_setup, ut_teardown,
13320 test_kasumi_encryption_test_case_3),
13321 TEST_CASE_ST(ut_setup, ut_teardown,
13322 test_kasumi_encryption_test_case_4),
13323 TEST_CASE_ST(ut_setup, ut_teardown,
13324 test_kasumi_encryption_test_case_5),
13325 TEST_CASE_ST(ut_setup, ut_teardown,
13326 test_kasumi_encryption_test_case_1_sgl),
13327 TEST_CASE_ST(ut_setup, ut_teardown,
13328 test_kasumi_encryption_test_case_1_oop_sgl),
13329 /** KASUMI decrypt only (UEA1) */
13330 TEST_CASE_ST(ut_setup, ut_teardown,
13331 test_kasumi_decryption_test_case_1),
13332 TEST_CASE_ST(ut_setup, ut_teardown,
13333 test_kasumi_decryption_test_case_2),
13334 TEST_CASE_ST(ut_setup, ut_teardown,
13335 test_kasumi_decryption_test_case_3),
13336 TEST_CASE_ST(ut_setup, ut_teardown,
13337 test_kasumi_decryption_test_case_4),
13338 TEST_CASE_ST(ut_setup, ut_teardown,
13339 test_kasumi_decryption_test_case_5),
13341 TEST_CASE_ST(ut_setup, ut_teardown,
13342 test_kasumi_encryption_test_case_1_oop),
13343 TEST_CASE_ST(ut_setup, ut_teardown,
13344 test_kasumi_decryption_test_case_1_oop),
13346 /** KASUMI hash only (UIA1) */
13347 TEST_CASE_ST(ut_setup, ut_teardown,
13348 test_kasumi_hash_generate_test_case_1),
13349 TEST_CASE_ST(ut_setup, ut_teardown,
13350 test_kasumi_hash_generate_test_case_2),
13351 TEST_CASE_ST(ut_setup, ut_teardown,
13352 test_kasumi_hash_generate_test_case_3),
13353 TEST_CASE_ST(ut_setup, ut_teardown,
13354 test_kasumi_hash_generate_test_case_4),
13355 TEST_CASE_ST(ut_setup, ut_teardown,
13356 test_kasumi_hash_generate_test_case_5),
13357 TEST_CASE_ST(ut_setup, ut_teardown,
13358 test_kasumi_hash_generate_test_case_6),
13359 TEST_CASE_ST(ut_setup, ut_teardown,
13360 test_kasumi_hash_verify_test_case_1),
13361 TEST_CASE_ST(ut_setup, ut_teardown,
13362 test_kasumi_hash_verify_test_case_2),
13363 TEST_CASE_ST(ut_setup, ut_teardown,
13364 test_kasumi_hash_verify_test_case_3),
13365 TEST_CASE_ST(ut_setup, ut_teardown,
13366 test_kasumi_hash_verify_test_case_4),
13367 TEST_CASE_ST(ut_setup, ut_teardown,
13368 test_kasumi_hash_verify_test_case_5),
13371 TEST_CASE_ST(ut_setup, ut_teardown,
13372 test_null_cipher_only_operation),
13373 TEST_CASE_ST(ut_setup, ut_teardown,
13374 test_null_auth_only_operation),
13375 TEST_CASE_ST(ut_setup, ut_teardown,
13376 test_null_cipher_auth_operation),
13377 TEST_CASE_ST(ut_setup, ut_teardown,
13378 test_null_auth_cipher_operation),
13380 /** Negative tests */
13381 TEST_CASE_ST(ut_setup, ut_teardown,
13382 authentication_verify_HMAC_SHA1_fail_data_corrupt),
13383 TEST_CASE_ST(ut_setup, ut_teardown,
13384 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13385 TEST_CASE_ST(ut_setup, ut_teardown,
13386 authentication_verify_AES128_GMAC_fail_data_corrupt),
13387 TEST_CASE_ST(ut_setup, ut_teardown,
13388 authentication_verify_AES128_GMAC_fail_tag_corrupt),
13389 TEST_CASE_ST(ut_setup, ut_teardown,
13390 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13391 TEST_CASE_ST(ut_setup, ut_teardown,
13392 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13393 TEST_CASES_END() /**< NULL terminate unit test array */
13398 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
13400 gbl_driver_id = rte_cryptodev_driver_id_get(
13401 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
13403 if (gbl_driver_id == -1) {
13404 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
13405 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
13406 "are enabled in config file to run this testsuite.\n");
13407 return TEST_SKIPPED;
13410 return unit_test_suite_runner(&cryptodev_testsuite);
13414 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
13416 gbl_driver_id = rte_cryptodev_driver_id_get(
13417 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
13419 if (gbl_driver_id == -1) {
13420 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
13421 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
13422 "in config file to run this testsuite.\n");
13423 return TEST_FAILED;
13426 return unit_test_suite_runner(&cryptodev_virtio_testsuite);
13430 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
13432 gbl_driver_id = rte_cryptodev_driver_id_get(
13433 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13435 if (gbl_driver_id == -1) {
13436 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
13437 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
13438 "in config file to run this testsuite.\n");
13439 return TEST_SKIPPED;
13442 return unit_test_suite_runner(&cryptodev_testsuite);
13446 test_cryptodev_cpu_aesni_mb(void)
13449 enum rte_security_session_action_type at;
13451 gbl_driver_id = rte_cryptodev_driver_id_get(
13452 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13454 if (gbl_driver_id == -1) {
13455 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
13456 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
13457 "in config file to run this testsuite.\n");
13458 return TEST_SKIPPED;
13461 at = gbl_action_type;
13462 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13463 rc = unit_test_suite_runner(&cryptodev_testsuite);
13464 gbl_action_type = at;
13469 test_cryptodev_openssl(void)
13471 gbl_driver_id = rte_cryptodev_driver_id_get(
13472 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
13474 if (gbl_driver_id == -1) {
13475 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
13476 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
13477 "in config file to run this testsuite.\n");
13478 return TEST_SKIPPED;
13481 return unit_test_suite_runner(&cryptodev_testsuite);
13485 test_cryptodev_aesni_gcm(void)
13487 gbl_driver_id = rte_cryptodev_driver_id_get(
13488 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13490 if (gbl_driver_id == -1) {
13491 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
13492 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
13493 "in config file to run this testsuite.\n");
13494 return TEST_SKIPPED;
13497 return unit_test_suite_runner(&cryptodev_testsuite);
13501 test_cryptodev_cpu_aesni_gcm(void)
13504 enum rte_security_session_action_type at;
13506 gbl_driver_id = rte_cryptodev_driver_id_get(
13507 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13509 if (gbl_driver_id == -1) {
13510 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
13511 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
13512 "in config file to run this testsuite.\n");
13513 return TEST_SKIPPED;
13516 at = gbl_action_type;
13517 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13518 rc = unit_test_suite_runner(&cryptodev_testsuite);
13519 gbl_action_type = at;
13524 test_cryptodev_null(void)
13526 gbl_driver_id = rte_cryptodev_driver_id_get(
13527 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
13529 if (gbl_driver_id == -1) {
13530 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
13531 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
13532 "in config file to run this testsuite.\n");
13533 return TEST_SKIPPED;
13536 return unit_test_suite_runner(&cryptodev_testsuite);
13540 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
13542 gbl_driver_id = rte_cryptodev_driver_id_get(
13543 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
13545 if (gbl_driver_id == -1) {
13546 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
13547 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
13548 "in config file to run this testsuite.\n");
13549 return TEST_SKIPPED;
13552 return unit_test_suite_runner(&cryptodev_testsuite);
13556 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
13558 gbl_driver_id = rte_cryptodev_driver_id_get(
13559 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
13561 if (gbl_driver_id == -1) {
13562 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
13563 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
13564 "in config file to run this testsuite.\n");
13565 return TEST_SKIPPED;
13568 return unit_test_suite_runner(&cryptodev_testsuite);
13572 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
13574 gbl_driver_id = rte_cryptodev_driver_id_get(
13575 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
13577 if (gbl_driver_id == -1) {
13578 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
13579 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
13580 "in config file to run this testsuite.\n");
13581 return TEST_SKIPPED;
13584 return unit_test_suite_runner(&cryptodev_testsuite);
13588 test_cryptodev_armv8(void)
13590 gbl_driver_id = rte_cryptodev_driver_id_get(
13591 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
13593 if (gbl_driver_id == -1) {
13594 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
13595 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
13596 "in config file to run this testsuite.\n");
13597 return TEST_SKIPPED;
13600 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
13604 test_cryptodev_mrvl(void)
13606 gbl_driver_id = rte_cryptodev_driver_id_get(
13607 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
13609 if (gbl_driver_id == -1) {
13610 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
13611 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
13612 "in config file to run this testsuite.\n");
13613 return TEST_SKIPPED;
13616 return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
13619 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
13622 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
13624 gbl_driver_id = rte_cryptodev_driver_id_get(
13625 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13627 if (gbl_driver_id == -1) {
13628 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
13629 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
13630 "in config file to run this testsuite.\n");
13631 return TEST_SKIPPED;
13634 if (rte_cryptodev_driver_id_get(
13635 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
13636 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
13637 " enabled in config file to run this testsuite.\n");
13638 return TEST_SKIPPED;
13640 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
13643 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
13648 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13650 gbl_driver_id = rte_cryptodev_driver_id_get(
13651 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
13653 if (gbl_driver_id == -1) {
13654 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
13655 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
13656 "in config file to run this testsuite.\n");
13657 return TEST_SKIPPED;
13660 return unit_test_suite_runner(&cryptodev_testsuite);
13664 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13666 gbl_driver_id = rte_cryptodev_driver_id_get(
13667 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
13669 if (gbl_driver_id == -1) {
13670 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
13671 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
13672 "in config file to run this testsuite.\n");
13673 return TEST_SKIPPED;
13676 return unit_test_suite_runner(&cryptodev_testsuite);
13680 test_cryptodev_ccp(void)
13682 gbl_driver_id = rte_cryptodev_driver_id_get(
13683 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
13685 if (gbl_driver_id == -1) {
13686 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
13687 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
13688 "in config file to run this testsuite.\n");
13689 return TEST_FAILED;
13692 return unit_test_suite_runner(&cryptodev_ccp_testsuite);
13696 test_cryptodev_octeontx(void)
13698 gbl_driver_id = rte_cryptodev_driver_id_get(
13699 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
13700 if (gbl_driver_id == -1) {
13701 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
13702 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
13703 "enabled in config file to run this "
13705 return TEST_FAILED;
13707 return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
13711 test_cryptodev_octeontx2(void)
13713 gbl_driver_id = rte_cryptodev_driver_id_get(
13714 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
13715 if (gbl_driver_id == -1) {
13716 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded. Check if "
13717 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is "
13718 "enabled in config file to run this "
13720 return TEST_FAILED;
13722 return unit_test_suite_runner(&cryptodev_octeontx2_testsuite);
13726 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
13728 gbl_driver_id = rte_cryptodev_driver_id_get(
13729 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
13731 if (gbl_driver_id == -1) {
13732 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
13733 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
13734 "in config file to run this testsuite.\n");
13735 return TEST_FAILED;
13738 return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
13742 test_cryptodev_nitrox(void)
13744 gbl_driver_id = rte_cryptodev_driver_id_get(
13745 RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
13747 if (gbl_driver_id == -1) {
13748 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if "
13749 "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled "
13750 "in config file to run this testsuite.\n");
13751 return TEST_FAILED;
13754 return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
13757 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
13758 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
13759 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
13760 test_cryptodev_cpu_aesni_mb);
13761 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
13762 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
13763 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
13764 test_cryptodev_cpu_aesni_gcm);
13765 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
13766 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
13767 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
13768 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
13769 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
13770 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
13771 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
13772 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
13773 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
13774 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
13775 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
13776 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
13777 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
13778 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);