1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015-2019 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>
15 #include <rte_crypto.h>
16 #include <rte_cryptodev.h>
17 #include <rte_cryptodev_pmd.h>
18 #include <rte_string_fns.h>
20 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
21 #include <rte_cryptodev_scheduler.h>
22 #include <rte_cryptodev_scheduler_operations.h>
25 #include <rte_lcore.h>
28 #include "test_cryptodev.h"
30 #include "test_cryptodev_blockcipher.h"
31 #include "test_cryptodev_aes_test_vectors.h"
32 #include "test_cryptodev_des_test_vectors.h"
33 #include "test_cryptodev_hash_test_vectors.h"
34 #include "test_cryptodev_kasumi_test_vectors.h"
35 #include "test_cryptodev_kasumi_hash_test_vectors.h"
36 #include "test_cryptodev_snow3g_test_vectors.h"
37 #include "test_cryptodev_snow3g_hash_test_vectors.h"
38 #include "test_cryptodev_zuc_test_vectors.h"
39 #include "test_cryptodev_aead_test_vectors.h"
40 #include "test_cryptodev_hmac_test_vectors.h"
41 #ifdef RTE_LIBRTE_SECURITY
42 #include "test_cryptodev_security_pdcp_test_vectors.h"
43 #include "test_cryptodev_security_pdcp_test_func.h"
46 #define VDEV_ARGS_SIZE 100
47 #define MAX_NB_SESSIONS 4
50 #define OUT_OF_PLACE 1
52 static int gbl_driver_id;
54 struct crypto_testsuite_params {
55 struct rte_mempool *mbuf_pool;
56 struct rte_mempool *large_mbuf_pool;
57 struct rte_mempool *op_mpool;
58 struct rte_mempool *session_mpool;
59 struct rte_mempool *session_priv_mpool;
60 struct rte_cryptodev_config conf;
61 struct rte_cryptodev_qp_conf qp_conf;
63 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
64 uint8_t valid_dev_count;
67 struct crypto_unittest_params {
68 struct rte_crypto_sym_xform cipher_xform;
69 struct rte_crypto_sym_xform auth_xform;
70 struct rte_crypto_sym_xform aead_xform;
73 struct rte_cryptodev_sym_session *sess;
74 struct rte_security_session *sec_session;
76 enum rte_security_session_action_type type;
77 struct rte_crypto_op *op;
79 struct rte_mbuf *obuf, *ibuf;
84 #define ALIGN_POW2_ROUNDUP(num, align) \
85 (((num) + (align) - 1) & ~((align) - 1))
88 * Forward declarations.
91 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
92 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
96 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
97 struct crypto_unittest_params *ut_params,
98 struct crypto_testsuite_params *ts_param,
99 const uint8_t *cipher,
100 const uint8_t *digest,
103 static struct rte_mbuf *
104 setup_test_string(struct rte_mempool *mpool,
105 const char *string, size_t len, uint8_t blocksize)
107 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
108 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
110 memset(m->buf_addr, 0, m->buf_len);
112 char *dst = rte_pktmbuf_append(m, t_len);
119 rte_memcpy(dst, string, t_len);
121 memset(dst, 0, t_len);
127 /* Get number of bytes in X bits (rounding up) */
129 ceil_byte_length(uint32_t num_bits)
132 return ((num_bits >> 3) + 1);
134 return (num_bits >> 3);
137 static struct rte_crypto_op *
138 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
140 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
141 printf("Error sending packet for encryption");
147 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
153 static struct crypto_testsuite_params testsuite_params = { NULL };
154 static struct crypto_unittest_params unittest_params;
157 testsuite_setup(void)
159 struct crypto_testsuite_params *ts_params = &testsuite_params;
160 struct rte_cryptodev_info info;
161 uint32_t i = 0, nb_devs, dev_id;
165 memset(ts_params, 0, sizeof(*ts_params));
167 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
168 if (ts_params->mbuf_pool == NULL) {
169 /* Not already created so create */
170 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
172 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
174 if (ts_params->mbuf_pool == NULL) {
175 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
180 ts_params->large_mbuf_pool = rte_mempool_lookup(
181 "CRYPTO_LARGE_MBUFPOOL");
182 if (ts_params->large_mbuf_pool == NULL) {
183 /* Not already created so create */
184 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
185 "CRYPTO_LARGE_MBUFPOOL",
188 if (ts_params->large_mbuf_pool == NULL) {
190 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
195 ts_params->op_mpool = rte_crypto_op_pool_create(
196 "MBUF_CRYPTO_SYM_OP_POOL",
197 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
198 NUM_MBUFS, MBUF_CACHE_SIZE,
200 sizeof(struct rte_crypto_sym_xform) +
203 if (ts_params->op_mpool == NULL) {
204 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
208 /* Create an AESNI MB device if required */
209 if (gbl_driver_id == rte_cryptodev_driver_id_get(
210 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
211 nb_devs = rte_cryptodev_device_count_by_driver(
212 rte_cryptodev_driver_id_get(
213 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
216 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
218 TEST_ASSERT(ret == 0,
219 "Failed to create instance of"
221 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
225 /* Create an AESNI GCM device if required */
226 if (gbl_driver_id == rte_cryptodev_driver_id_get(
227 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
228 nb_devs = rte_cryptodev_device_count_by_driver(
229 rte_cryptodev_driver_id_get(
230 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
232 TEST_ASSERT_SUCCESS(rte_vdev_init(
233 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
234 "Failed to create instance of"
236 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
240 /* Create a SNOW 3G device if required */
241 if (gbl_driver_id == rte_cryptodev_driver_id_get(
242 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
243 nb_devs = rte_cryptodev_device_count_by_driver(
244 rte_cryptodev_driver_id_get(
245 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
247 TEST_ASSERT_SUCCESS(rte_vdev_init(
248 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
249 "Failed to create instance of"
251 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
255 /* Create a KASUMI device if required */
256 if (gbl_driver_id == rte_cryptodev_driver_id_get(
257 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
258 nb_devs = rte_cryptodev_device_count_by_driver(
259 rte_cryptodev_driver_id_get(
260 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
262 TEST_ASSERT_SUCCESS(rte_vdev_init(
263 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
264 "Failed to create instance of"
266 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
270 /* Create a ZUC device if required */
271 if (gbl_driver_id == rte_cryptodev_driver_id_get(
272 RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
273 nb_devs = rte_cryptodev_device_count_by_driver(
274 rte_cryptodev_driver_id_get(
275 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
277 TEST_ASSERT_SUCCESS(rte_vdev_init(
278 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
279 "Failed to create instance of"
281 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
285 /* Create a NULL device if required */
286 if (gbl_driver_id == rte_cryptodev_driver_id_get(
287 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
288 nb_devs = rte_cryptodev_device_count_by_driver(
289 rte_cryptodev_driver_id_get(
290 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
293 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
295 TEST_ASSERT(ret == 0,
296 "Failed to create instance of"
298 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
302 /* Create an OPENSSL device if required */
303 if (gbl_driver_id == rte_cryptodev_driver_id_get(
304 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
305 nb_devs = rte_cryptodev_device_count_by_driver(
306 rte_cryptodev_driver_id_get(
307 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
310 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
313 TEST_ASSERT(ret == 0, "Failed to create "
314 "instance of pmd : %s",
315 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
319 /* Create a ARMv8 device if required */
320 if (gbl_driver_id == rte_cryptodev_driver_id_get(
321 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
322 nb_devs = rte_cryptodev_device_count_by_driver(
323 rte_cryptodev_driver_id_get(
324 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
327 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
330 TEST_ASSERT(ret == 0, "Failed to create "
331 "instance of pmd : %s",
332 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
336 /* Create a MVSAM device if required */
337 if (gbl_driver_id == rte_cryptodev_driver_id_get(
338 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
339 nb_devs = rte_cryptodev_device_count_by_driver(
340 rte_cryptodev_driver_id_get(
341 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
344 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
347 TEST_ASSERT(ret == 0, "Failed to create "
348 "instance of pmd : %s",
349 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
353 /* Create an CCP device if required */
354 if (gbl_driver_id == rte_cryptodev_driver_id_get(
355 RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
356 nb_devs = rte_cryptodev_device_count_by_driver(
357 rte_cryptodev_driver_id_get(
358 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
361 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
364 TEST_ASSERT(ret == 0, "Failed to create "
365 "instance of pmd : %s",
366 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
370 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
371 char vdev_args[VDEV_ARGS_SIZE] = {""};
372 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
373 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
374 uint16_t slave_core_count = 0;
375 uint16_t socket_id = 0;
377 if (gbl_driver_id == rte_cryptodev_driver_id_get(
378 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
380 /* Identify the Slave Cores
381 * Use 2 slave cores for the device args
383 RTE_LCORE_FOREACH_SLAVE(i) {
384 if (slave_core_count > 1)
386 snprintf(vdev_args, sizeof(vdev_args),
387 "%s%d", temp_str, i);
388 strcpy(temp_str, vdev_args);
389 strlcat(temp_str, ";", sizeof(temp_str));
391 socket_id = rte_lcore_to_socket_id(i);
393 if (slave_core_count != 2) {
395 "Cryptodev scheduler test require at least "
396 "two slave cores to run. "
397 "Please use the correct coremask.\n");
400 strcpy(temp_str, vdev_args);
401 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
402 temp_str, socket_id);
403 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
404 nb_devs = rte_cryptodev_device_count_by_driver(
405 rte_cryptodev_driver_id_get(
406 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
409 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
411 TEST_ASSERT(ret == 0,
412 "Failed to create instance %u of"
414 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
417 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
419 nb_devs = rte_cryptodev_count();
421 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
425 /* Create list of valid crypto devs */
426 for (i = 0; i < nb_devs; i++) {
427 rte_cryptodev_info_get(i, &info);
428 if (info.driver_id == gbl_driver_id)
429 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
432 if (ts_params->valid_dev_count < 1)
435 /* Set up all the qps on the first of the valid devices found */
437 dev_id = ts_params->valid_devs[0];
439 rte_cryptodev_info_get(dev_id, &info);
441 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
442 ts_params->conf.socket_id = SOCKET_ID_ANY;
443 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
445 unsigned int session_size =
446 rte_cryptodev_sym_get_private_session_size(dev_id);
449 * Create mempool with maximum number of sessions * 2,
450 * to include the session headers
452 if (info.sym.max_nb_sessions != 0 &&
453 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
454 RTE_LOG(ERR, USER1, "Device does not support "
455 "at least %u sessions\n",
460 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
461 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
463 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
464 "session mempool allocation failed");
466 ts_params->session_priv_mpool = rte_mempool_create(
470 0, 0, NULL, NULL, NULL,
473 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
474 "session mempool allocation failed");
478 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
480 "Failed to configure cryptodev %u with %u qps",
481 dev_id, ts_params->conf.nb_queue_pairs);
483 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
484 ts_params->qp_conf.mp_session = ts_params->session_mpool;
485 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
487 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
488 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
489 dev_id, qp_id, &ts_params->qp_conf,
490 rte_cryptodev_socket_id(dev_id)),
491 "Failed to setup queue pair %u on cryptodev %u",
499 testsuite_teardown(void)
501 struct crypto_testsuite_params *ts_params = &testsuite_params;
503 if (ts_params->mbuf_pool != NULL) {
504 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
505 rte_mempool_avail_count(ts_params->mbuf_pool));
508 if (ts_params->op_mpool != NULL) {
509 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
510 rte_mempool_avail_count(ts_params->op_mpool));
513 /* Free session mempools */
514 if (ts_params->session_priv_mpool != NULL) {
515 rte_mempool_free(ts_params->session_priv_mpool);
516 ts_params->session_priv_mpool = NULL;
519 if (ts_params->session_mpool != NULL) {
520 rte_mempool_free(ts_params->session_mpool);
521 ts_params->session_mpool = NULL;
528 struct crypto_testsuite_params *ts_params = &testsuite_params;
529 struct crypto_unittest_params *ut_params = &unittest_params;
533 /* Clear unit test parameters before running test */
534 memset(ut_params, 0, sizeof(*ut_params));
536 /* Reconfigure device to default parameters */
537 ts_params->conf.socket_id = SOCKET_ID_ANY;
538 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
539 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
540 ts_params->qp_conf.mp_session = ts_params->session_mpool;
541 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
543 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
545 "Failed to configure cryptodev %u",
546 ts_params->valid_devs[0]);
548 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
549 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
550 ts_params->valid_devs[0], qp_id,
552 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
553 "Failed to setup queue pair %u on cryptodev %u",
554 qp_id, ts_params->valid_devs[0]);
558 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
560 /* Start the device */
561 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
562 "Failed to start cryptodev %u",
563 ts_params->valid_devs[0]);
571 struct crypto_testsuite_params *ts_params = &testsuite_params;
572 struct crypto_unittest_params *ut_params = &unittest_params;
573 struct rte_cryptodev_stats stats;
575 /* free crypto session structure */
576 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
577 if (ut_params->sec_session) {
578 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
579 (ts_params->valid_devs[0]),
580 ut_params->sec_session);
581 ut_params->sec_session = NULL;
584 if (ut_params->sess) {
585 rte_cryptodev_sym_session_clear(
586 ts_params->valid_devs[0],
588 rte_cryptodev_sym_session_free(ut_params->sess);
589 ut_params->sess = NULL;
593 /* free crypto operation structure */
595 rte_crypto_op_free(ut_params->op);
598 * free mbuf - both obuf and ibuf are usually the same,
599 * so check if they point at the same address is necessary,
600 * to avoid freeing the mbuf twice.
602 if (ut_params->obuf) {
603 rte_pktmbuf_free(ut_params->obuf);
604 if (ut_params->ibuf == ut_params->obuf)
608 if (ut_params->ibuf) {
609 rte_pktmbuf_free(ut_params->ibuf);
613 if (ts_params->mbuf_pool != NULL)
614 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
615 rte_mempool_avail_count(ts_params->mbuf_pool));
617 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
619 /* Stop the device */
620 rte_cryptodev_stop(ts_params->valid_devs[0]);
624 test_device_configure_invalid_dev_id(void)
626 struct crypto_testsuite_params *ts_params = &testsuite_params;
627 uint16_t dev_id, num_devs = 0;
629 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
630 "Need at least %d devices for test", 1);
632 /* valid dev_id values */
633 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
635 /* Stop the device in case it's started so it can be configured */
636 rte_cryptodev_stop(dev_id);
638 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
639 "Failed test for rte_cryptodev_configure: "
640 "invalid dev_num %u", dev_id);
642 /* invalid dev_id values */
645 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
646 "Failed test for rte_cryptodev_configure: "
647 "invalid dev_num %u", dev_id);
651 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
652 "Failed test for rte_cryptodev_configure:"
653 "invalid dev_num %u", dev_id);
659 test_device_configure_invalid_queue_pair_ids(void)
661 struct crypto_testsuite_params *ts_params = &testsuite_params;
662 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
664 /* Stop the device in case it's started so it can be configured */
665 rte_cryptodev_stop(ts_params->valid_devs[0]);
667 /* valid - one queue pairs */
668 ts_params->conf.nb_queue_pairs = 1;
670 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
672 "Failed to configure cryptodev: dev_id %u, qp_id %u",
673 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
676 /* valid - max value queue pairs */
677 ts_params->conf.nb_queue_pairs = orig_nb_qps;
679 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
681 "Failed to configure cryptodev: dev_id %u, qp_id %u",
682 ts_params->valid_devs[0],
683 ts_params->conf.nb_queue_pairs);
686 /* invalid - zero queue pairs */
687 ts_params->conf.nb_queue_pairs = 0;
689 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
691 "Failed test for rte_cryptodev_configure, dev_id %u,"
693 ts_params->valid_devs[0],
694 ts_params->conf.nb_queue_pairs);
697 /* invalid - max value supported by field queue pairs */
698 ts_params->conf.nb_queue_pairs = UINT16_MAX;
700 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
702 "Failed test for rte_cryptodev_configure, dev_id %u,"
704 ts_params->valid_devs[0],
705 ts_params->conf.nb_queue_pairs);
708 /* invalid - max value + 1 queue pairs */
709 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
711 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
713 "Failed test for rte_cryptodev_configure, dev_id %u,"
715 ts_params->valid_devs[0],
716 ts_params->conf.nb_queue_pairs);
718 /* revert to original testsuite value */
719 ts_params->conf.nb_queue_pairs = orig_nb_qps;
725 test_queue_pair_descriptor_setup(void)
727 struct crypto_testsuite_params *ts_params = &testsuite_params;
728 struct rte_cryptodev_info dev_info;
729 struct rte_cryptodev_qp_conf qp_conf = {
730 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
735 /* Stop the device in case it's started so it can be configured */
736 rte_cryptodev_stop(ts_params->valid_devs[0]);
739 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
741 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
743 "Failed to configure cryptodev %u",
744 ts_params->valid_devs[0]);
747 * Test various ring sizes on this device. memzones can't be
748 * freed so are re-used if ring is released and re-created.
750 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
751 qp_conf.mp_session = ts_params->session_mpool;
752 qp_conf.mp_session_private = ts_params->session_priv_mpool;
754 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
755 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
756 ts_params->valid_devs[0], qp_id, &qp_conf,
757 rte_cryptodev_socket_id(
758 ts_params->valid_devs[0])),
760 "rte_cryptodev_queue_pair_setup: num_inflights "
761 "%u on qp %u on cryptodev %u",
762 qp_conf.nb_descriptors, qp_id,
763 ts_params->valid_devs[0]);
766 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
768 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
769 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
770 ts_params->valid_devs[0], qp_id, &qp_conf,
771 rte_cryptodev_socket_id(
772 ts_params->valid_devs[0])),
774 " rte_cryptodev_queue_pair_setup: num_inflights"
775 " %u on qp %u on cryptodev %u",
776 qp_conf.nb_descriptors, qp_id,
777 ts_params->valid_devs[0]);
780 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
782 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
783 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
784 ts_params->valid_devs[0], qp_id, &qp_conf,
785 rte_cryptodev_socket_id(
786 ts_params->valid_devs[0])),
788 "rte_cryptodev_queue_pair_setup: num_inflights"
789 " %u on qp %u on cryptodev %u",
790 qp_conf.nb_descriptors, qp_id,
791 ts_params->valid_devs[0]);
794 /* invalid number of descriptors - max supported + 2 */
795 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
797 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
798 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
799 ts_params->valid_devs[0], qp_id, &qp_conf,
800 rte_cryptodev_socket_id(
801 ts_params->valid_devs[0])),
802 "Unexpectedly passed test for "
803 "rte_cryptodev_queue_pair_setup:"
804 "num_inflights %u on qp %u on cryptodev %u",
805 qp_conf.nb_descriptors, qp_id,
806 ts_params->valid_devs[0]);
809 /* invalid number of descriptors - max value of parameter */
810 qp_conf.nb_descriptors = UINT32_MAX-1;
812 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
813 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
814 ts_params->valid_devs[0], qp_id, &qp_conf,
815 rte_cryptodev_socket_id(
816 ts_params->valid_devs[0])),
817 "Unexpectedly passed test for "
818 "rte_cryptodev_queue_pair_setup:"
819 "num_inflights %u on qp %u on cryptodev %u",
820 qp_conf.nb_descriptors, qp_id,
821 ts_params->valid_devs[0]);
824 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
826 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
827 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
828 ts_params->valid_devs[0], qp_id, &qp_conf,
829 rte_cryptodev_socket_id(
830 ts_params->valid_devs[0])),
832 " rte_cryptodev_queue_pair_setup:"
833 "num_inflights %u on qp %u on cryptodev %u",
834 qp_conf.nb_descriptors, qp_id,
835 ts_params->valid_devs[0]);
838 /* invalid number of descriptors - max supported + 1 */
839 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
841 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
842 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
843 ts_params->valid_devs[0], qp_id, &qp_conf,
844 rte_cryptodev_socket_id(
845 ts_params->valid_devs[0])),
846 "Unexpectedly passed test for "
847 "rte_cryptodev_queue_pair_setup:"
848 "num_inflights %u on qp %u on cryptodev %u",
849 qp_conf.nb_descriptors, qp_id,
850 ts_params->valid_devs[0]);
853 /* test invalid queue pair id */
854 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
856 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
858 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
859 ts_params->valid_devs[0],
861 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
862 "Failed test for rte_cryptodev_queue_pair_setup:"
863 "invalid qp %u on cryptodev %u",
864 qp_id, ts_params->valid_devs[0]);
866 qp_id = 0xffff; /*invalid*/
868 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
869 ts_params->valid_devs[0],
871 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
872 "Failed test for rte_cryptodev_queue_pair_setup:"
873 "invalid qp %u on cryptodev %u",
874 qp_id, ts_params->valid_devs[0]);
879 /* ***** Plaintext data for tests ***** */
881 const char catch_22_quote_1[] =
882 "There was only one catch and that was Catch-22, which "
883 "specified that a concern for one's safety in the face of "
884 "dangers that were real and immediate was the process of a "
885 "rational mind. Orr was crazy and could be grounded. All he "
886 "had to do was ask; and as soon as he did, he would no longer "
887 "be crazy and would have to fly more missions. Orr would be "
888 "crazy to fly more missions and sane if he didn't, but if he "
889 "was sane he had to fly them. If he flew them he was crazy "
890 "and didn't have to; but if he didn't want to he was sane and "
891 "had to. Yossarian was moved very deeply by the absolute "
892 "simplicity of this clause of Catch-22 and let out a "
893 "respectful whistle. \"That's some catch, that Catch-22\", he "
894 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
896 const char catch_22_quote[] =
897 "What a lousy earth! He wondered how many people were "
898 "destitute that same night even in his own prosperous country, "
899 "how many homes were shanties, how many husbands were drunk "
900 "and wives socked, and how many children were bullied, abused, "
901 "or abandoned. How many families hungered for food they could "
902 "not afford to buy? How many hearts were broken? How many "
903 "suicides would take place that same night, how many people "
904 "would go insane? How many cockroaches and landlords would "
905 "triumph? How many winners were losers, successes failures, "
906 "and rich men poor men? How many wise guys were stupid? How "
907 "many happy endings were unhappy endings? How many honest men "
908 "were liars, brave men cowards, loyal men traitors, how many "
909 "sainted men were corrupt, how many people in positions of "
910 "trust had sold their souls to bodyguards, how many had never "
911 "had souls? How many straight-and-narrow paths were crooked "
912 "paths? How many best families were worst families and how "
913 "many good people were bad people? When you added them all up "
914 "and then subtracted, you might be left with only the children, "
915 "and perhaps with Albert Einstein and an old violinist or "
916 "sculptor somewhere.";
918 #define QUOTE_480_BYTES (480)
919 #define QUOTE_512_BYTES (512)
920 #define QUOTE_768_BYTES (768)
921 #define QUOTE_1024_BYTES (1024)
925 /* ***** SHA1 Hash Tests ***** */
927 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
929 static uint8_t hmac_sha1_key[] = {
930 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
931 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
932 0xDE, 0xF4, 0xDE, 0xAD };
934 /* ***** SHA224 Hash Tests ***** */
936 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
939 /* ***** AES-CBC Cipher Tests ***** */
941 #define CIPHER_KEY_LENGTH_AES_CBC (16)
942 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
944 static uint8_t aes_cbc_key[] = {
945 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
946 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
948 static uint8_t aes_cbc_iv[] = {
949 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
950 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
953 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
955 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
956 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
957 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
958 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
959 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
960 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
961 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
962 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
963 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
964 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
965 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
966 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
967 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
968 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
969 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
970 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
971 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
972 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
973 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
974 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
975 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
976 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
977 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
978 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
979 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
980 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
981 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
982 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
983 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
984 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
985 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
986 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
987 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
988 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
989 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
990 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
991 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
992 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
993 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
994 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
995 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
996 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
997 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
998 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
999 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1000 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1001 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1002 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1003 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1004 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1005 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1006 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1007 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1008 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1009 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1010 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1011 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1012 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1013 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1014 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1015 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1016 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1017 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1018 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1019 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1022 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1023 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1024 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1025 0x18, 0x8c, 0x1d, 0x32
1029 /* Multisession Vector context Test */
1030 /*Begin Session 0 */
1031 static uint8_t ms_aes_cbc_key0[] = {
1032 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1033 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1036 static uint8_t ms_aes_cbc_iv0[] = {
1037 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1038 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1041 static const uint8_t ms_aes_cbc_cipher0[] = {
1042 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1043 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1044 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1045 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1046 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1047 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1048 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1049 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1050 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1051 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1052 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1053 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1054 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1055 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1056 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1057 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1058 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1059 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1060 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1061 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1062 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1063 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1064 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1065 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1066 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1067 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1068 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1069 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1070 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1071 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1072 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1073 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1074 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1075 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1076 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1077 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1078 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1079 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1080 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1081 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1082 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1083 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1084 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1085 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1086 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1087 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1088 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1089 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1090 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1091 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1092 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1093 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1094 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1095 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1096 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1097 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1098 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1099 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1100 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1101 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1102 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1103 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1104 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1105 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1109 static uint8_t ms_hmac_key0[] = {
1110 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1111 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1112 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1113 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1114 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1115 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1116 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1117 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1120 static const uint8_t ms_hmac_digest0[] = {
1121 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1122 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1123 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1124 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1125 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1126 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1127 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1128 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1132 /* Begin session 1 */
1134 static uint8_t ms_aes_cbc_key1[] = {
1135 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1136 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1139 static uint8_t ms_aes_cbc_iv1[] = {
1140 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1141 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1144 static const uint8_t ms_aes_cbc_cipher1[] = {
1145 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1146 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1147 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1148 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1149 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1150 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1151 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1152 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1153 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1154 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1155 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1156 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1157 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1158 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1159 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1160 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1161 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1162 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1163 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1164 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1165 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1166 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1167 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1168 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1169 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1170 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1171 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1172 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1173 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1174 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1175 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1176 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1177 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1178 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1179 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1180 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1181 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1182 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1183 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1184 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1185 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1186 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1187 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1188 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1189 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1190 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1191 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1192 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1193 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1194 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1195 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1196 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1197 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1198 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1199 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1200 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1201 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1202 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1203 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1204 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1205 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1206 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1207 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1208 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1212 static uint8_t ms_hmac_key1[] = {
1213 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1214 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1215 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1216 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1217 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1218 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1219 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1220 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1223 static const uint8_t ms_hmac_digest1[] = {
1224 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1225 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1226 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1227 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1228 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1229 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1230 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1231 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1234 /* Begin Session 2 */
1235 static uint8_t ms_aes_cbc_key2[] = {
1236 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1237 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1240 static uint8_t ms_aes_cbc_iv2[] = {
1241 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1242 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1245 static const uint8_t ms_aes_cbc_cipher2[] = {
1246 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1247 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1248 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1249 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1250 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1251 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1252 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1253 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1254 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1255 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1256 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1257 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1258 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1259 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1260 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1261 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1262 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1263 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1264 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1265 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1266 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1267 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1268 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1269 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1270 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1271 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1272 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1273 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1274 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1275 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1276 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1277 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1278 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1279 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1280 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1281 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1282 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1283 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1284 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1285 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1286 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1287 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1288 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1289 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1290 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1291 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1292 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1293 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1294 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1295 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1296 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1297 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1298 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1299 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1300 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1301 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1302 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1303 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1304 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1305 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1306 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1307 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1308 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1309 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1312 static uint8_t ms_hmac_key2[] = {
1313 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1314 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1315 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1316 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1317 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1318 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1319 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1320 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1323 static const uint8_t ms_hmac_digest2[] = {
1324 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1325 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1326 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1327 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1328 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1329 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1330 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1331 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1338 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1340 struct crypto_testsuite_params *ts_params = &testsuite_params;
1341 struct crypto_unittest_params *ut_params = &unittest_params;
1343 /* Generate test mbuf data and space for digest */
1344 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1345 catch_22_quote, QUOTE_512_BYTES, 0);
1347 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1348 DIGEST_BYTE_LENGTH_SHA1);
1349 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1351 /* Setup Cipher Parameters */
1352 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1353 ut_params->cipher_xform.next = &ut_params->auth_xform;
1355 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1356 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1357 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1358 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1359 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1360 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1362 /* Setup HMAC Parameters */
1363 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1365 ut_params->auth_xform.next = NULL;
1367 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1368 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1369 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1370 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1371 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1373 ut_params->sess = rte_cryptodev_sym_session_create(
1374 ts_params->session_mpool);
1376 /* Create crypto session*/
1377 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1378 ut_params->sess, &ut_params->cipher_xform,
1379 ts_params->session_priv_mpool);
1380 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1382 /* Generate crypto op data structure */
1383 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1384 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1385 TEST_ASSERT_NOT_NULL(ut_params->op,
1386 "Failed to allocate symmetric crypto operation struct");
1388 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1390 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1392 /* set crypto operation source mbuf */
1393 sym_op->m_src = ut_params->ibuf;
1395 /* Set crypto operation authentication parameters */
1396 sym_op->auth.digest.data = ut_params->digest;
1397 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1398 ut_params->ibuf, QUOTE_512_BYTES);
1400 sym_op->auth.data.offset = 0;
1401 sym_op->auth.data.length = QUOTE_512_BYTES;
1403 /* Copy IV at the end of the crypto operation */
1404 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1405 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1407 /* Set crypto operation cipher parameters */
1408 sym_op->cipher.data.offset = 0;
1409 sym_op->cipher.data.length = QUOTE_512_BYTES;
1411 /* Process crypto operation */
1412 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1413 ut_params->op), "failed to process sym crypto op");
1415 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1416 "crypto op processing failed");
1419 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1422 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1423 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1425 "ciphertext data not as expected");
1427 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1429 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1430 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1431 gbl_driver_id == rte_cryptodev_driver_id_get(
1432 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1433 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1434 DIGEST_BYTE_LENGTH_SHA1,
1435 "Generated digest data not as expected");
1437 return TEST_SUCCESS;
1440 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1442 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1444 static uint8_t hmac_sha512_key[] = {
1445 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1446 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1447 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1448 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1449 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1450 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1451 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1452 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1454 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1455 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1456 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1457 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1458 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1459 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1460 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1461 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1462 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1467 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1468 struct crypto_unittest_params *ut_params,
1469 uint8_t *cipher_key,
1473 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1474 struct crypto_unittest_params *ut_params,
1475 struct crypto_testsuite_params *ts_params,
1476 const uint8_t *cipher,
1477 const uint8_t *digest,
1482 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1483 struct crypto_unittest_params *ut_params,
1484 uint8_t *cipher_key,
1488 /* Setup Cipher Parameters */
1489 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1490 ut_params->cipher_xform.next = NULL;
1492 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1493 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1494 ut_params->cipher_xform.cipher.key.data = cipher_key;
1495 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1496 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1497 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1499 /* Setup HMAC Parameters */
1500 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1501 ut_params->auth_xform.next = &ut_params->cipher_xform;
1503 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1504 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1505 ut_params->auth_xform.auth.key.data = hmac_key;
1506 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1507 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1509 return TEST_SUCCESS;
1514 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1515 struct crypto_unittest_params *ut_params,
1516 struct crypto_testsuite_params *ts_params,
1517 const uint8_t *cipher,
1518 const uint8_t *digest,
1521 /* Generate test mbuf data and digest */
1522 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1525 QUOTE_512_BYTES, 0);
1527 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1528 DIGEST_BYTE_LENGTH_SHA512);
1529 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1531 rte_memcpy(ut_params->digest,
1533 DIGEST_BYTE_LENGTH_SHA512);
1535 /* Generate Crypto op data structure */
1536 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1537 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1538 TEST_ASSERT_NOT_NULL(ut_params->op,
1539 "Failed to allocate symmetric crypto operation struct");
1541 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1543 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1545 /* set crypto operation source mbuf */
1546 sym_op->m_src = ut_params->ibuf;
1548 sym_op->auth.digest.data = ut_params->digest;
1549 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1550 ut_params->ibuf, QUOTE_512_BYTES);
1552 sym_op->auth.data.offset = 0;
1553 sym_op->auth.data.length = QUOTE_512_BYTES;
1555 /* Copy IV at the end of the crypto operation */
1556 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1557 iv, CIPHER_IV_LENGTH_AES_CBC);
1559 sym_op->cipher.data.offset = 0;
1560 sym_op->cipher.data.length = QUOTE_512_BYTES;
1562 /* Process crypto operation */
1563 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1564 ut_params->op), "failed to process sym crypto op");
1566 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1567 "crypto op processing failed");
1569 ut_params->obuf = ut_params->op->sym->m_src;
1572 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1573 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1576 "Plaintext data not as expected");
1579 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1580 "Digest verification failed");
1582 return TEST_SUCCESS;
1586 test_AES_cipheronly_mb_all(void)
1588 struct crypto_testsuite_params *ts_params = &testsuite_params;
1591 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1592 ts_params->op_mpool,
1593 ts_params->session_mpool, ts_params->session_priv_mpool,
1594 ts_params->valid_devs[0],
1595 rte_cryptodev_driver_id_get(
1596 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1597 BLKCIPHER_AES_CIPHERONLY_TYPE);
1599 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1601 return TEST_SUCCESS;
1605 test_AES_docsis_mb_all(void)
1607 struct crypto_testsuite_params *ts_params = &testsuite_params;
1610 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1611 ts_params->op_mpool,
1612 ts_params->session_mpool, ts_params->session_priv_mpool,
1613 ts_params->valid_devs[0],
1614 rte_cryptodev_driver_id_get(
1615 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1616 BLKCIPHER_AES_DOCSIS_TYPE);
1618 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1620 return TEST_SUCCESS;
1624 test_AES_docsis_qat_all(void)
1626 struct crypto_testsuite_params *ts_params = &testsuite_params;
1629 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1630 ts_params->op_mpool,
1631 ts_params->session_mpool, ts_params->session_priv_mpool,
1632 ts_params->valid_devs[0],
1633 rte_cryptodev_driver_id_get(
1634 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1635 BLKCIPHER_AES_DOCSIS_TYPE);
1637 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1639 return TEST_SUCCESS;
1643 test_DES_docsis_qat_all(void)
1645 struct crypto_testsuite_params *ts_params = &testsuite_params;
1648 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1649 ts_params->op_mpool,
1650 ts_params->session_mpool, ts_params->session_priv_mpool,
1651 ts_params->valid_devs[0],
1652 rte_cryptodev_driver_id_get(
1653 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1654 BLKCIPHER_DES_DOCSIS_TYPE);
1656 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1658 return TEST_SUCCESS;
1662 test_authonly_mb_all(void)
1664 struct crypto_testsuite_params *ts_params = &testsuite_params;
1667 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1668 ts_params->op_mpool,
1669 ts_params->session_mpool, ts_params->session_priv_mpool,
1670 ts_params->valid_devs[0],
1671 rte_cryptodev_driver_id_get(
1672 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1673 BLKCIPHER_AUTHONLY_TYPE);
1675 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1677 return TEST_SUCCESS;
1681 test_authonly_qat_all(void)
1683 struct crypto_testsuite_params *ts_params = &testsuite_params;
1686 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1687 ts_params->op_mpool,
1688 ts_params->session_mpool, ts_params->session_priv_mpool,
1689 ts_params->valid_devs[0],
1690 rte_cryptodev_driver_id_get(
1691 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1692 BLKCIPHER_AUTHONLY_TYPE);
1694 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1696 return TEST_SUCCESS;
1700 test_AES_chain_null_all(void)
1702 struct crypto_testsuite_params *ts_params = &testsuite_params;
1705 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1706 ts_params->op_mpool,
1707 ts_params->session_mpool, ts_params->session_priv_mpool,
1708 ts_params->valid_devs[0],
1709 rte_cryptodev_driver_id_get(
1710 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1711 BLKCIPHER_AES_CHAIN_TYPE);
1713 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1715 return TEST_SUCCESS;
1719 test_AES_cipheronly_null_all(void)
1721 struct crypto_testsuite_params *ts_params = &testsuite_params;
1724 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1725 ts_params->op_mpool,
1726 ts_params->session_mpool, ts_params->session_priv_mpool,
1727 ts_params->valid_devs[0],
1728 rte_cryptodev_driver_id_get(
1729 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1730 BLKCIPHER_AES_CIPHERONLY_TYPE);
1732 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1734 return TEST_SUCCESS;
1738 test_authonly_null_all(void)
1740 struct crypto_testsuite_params *ts_params = &testsuite_params;
1743 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1744 ts_params->op_mpool,
1745 ts_params->session_mpool, ts_params->session_priv_mpool,
1746 ts_params->valid_devs[0],
1747 rte_cryptodev_driver_id_get(
1748 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1749 BLKCIPHER_AUTHONLY_TYPE);
1751 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1753 return TEST_SUCCESS;
1757 test_AES_chain_mb_all(void)
1759 struct crypto_testsuite_params *ts_params = &testsuite_params;
1762 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1763 ts_params->op_mpool,
1764 ts_params->session_mpool, ts_params->session_priv_mpool,
1765 ts_params->valid_devs[0],
1766 rte_cryptodev_driver_id_get(
1767 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1768 BLKCIPHER_AES_CHAIN_TYPE);
1770 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1772 return TEST_SUCCESS;
1775 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1778 test_AES_cipheronly_scheduler_all(void)
1780 struct crypto_testsuite_params *ts_params = &testsuite_params;
1783 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1784 ts_params->op_mpool,
1785 ts_params->session_mpool, ts_params->session_priv_mpool,
1786 ts_params->valid_devs[0],
1787 rte_cryptodev_driver_id_get(
1788 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1789 BLKCIPHER_AES_CIPHERONLY_TYPE);
1791 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1793 return TEST_SUCCESS;
1797 test_AES_chain_scheduler_all(void)
1799 struct crypto_testsuite_params *ts_params = &testsuite_params;
1802 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1803 ts_params->op_mpool,
1804 ts_params->session_mpool, ts_params->session_priv_mpool,
1805 ts_params->valid_devs[0],
1806 rte_cryptodev_driver_id_get(
1807 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1808 BLKCIPHER_AES_CHAIN_TYPE);
1810 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1812 return TEST_SUCCESS;
1816 test_authonly_scheduler_all(void)
1818 struct crypto_testsuite_params *ts_params = &testsuite_params;
1821 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1822 ts_params->op_mpool,
1823 ts_params->session_mpool, ts_params->session_priv_mpool,
1824 ts_params->valid_devs[0],
1825 rte_cryptodev_driver_id_get(
1826 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1827 BLKCIPHER_AUTHONLY_TYPE);
1829 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1831 return TEST_SUCCESS;
1834 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1837 test_AES_chain_openssl_all(void)
1839 struct crypto_testsuite_params *ts_params = &testsuite_params;
1842 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1843 ts_params->op_mpool,
1844 ts_params->session_mpool, ts_params->session_priv_mpool,
1845 ts_params->valid_devs[0],
1846 rte_cryptodev_driver_id_get(
1847 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1848 BLKCIPHER_AES_CHAIN_TYPE);
1850 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1852 return TEST_SUCCESS;
1856 test_AES_cipheronly_openssl_all(void)
1858 struct crypto_testsuite_params *ts_params = &testsuite_params;
1861 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1862 ts_params->op_mpool,
1863 ts_params->session_mpool, ts_params->session_priv_mpool,
1864 ts_params->valid_devs[0],
1865 rte_cryptodev_driver_id_get(
1866 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1867 BLKCIPHER_AES_CIPHERONLY_TYPE);
1869 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1871 return TEST_SUCCESS;
1875 test_AES_chain_ccp_all(void)
1877 struct crypto_testsuite_params *ts_params = &testsuite_params;
1880 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1881 ts_params->op_mpool,
1882 ts_params->session_mpool, ts_params->session_priv_mpool,
1883 ts_params->valid_devs[0],
1884 rte_cryptodev_driver_id_get(
1885 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1886 BLKCIPHER_AES_CHAIN_TYPE);
1888 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1890 return TEST_SUCCESS;
1894 test_AES_cipheronly_ccp_all(void)
1896 struct crypto_testsuite_params *ts_params = &testsuite_params;
1899 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1900 ts_params->op_mpool,
1901 ts_params->session_mpool, ts_params->session_priv_mpool,
1902 ts_params->valid_devs[0],
1903 rte_cryptodev_driver_id_get(
1904 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1905 BLKCIPHER_AES_CIPHERONLY_TYPE);
1907 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1909 return TEST_SUCCESS;
1913 test_AES_chain_qat_all(void)
1915 struct crypto_testsuite_params *ts_params = &testsuite_params;
1918 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1919 ts_params->op_mpool,
1920 ts_params->session_mpool, ts_params->session_priv_mpool,
1921 ts_params->valid_devs[0],
1922 rte_cryptodev_driver_id_get(
1923 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1924 BLKCIPHER_AES_CHAIN_TYPE);
1926 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1928 return TEST_SUCCESS;
1932 test_AES_cipheronly_qat_all(void)
1934 struct crypto_testsuite_params *ts_params = &testsuite_params;
1937 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1938 ts_params->op_mpool,
1939 ts_params->session_mpool, ts_params->session_priv_mpool,
1940 ts_params->valid_devs[0],
1941 rte_cryptodev_driver_id_get(
1942 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1943 BLKCIPHER_AES_CIPHERONLY_TYPE);
1945 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1947 return TEST_SUCCESS;
1951 test_AES_cipheronly_virtio_all(void)
1953 struct crypto_testsuite_params *ts_params = &testsuite_params;
1956 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1957 ts_params->op_mpool,
1958 ts_params->session_mpool, ts_params->session_priv_mpool,
1959 ts_params->valid_devs[0],
1960 rte_cryptodev_driver_id_get(
1961 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)),
1962 BLKCIPHER_AES_CIPHERONLY_TYPE);
1964 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1966 return TEST_SUCCESS;
1970 test_AES_chain_caam_jr_all(void)
1972 struct crypto_testsuite_params *ts_params = &testsuite_params;
1975 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1976 ts_params->op_mpool,
1977 ts_params->session_mpool, ts_params->session_priv_mpool,
1978 ts_params->valid_devs[0],
1979 rte_cryptodev_driver_id_get(
1980 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
1981 BLKCIPHER_AES_CHAIN_TYPE);
1983 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1985 return TEST_SUCCESS;
1989 test_AES_cipheronly_caam_jr_all(void)
1991 struct crypto_testsuite_params *ts_params = &testsuite_params;
1994 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1995 ts_params->op_mpool,
1996 ts_params->session_mpool, ts_params->session_priv_mpool,
1997 ts_params->valid_devs[0],
1998 rte_cryptodev_driver_id_get(
1999 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
2000 BLKCIPHER_AES_CIPHERONLY_TYPE);
2002 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2004 return TEST_SUCCESS;
2008 test_authonly_caam_jr_all(void)
2010 struct crypto_testsuite_params *ts_params = &testsuite_params;
2013 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2014 ts_params->op_mpool,
2015 ts_params->session_mpool, ts_params->session_priv_mpool,
2016 ts_params->valid_devs[0],
2017 rte_cryptodev_driver_id_get(
2018 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
2019 BLKCIPHER_AUTHONLY_TYPE);
2021 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2023 return TEST_SUCCESS;
2028 test_AES_chain_dpaa_sec_all(void)
2030 struct crypto_testsuite_params *ts_params = &testsuite_params;
2033 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2034 ts_params->op_mpool,
2035 ts_params->session_mpool, ts_params->session_priv_mpool,
2036 ts_params->valid_devs[0],
2037 rte_cryptodev_driver_id_get(
2038 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2039 BLKCIPHER_AES_CHAIN_TYPE);
2041 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2043 return TEST_SUCCESS;
2047 test_AES_cipheronly_dpaa_sec_all(void)
2049 struct crypto_testsuite_params *ts_params = &testsuite_params;
2052 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2053 ts_params->op_mpool,
2054 ts_params->session_mpool, ts_params->session_priv_mpool,
2055 ts_params->valid_devs[0],
2056 rte_cryptodev_driver_id_get(
2057 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2058 BLKCIPHER_AES_CIPHERONLY_TYPE);
2060 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2062 return TEST_SUCCESS;
2066 test_authonly_dpaa_sec_all(void)
2068 struct crypto_testsuite_params *ts_params = &testsuite_params;
2071 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2072 ts_params->op_mpool,
2073 ts_params->session_mpool, ts_params->session_priv_mpool,
2074 ts_params->valid_devs[0],
2075 rte_cryptodev_driver_id_get(
2076 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2077 BLKCIPHER_AUTHONLY_TYPE);
2079 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2081 return TEST_SUCCESS;
2085 test_AES_chain_dpaa2_sec_all(void)
2087 struct crypto_testsuite_params *ts_params = &testsuite_params;
2090 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2091 ts_params->op_mpool,
2092 ts_params->session_mpool, ts_params->session_priv_mpool,
2093 ts_params->valid_devs[0],
2094 rte_cryptodev_driver_id_get(
2095 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2096 BLKCIPHER_AES_CHAIN_TYPE);
2098 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2100 return TEST_SUCCESS;
2104 test_AES_cipheronly_dpaa2_sec_all(void)
2106 struct crypto_testsuite_params *ts_params = &testsuite_params;
2109 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2110 ts_params->op_mpool,
2111 ts_params->session_mpool, ts_params->session_priv_mpool,
2112 ts_params->valid_devs[0],
2113 rte_cryptodev_driver_id_get(
2114 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2115 BLKCIPHER_AES_CIPHERONLY_TYPE);
2117 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2119 return TEST_SUCCESS;
2123 test_authonly_dpaa2_sec_all(void)
2125 struct crypto_testsuite_params *ts_params = &testsuite_params;
2128 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2129 ts_params->op_mpool,
2130 ts_params->session_mpool, ts_params->session_priv_mpool,
2131 ts_params->valid_devs[0],
2132 rte_cryptodev_driver_id_get(
2133 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2134 BLKCIPHER_AUTHONLY_TYPE);
2136 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2138 return TEST_SUCCESS;
2142 test_authonly_openssl_all(void)
2144 struct crypto_testsuite_params *ts_params = &testsuite_params;
2147 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2148 ts_params->op_mpool,
2149 ts_params->session_mpool, ts_params->session_priv_mpool,
2150 ts_params->valid_devs[0],
2151 rte_cryptodev_driver_id_get(
2152 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
2153 BLKCIPHER_AUTHONLY_TYPE);
2155 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2157 return TEST_SUCCESS;
2161 test_authonly_ccp_all(void)
2163 struct crypto_testsuite_params *ts_params = &testsuite_params;
2166 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2167 ts_params->op_mpool,
2168 ts_params->session_mpool, ts_params->session_priv_mpool,
2169 ts_params->valid_devs[0],
2170 rte_cryptodev_driver_id_get(
2171 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
2172 BLKCIPHER_AUTHONLY_TYPE);
2174 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2176 return TEST_SUCCESS;
2180 test_AES_chain_armv8_all(void)
2182 struct crypto_testsuite_params *ts_params = &testsuite_params;
2185 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2186 ts_params->op_mpool,
2187 ts_params->session_mpool, ts_params->session_priv_mpool,
2188 ts_params->valid_devs[0],
2189 rte_cryptodev_driver_id_get(
2190 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
2191 BLKCIPHER_AES_CHAIN_TYPE);
2193 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2195 return TEST_SUCCESS;
2199 test_AES_chain_mrvl_all(void)
2201 struct crypto_testsuite_params *ts_params = &testsuite_params;
2204 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2205 ts_params->op_mpool,
2206 ts_params->session_mpool, ts_params->session_priv_mpool,
2207 ts_params->valid_devs[0],
2208 rte_cryptodev_driver_id_get(
2209 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2210 BLKCIPHER_AES_CHAIN_TYPE);
2212 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2214 return TEST_SUCCESS;
2218 test_AES_cipheronly_mrvl_all(void)
2220 struct crypto_testsuite_params *ts_params = &testsuite_params;
2223 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2224 ts_params->op_mpool,
2225 ts_params->session_mpool, ts_params->session_priv_mpool,
2226 ts_params->valid_devs[0],
2227 rte_cryptodev_driver_id_get(
2228 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2229 BLKCIPHER_AES_CIPHERONLY_TYPE);
2231 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2233 return TEST_SUCCESS;
2237 test_authonly_mrvl_all(void)
2239 struct crypto_testsuite_params *ts_params = &testsuite_params;
2242 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2243 ts_params->op_mpool,
2244 ts_params->session_mpool, ts_params->session_priv_mpool,
2245 ts_params->valid_devs[0],
2246 rte_cryptodev_driver_id_get(
2247 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2248 BLKCIPHER_AUTHONLY_TYPE);
2250 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2252 return TEST_SUCCESS;
2256 test_3DES_chain_mrvl_all(void)
2258 struct crypto_testsuite_params *ts_params = &testsuite_params;
2261 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2262 ts_params->op_mpool,
2263 ts_params->session_mpool, ts_params->session_priv_mpool,
2264 ts_params->valid_devs[0],
2265 rte_cryptodev_driver_id_get(
2266 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2267 BLKCIPHER_3DES_CHAIN_TYPE);
2269 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2271 return TEST_SUCCESS;
2275 test_3DES_cipheronly_mrvl_all(void)
2277 struct crypto_testsuite_params *ts_params = &testsuite_params;
2280 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2281 ts_params->op_mpool,
2282 ts_params->session_mpool, ts_params->session_priv_mpool,
2283 ts_params->valid_devs[0],
2284 rte_cryptodev_driver_id_get(
2285 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2286 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2288 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2290 return TEST_SUCCESS;
2294 test_AES_chain_octeontx_all(void)
2296 struct crypto_testsuite_params *ts_params = &testsuite_params;
2299 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2300 ts_params->op_mpool, ts_params->session_mpool,
2301 ts_params->session_priv_mpool,
2302 ts_params->valid_devs[0],
2303 rte_cryptodev_driver_id_get(
2304 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2305 BLKCIPHER_AES_CHAIN_TYPE);
2307 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2309 return TEST_SUCCESS;
2313 test_AES_cipheronly_octeontx_all(void)
2315 struct crypto_testsuite_params *ts_params = &testsuite_params;
2318 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2319 ts_params->op_mpool, ts_params->session_mpool,
2320 ts_params->session_priv_mpool,
2321 ts_params->valid_devs[0],
2322 rte_cryptodev_driver_id_get(
2323 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2324 BLKCIPHER_AES_CIPHERONLY_TYPE);
2326 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2328 return TEST_SUCCESS;
2332 test_3DES_chain_octeontx_all(void)
2334 struct crypto_testsuite_params *ts_params = &testsuite_params;
2337 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2338 ts_params->op_mpool, ts_params->session_mpool,
2339 ts_params->session_priv_mpool,
2340 ts_params->valid_devs[0],
2341 rte_cryptodev_driver_id_get(
2342 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2343 BLKCIPHER_3DES_CHAIN_TYPE);
2345 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2347 return TEST_SUCCESS;
2351 test_3DES_cipheronly_octeontx_all(void)
2353 struct crypto_testsuite_params *ts_params = &testsuite_params;
2356 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2357 ts_params->op_mpool, ts_params->session_mpool,
2358 ts_params->session_priv_mpool,
2359 ts_params->valid_devs[0],
2360 rte_cryptodev_driver_id_get(
2361 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2362 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2364 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2366 return TEST_SUCCESS;
2370 test_authonly_octeontx_all(void)
2372 struct crypto_testsuite_params *ts_params = &testsuite_params;
2375 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2376 ts_params->op_mpool, ts_params->session_mpool,
2377 ts_params->session_priv_mpool,
2378 ts_params->valid_devs[0],
2379 rte_cryptodev_driver_id_get(
2380 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2381 BLKCIPHER_AUTHONLY_TYPE);
2383 TEST_ASSERT_EQUAL(status, 0, "Test failed");
2385 return TEST_SUCCESS;
2388 /* ***** SNOW 3G Tests ***** */
2390 create_wireless_algo_hash_session(uint8_t dev_id,
2391 const uint8_t *key, const uint8_t key_len,
2392 const uint8_t iv_len, const uint8_t auth_len,
2393 enum rte_crypto_auth_operation op,
2394 enum rte_crypto_auth_algorithm algo)
2396 uint8_t hash_key[key_len];
2399 struct crypto_testsuite_params *ts_params = &testsuite_params;
2400 struct crypto_unittest_params *ut_params = &unittest_params;
2402 memcpy(hash_key, key, key_len);
2404 debug_hexdump(stdout, "key:", key, key_len);
2406 /* Setup Authentication Parameters */
2407 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2408 ut_params->auth_xform.next = NULL;
2410 ut_params->auth_xform.auth.op = op;
2411 ut_params->auth_xform.auth.algo = algo;
2412 ut_params->auth_xform.auth.key.length = key_len;
2413 ut_params->auth_xform.auth.key.data = hash_key;
2414 ut_params->auth_xform.auth.digest_length = auth_len;
2415 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2416 ut_params->auth_xform.auth.iv.length = iv_len;
2417 ut_params->sess = rte_cryptodev_sym_session_create(
2418 ts_params->session_mpool);
2420 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2421 &ut_params->auth_xform,
2422 ts_params->session_priv_mpool);
2423 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2424 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2429 create_wireless_algo_cipher_session(uint8_t dev_id,
2430 enum rte_crypto_cipher_operation op,
2431 enum rte_crypto_cipher_algorithm algo,
2432 const uint8_t *key, const uint8_t key_len,
2435 uint8_t cipher_key[key_len];
2437 struct crypto_testsuite_params *ts_params = &testsuite_params;
2438 struct crypto_unittest_params *ut_params = &unittest_params;
2440 memcpy(cipher_key, key, key_len);
2442 /* Setup Cipher Parameters */
2443 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2444 ut_params->cipher_xform.next = NULL;
2446 ut_params->cipher_xform.cipher.algo = algo;
2447 ut_params->cipher_xform.cipher.op = op;
2448 ut_params->cipher_xform.cipher.key.data = cipher_key;
2449 ut_params->cipher_xform.cipher.key.length = key_len;
2450 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2451 ut_params->cipher_xform.cipher.iv.length = iv_len;
2453 debug_hexdump(stdout, "key:", key, key_len);
2455 /* Create Crypto session */
2456 ut_params->sess = rte_cryptodev_sym_session_create(
2457 ts_params->session_mpool);
2459 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2460 &ut_params->cipher_xform,
2461 ts_params->session_priv_mpool);
2462 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2463 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2468 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2469 unsigned int cipher_len,
2470 unsigned int cipher_offset)
2472 struct crypto_testsuite_params *ts_params = &testsuite_params;
2473 struct crypto_unittest_params *ut_params = &unittest_params;
2475 /* Generate Crypto op data structure */
2476 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2477 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2478 TEST_ASSERT_NOT_NULL(ut_params->op,
2479 "Failed to allocate pktmbuf offload");
2481 /* Set crypto operation data parameters */
2482 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2484 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2486 /* set crypto operation source mbuf */
2487 sym_op->m_src = ut_params->ibuf;
2490 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2492 sym_op->cipher.data.length = cipher_len;
2493 sym_op->cipher.data.offset = cipher_offset;
2498 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2499 unsigned int cipher_len,
2500 unsigned int cipher_offset)
2502 struct crypto_testsuite_params *ts_params = &testsuite_params;
2503 struct crypto_unittest_params *ut_params = &unittest_params;
2505 /* Generate Crypto op data structure */
2506 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2507 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2508 TEST_ASSERT_NOT_NULL(ut_params->op,
2509 "Failed to allocate pktmbuf offload");
2511 /* Set crypto operation data parameters */
2512 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2514 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2516 /* set crypto operation source mbuf */
2517 sym_op->m_src = ut_params->ibuf;
2518 sym_op->m_dst = ut_params->obuf;
2521 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2523 sym_op->cipher.data.length = cipher_len;
2524 sym_op->cipher.data.offset = cipher_offset;
2529 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2530 enum rte_crypto_cipher_operation cipher_op,
2531 enum rte_crypto_auth_operation auth_op,
2532 enum rte_crypto_auth_algorithm auth_algo,
2533 enum rte_crypto_cipher_algorithm cipher_algo,
2534 const uint8_t *key, uint8_t key_len,
2535 uint8_t auth_iv_len, uint8_t auth_len,
2536 uint8_t cipher_iv_len)
2539 uint8_t cipher_auth_key[key_len];
2542 struct crypto_testsuite_params *ts_params = &testsuite_params;
2543 struct crypto_unittest_params *ut_params = &unittest_params;
2545 memcpy(cipher_auth_key, key, key_len);
2547 /* Setup Authentication Parameters */
2548 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2549 ut_params->auth_xform.next = NULL;
2551 ut_params->auth_xform.auth.op = auth_op;
2552 ut_params->auth_xform.auth.algo = auth_algo;
2553 ut_params->auth_xform.auth.key.length = key_len;
2554 /* Hash key = cipher key */
2555 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2556 ut_params->auth_xform.auth.digest_length = auth_len;
2557 /* Auth IV will be after cipher IV */
2558 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2559 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2561 /* Setup Cipher Parameters */
2562 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2563 ut_params->cipher_xform.next = &ut_params->auth_xform;
2565 ut_params->cipher_xform.cipher.algo = cipher_algo;
2566 ut_params->cipher_xform.cipher.op = cipher_op;
2567 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2568 ut_params->cipher_xform.cipher.key.length = key_len;
2569 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2570 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2572 debug_hexdump(stdout, "key:", key, key_len);
2574 /* Create Crypto session*/
2575 ut_params->sess = rte_cryptodev_sym_session_create(
2576 ts_params->session_mpool);
2578 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2579 &ut_params->cipher_xform,
2580 ts_params->session_priv_mpool);
2582 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2583 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2588 create_wireless_cipher_auth_session(uint8_t dev_id,
2589 enum rte_crypto_cipher_operation cipher_op,
2590 enum rte_crypto_auth_operation auth_op,
2591 enum rte_crypto_auth_algorithm auth_algo,
2592 enum rte_crypto_cipher_algorithm cipher_algo,
2593 const struct wireless_test_data *tdata)
2595 const uint8_t key_len = tdata->key.len;
2596 uint8_t cipher_auth_key[key_len];
2599 struct crypto_testsuite_params *ts_params = &testsuite_params;
2600 struct crypto_unittest_params *ut_params = &unittest_params;
2601 const uint8_t *key = tdata->key.data;
2602 const uint8_t auth_len = tdata->digest.len;
2603 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2604 uint8_t auth_iv_len = tdata->auth_iv.len;
2606 memcpy(cipher_auth_key, key, key_len);
2608 /* Setup Authentication Parameters */
2609 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2610 ut_params->auth_xform.next = NULL;
2612 ut_params->auth_xform.auth.op = auth_op;
2613 ut_params->auth_xform.auth.algo = auth_algo;
2614 ut_params->auth_xform.auth.key.length = key_len;
2615 /* Hash key = cipher key */
2616 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2617 ut_params->auth_xform.auth.digest_length = auth_len;
2618 /* Auth IV will be after cipher IV */
2619 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2620 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2622 /* Setup Cipher Parameters */
2623 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2624 ut_params->cipher_xform.next = &ut_params->auth_xform;
2626 ut_params->cipher_xform.cipher.algo = cipher_algo;
2627 ut_params->cipher_xform.cipher.op = cipher_op;
2628 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2629 ut_params->cipher_xform.cipher.key.length = key_len;
2630 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2631 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2634 debug_hexdump(stdout, "key:", key, key_len);
2636 /* Create Crypto session*/
2637 ut_params->sess = rte_cryptodev_sym_session_create(
2638 ts_params->session_mpool);
2640 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2641 &ut_params->cipher_xform,
2642 ts_params->session_priv_mpool);
2644 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2645 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2650 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2651 const struct wireless_test_data *tdata)
2653 return create_wireless_cipher_auth_session(dev_id,
2654 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2655 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2656 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2660 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2661 enum rte_crypto_cipher_operation cipher_op,
2662 enum rte_crypto_auth_operation auth_op,
2663 enum rte_crypto_auth_algorithm auth_algo,
2664 enum rte_crypto_cipher_algorithm cipher_algo,
2665 const uint8_t *key, const uint8_t key_len,
2666 uint8_t auth_iv_len, uint8_t auth_len,
2667 uint8_t cipher_iv_len)
2669 uint8_t auth_cipher_key[key_len];
2671 struct crypto_testsuite_params *ts_params = &testsuite_params;
2672 struct crypto_unittest_params *ut_params = &unittest_params;
2674 memcpy(auth_cipher_key, key, key_len);
2676 /* Setup Authentication Parameters */
2677 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2678 ut_params->auth_xform.auth.op = auth_op;
2679 ut_params->auth_xform.next = &ut_params->cipher_xform;
2680 ut_params->auth_xform.auth.algo = auth_algo;
2681 ut_params->auth_xform.auth.key.length = key_len;
2682 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2683 ut_params->auth_xform.auth.digest_length = auth_len;
2684 /* Auth IV will be after cipher IV */
2685 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2686 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2688 /* Setup Cipher Parameters */
2689 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2690 ut_params->cipher_xform.next = NULL;
2691 ut_params->cipher_xform.cipher.algo = cipher_algo;
2692 ut_params->cipher_xform.cipher.op = cipher_op;
2693 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2694 ut_params->cipher_xform.cipher.key.length = key_len;
2695 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2696 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2698 debug_hexdump(stdout, "key:", key, key_len);
2700 /* Create Crypto session*/
2701 ut_params->sess = rte_cryptodev_sym_session_create(
2702 ts_params->session_mpool);
2704 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2705 &ut_params->auth_xform,
2706 ts_params->session_priv_mpool);
2707 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2708 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2714 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2715 unsigned int auth_tag_len,
2716 const uint8_t *iv, unsigned int iv_len,
2717 unsigned int data_pad_len,
2718 enum rte_crypto_auth_operation op,
2719 unsigned int auth_len, unsigned int auth_offset)
2721 struct crypto_testsuite_params *ts_params = &testsuite_params;
2723 struct crypto_unittest_params *ut_params = &unittest_params;
2725 /* Generate Crypto op data structure */
2726 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2727 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2728 TEST_ASSERT_NOT_NULL(ut_params->op,
2729 "Failed to allocate pktmbuf offload");
2731 /* Set crypto operation data parameters */
2732 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2734 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2736 /* set crypto operation source mbuf */
2737 sym_op->m_src = ut_params->ibuf;
2740 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2743 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2744 ut_params->ibuf, auth_tag_len);
2746 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2747 "no room to append auth tag");
2748 ut_params->digest = sym_op->auth.digest.data;
2749 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2750 ut_params->ibuf, data_pad_len);
2751 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2752 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2754 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2756 debug_hexdump(stdout, "digest:",
2757 sym_op->auth.digest.data,
2760 sym_op->auth.data.length = auth_len;
2761 sym_op->auth.data.offset = auth_offset;
2767 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2768 enum rte_crypto_auth_operation op)
2770 struct crypto_testsuite_params *ts_params = &testsuite_params;
2771 struct crypto_unittest_params *ut_params = &unittest_params;
2773 const uint8_t *auth_tag = tdata->digest.data;
2774 const unsigned int auth_tag_len = tdata->digest.len;
2775 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2776 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2778 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2779 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2780 const uint8_t *auth_iv = tdata->auth_iv.data;
2781 const uint8_t auth_iv_len = tdata->auth_iv.len;
2782 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2783 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2785 /* Generate Crypto op data structure */
2786 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2787 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2788 TEST_ASSERT_NOT_NULL(ut_params->op,
2789 "Failed to allocate pktmbuf offload");
2790 /* Set crypto operation data parameters */
2791 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2793 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2795 /* set crypto operation source mbuf */
2796 sym_op->m_src = ut_params->ibuf;
2799 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2800 ut_params->ibuf, auth_tag_len);
2802 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2803 "no room to append auth tag");
2804 ut_params->digest = sym_op->auth.digest.data;
2805 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2806 ut_params->ibuf, data_pad_len);
2807 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2808 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2810 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2812 debug_hexdump(stdout, "digest:",
2813 sym_op->auth.digest.data,
2816 /* Copy cipher and auth IVs at the end of the crypto operation */
2817 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2819 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2820 iv_ptr += cipher_iv_len;
2821 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2823 sym_op->cipher.data.length = cipher_len;
2824 sym_op->cipher.data.offset = 0;
2825 sym_op->auth.data.length = auth_len;
2826 sym_op->auth.data.offset = 0;
2832 create_zuc_cipher_hash_generate_operation(
2833 const struct wireless_test_data *tdata)
2835 return create_wireless_cipher_hash_operation(tdata,
2836 RTE_CRYPTO_AUTH_OP_GENERATE);
2840 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2841 const unsigned auth_tag_len,
2842 const uint8_t *auth_iv, uint8_t auth_iv_len,
2843 unsigned data_pad_len,
2844 enum rte_crypto_auth_operation op,
2845 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2846 const unsigned cipher_len, const unsigned cipher_offset,
2847 const unsigned auth_len, const unsigned auth_offset)
2849 struct crypto_testsuite_params *ts_params = &testsuite_params;
2850 struct crypto_unittest_params *ut_params = &unittest_params;
2852 /* Generate Crypto op data structure */
2853 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2854 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2855 TEST_ASSERT_NOT_NULL(ut_params->op,
2856 "Failed to allocate pktmbuf offload");
2857 /* Set crypto operation data parameters */
2858 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2860 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2862 /* set crypto operation source mbuf */
2863 sym_op->m_src = ut_params->ibuf;
2866 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2867 ut_params->ibuf, auth_tag_len);
2869 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2870 "no room to append auth tag");
2871 ut_params->digest = sym_op->auth.digest.data;
2872 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2873 ut_params->ibuf, data_pad_len);
2874 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2875 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2877 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2879 debug_hexdump(stdout, "digest:",
2880 sym_op->auth.digest.data,
2883 /* Copy cipher and auth IVs at the end of the crypto operation */
2884 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2886 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2887 iv_ptr += cipher_iv_len;
2888 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2890 sym_op->cipher.data.length = cipher_len;
2891 sym_op->cipher.data.offset = cipher_offset;
2892 sym_op->auth.data.length = auth_len;
2893 sym_op->auth.data.offset = auth_offset;
2899 create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
2900 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2901 const uint8_t *auth_iv, uint8_t auth_iv_len,
2902 unsigned int data_pad_len,
2903 unsigned int cipher_len, unsigned int cipher_offset,
2904 unsigned int auth_len, unsigned int auth_offset,
2905 uint8_t op_mode, uint8_t do_sgl)
2907 struct crypto_testsuite_params *ts_params = &testsuite_params;
2908 struct crypto_unittest_params *ut_params = &unittest_params;
2910 /* Generate Crypto op data structure */
2911 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2912 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2913 TEST_ASSERT_NOT_NULL(ut_params->op,
2914 "Failed to allocate pktmbuf offload");
2916 /* Set crypto operation data parameters */
2917 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2919 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2921 /* set crypto operation mbufs */
2922 sym_op->m_src = ut_params->ibuf;
2923 if (op_mode == OUT_OF_PLACE)
2924 sym_op->m_dst = ut_params->obuf;
2928 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2929 (op_mode == IN_PLACE ?
2930 ut_params->ibuf : ut_params->obuf),
2931 uint8_t *, data_pad_len);
2932 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2933 (op_mode == IN_PLACE ?
2934 ut_params->ibuf : ut_params->obuf),
2936 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2938 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2939 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2940 sym_op->m_src : sym_op->m_dst);
2941 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2942 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2943 sgl_buf = sgl_buf->next;
2945 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2946 uint8_t *, remaining_off);
2947 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2949 memset(sym_op->auth.digest.data, 0, remaining_off);
2950 while (sgl_buf->next != NULL) {
2951 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2952 0, rte_pktmbuf_data_len(sgl_buf));
2953 sgl_buf = sgl_buf->next;
2957 /* Copy cipher and auth IVs at the end of the crypto operation */
2958 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2959 ut_params->op, uint8_t *, IV_OFFSET);
2961 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2962 iv_ptr += cipher_iv_len;
2963 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2965 sym_op->cipher.data.length = cipher_len;
2966 sym_op->cipher.data.offset = cipher_offset;
2968 sym_op->auth.data.length = auth_len;
2969 sym_op->auth.data.offset = auth_offset;
2975 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2977 struct crypto_testsuite_params *ts_params = &testsuite_params;
2978 struct crypto_unittest_params *ut_params = &unittest_params;
2981 unsigned plaintext_pad_len;
2982 unsigned plaintext_len;
2985 /* Create SNOW 3G session */
2986 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2987 tdata->key.data, tdata->key.len,
2988 tdata->auth_iv.len, tdata->digest.len,
2989 RTE_CRYPTO_AUTH_OP_GENERATE,
2990 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2994 /* alloc mbuf and set payload */
2995 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2997 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2998 rte_pktmbuf_tailroom(ut_params->ibuf));
3000 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3001 /* Append data which is padded to a multiple of */
3002 /* the algorithms block size */
3003 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3004 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3006 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3008 /* Create SNOW 3G operation */
3009 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3010 tdata->auth_iv.data, tdata->auth_iv.len,
3011 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3012 tdata->validAuthLenInBits.len,
3017 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3019 ut_params->obuf = ut_params->op->sym->m_src;
3020 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3021 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3022 + plaintext_pad_len;
3025 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3028 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3029 "SNOW 3G Generated auth tag not as expected");
3035 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3037 struct crypto_testsuite_params *ts_params = &testsuite_params;
3038 struct crypto_unittest_params *ut_params = &unittest_params;
3041 unsigned plaintext_pad_len;
3042 unsigned plaintext_len;
3045 /* Create SNOW 3G session */
3046 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3047 tdata->key.data, tdata->key.len,
3048 tdata->auth_iv.len, tdata->digest.len,
3049 RTE_CRYPTO_AUTH_OP_VERIFY,
3050 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3053 /* alloc mbuf and set payload */
3054 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3056 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3057 rte_pktmbuf_tailroom(ut_params->ibuf));
3059 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3060 /* Append data which is padded to a multiple of */
3061 /* the algorithms block size */
3062 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3063 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3065 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3067 /* Create SNOW 3G operation */
3068 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3070 tdata->auth_iv.data, tdata->auth_iv.len,
3072 RTE_CRYPTO_AUTH_OP_VERIFY,
3073 tdata->validAuthLenInBits.len,
3078 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3080 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3081 ut_params->obuf = ut_params->op->sym->m_src;
3082 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3083 + plaintext_pad_len;
3086 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3095 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3097 struct crypto_testsuite_params *ts_params = &testsuite_params;
3098 struct crypto_unittest_params *ut_params = &unittest_params;
3101 unsigned plaintext_pad_len;
3102 unsigned plaintext_len;
3105 /* Create KASUMI session */
3106 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3107 tdata->key.data, tdata->key.len,
3108 0, tdata->digest.len,
3109 RTE_CRYPTO_AUTH_OP_GENERATE,
3110 RTE_CRYPTO_AUTH_KASUMI_F9);
3114 /* alloc mbuf and set payload */
3115 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3117 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3118 rte_pktmbuf_tailroom(ut_params->ibuf));
3120 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3121 /* Append data which is padded to a multiple of */
3122 /* the algorithms block size */
3123 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3124 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3126 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3128 /* Create KASUMI operation */
3129 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3131 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3132 tdata->plaintext.len,
3137 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3139 ut_params->obuf = ut_params->op->sym->m_src;
3140 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3141 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3142 + plaintext_pad_len;
3145 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3148 DIGEST_BYTE_LENGTH_KASUMI_F9,
3149 "KASUMI Generated auth tag not as expected");
3155 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3157 struct crypto_testsuite_params *ts_params = &testsuite_params;
3158 struct crypto_unittest_params *ut_params = &unittest_params;
3161 unsigned plaintext_pad_len;
3162 unsigned plaintext_len;
3165 /* Create KASUMI session */
3166 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3167 tdata->key.data, tdata->key.len,
3168 0, tdata->digest.len,
3169 RTE_CRYPTO_AUTH_OP_VERIFY,
3170 RTE_CRYPTO_AUTH_KASUMI_F9);
3173 /* alloc mbuf and set payload */
3174 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3176 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3177 rte_pktmbuf_tailroom(ut_params->ibuf));
3179 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3180 /* Append data which is padded to a multiple */
3181 /* of the algorithms block size */
3182 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3183 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3185 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3187 /* Create KASUMI operation */
3188 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3192 RTE_CRYPTO_AUTH_OP_VERIFY,
3193 tdata->plaintext.len,
3198 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3200 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3201 ut_params->obuf = ut_params->op->sym->m_src;
3202 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3203 + plaintext_pad_len;
3206 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3215 test_snow3g_hash_generate_test_case_1(void)
3217 return test_snow3g_authentication(&snow3g_hash_test_case_1);
3221 test_snow3g_hash_generate_test_case_2(void)
3223 return test_snow3g_authentication(&snow3g_hash_test_case_2);
3227 test_snow3g_hash_generate_test_case_3(void)
3229 return test_snow3g_authentication(&snow3g_hash_test_case_3);
3233 test_snow3g_hash_generate_test_case_4(void)
3235 return test_snow3g_authentication(&snow3g_hash_test_case_4);
3239 test_snow3g_hash_generate_test_case_5(void)
3241 return test_snow3g_authentication(&snow3g_hash_test_case_5);
3245 test_snow3g_hash_generate_test_case_6(void)
3247 return test_snow3g_authentication(&snow3g_hash_test_case_6);
3251 test_snow3g_hash_verify_test_case_1(void)
3253 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3258 test_snow3g_hash_verify_test_case_2(void)
3260 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3264 test_snow3g_hash_verify_test_case_3(void)
3266 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3270 test_snow3g_hash_verify_test_case_4(void)
3272 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3276 test_snow3g_hash_verify_test_case_5(void)
3278 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3282 test_snow3g_hash_verify_test_case_6(void)
3284 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3288 test_kasumi_hash_generate_test_case_1(void)
3290 return test_kasumi_authentication(&kasumi_hash_test_case_1);
3294 test_kasumi_hash_generate_test_case_2(void)
3296 return test_kasumi_authentication(&kasumi_hash_test_case_2);
3300 test_kasumi_hash_generate_test_case_3(void)
3302 return test_kasumi_authentication(&kasumi_hash_test_case_3);
3306 test_kasumi_hash_generate_test_case_4(void)
3308 return test_kasumi_authentication(&kasumi_hash_test_case_4);
3312 test_kasumi_hash_generate_test_case_5(void)
3314 return test_kasumi_authentication(&kasumi_hash_test_case_5);
3318 test_kasumi_hash_generate_test_case_6(void)
3320 return test_kasumi_authentication(&kasumi_hash_test_case_6);
3324 test_kasumi_hash_verify_test_case_1(void)
3326 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3330 test_kasumi_hash_verify_test_case_2(void)
3332 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3336 test_kasumi_hash_verify_test_case_3(void)
3338 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3342 test_kasumi_hash_verify_test_case_4(void)
3344 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3348 test_kasumi_hash_verify_test_case_5(void)
3350 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3354 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3356 struct crypto_testsuite_params *ts_params = &testsuite_params;
3357 struct crypto_unittest_params *ut_params = &unittest_params;
3360 uint8_t *plaintext, *ciphertext;
3361 unsigned plaintext_pad_len;
3362 unsigned plaintext_len;
3364 /* Create KASUMI session */
3365 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3366 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3367 RTE_CRYPTO_CIPHER_KASUMI_F8,
3368 tdata->key.data, tdata->key.len,
3369 tdata->cipher_iv.len);
3373 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3375 /* Clear mbuf payload */
3376 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3377 rte_pktmbuf_tailroom(ut_params->ibuf));
3379 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3380 /* Append data which is padded to a multiple */
3381 /* of the algorithms block size */
3382 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3383 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3385 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3387 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3389 /* Create KASUMI operation */
3390 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3391 tdata->cipher_iv.len,
3392 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3393 tdata->validCipherOffsetInBits.len);
3397 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3399 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3401 ut_params->obuf = ut_params->op->sym->m_dst;
3402 if (ut_params->obuf)
3403 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3405 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3407 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3409 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3410 (tdata->validCipherOffsetInBits.len >> 3);
3412 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3414 reference_ciphertext,
3415 tdata->validCipherLenInBits.len,
3416 "KASUMI Ciphertext data not as expected");
3421 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3423 struct crypto_testsuite_params *ts_params = &testsuite_params;
3424 struct crypto_unittest_params *ut_params = &unittest_params;
3428 unsigned int plaintext_pad_len;
3429 unsigned int plaintext_len;
3431 uint8_t buffer[10000];
3432 const uint8_t *ciphertext;
3434 struct rte_cryptodev_info dev_info;
3436 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3438 uint64_t feat_flags = dev_info.feature_flags;
3440 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3441 printf("Device doesn't support in-place scatter-gather. "
3446 /* Create KASUMI session */
3447 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3448 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3449 RTE_CRYPTO_CIPHER_KASUMI_F8,
3450 tdata->key.data, tdata->key.len,
3451 tdata->cipher_iv.len);
3455 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3458 /* Append data which is padded to a multiple */
3459 /* of the algorithms block size */
3460 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3462 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3463 plaintext_pad_len, 10, 0);
3465 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3467 /* Create KASUMI operation */
3468 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3469 tdata->cipher_iv.len,
3470 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3471 tdata->validCipherOffsetInBits.len);
3475 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3477 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3479 ut_params->obuf = ut_params->op->sym->m_dst;
3481 if (ut_params->obuf)
3482 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3483 plaintext_len, buffer);
3485 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3486 tdata->validCipherOffsetInBits.len >> 3,
3487 plaintext_len, buffer);
3490 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3492 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3493 (tdata->validCipherOffsetInBits.len >> 3);
3495 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3497 reference_ciphertext,
3498 tdata->validCipherLenInBits.len,
3499 "KASUMI Ciphertext data not as expected");
3504 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3506 struct crypto_testsuite_params *ts_params = &testsuite_params;
3507 struct crypto_unittest_params *ut_params = &unittest_params;
3510 uint8_t *plaintext, *ciphertext;
3511 unsigned plaintext_pad_len;
3512 unsigned plaintext_len;
3514 /* Create KASUMI session */
3515 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3516 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3517 RTE_CRYPTO_CIPHER_KASUMI_F8,
3518 tdata->key.data, tdata->key.len,
3519 tdata->cipher_iv.len);
3523 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3524 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3526 /* Clear mbuf payload */
3527 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3528 rte_pktmbuf_tailroom(ut_params->ibuf));
3530 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3531 /* Append data which is padded to a multiple */
3532 /* of the algorithms block size */
3533 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3534 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3536 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3537 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3539 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3541 /* Create KASUMI operation */
3542 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3543 tdata->cipher_iv.len,
3544 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3545 tdata->validCipherOffsetInBits.len);
3549 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3551 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3553 ut_params->obuf = ut_params->op->sym->m_dst;
3554 if (ut_params->obuf)
3555 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3557 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3559 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3561 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3562 (tdata->validCipherOffsetInBits.len >> 3);
3564 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3566 reference_ciphertext,
3567 tdata->validCipherLenInBits.len,
3568 "KASUMI Ciphertext data not as expected");
3573 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3575 struct crypto_testsuite_params *ts_params = &testsuite_params;
3576 struct crypto_unittest_params *ut_params = &unittest_params;
3579 unsigned int plaintext_pad_len;
3580 unsigned int plaintext_len;
3582 const uint8_t *ciphertext;
3583 uint8_t buffer[2048];
3585 struct rte_cryptodev_info dev_info;
3587 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3589 uint64_t feat_flags = dev_info.feature_flags;
3590 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3591 printf("Device doesn't support out-of-place scatter-gather "
3592 "in both input and output mbufs. "
3597 /* Create KASUMI session */
3598 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3599 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3600 RTE_CRYPTO_CIPHER_KASUMI_F8,
3601 tdata->key.data, tdata->key.len,
3602 tdata->cipher_iv.len);
3606 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3607 /* Append data which is padded to a multiple */
3608 /* of the algorithms block size */
3609 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3611 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3612 plaintext_pad_len, 10, 0);
3613 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3614 plaintext_pad_len, 3, 0);
3616 /* Append data which is padded to a multiple */
3617 /* of the algorithms block size */
3618 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3620 /* Create KASUMI operation */
3621 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3622 tdata->cipher_iv.len,
3623 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3624 tdata->validCipherOffsetInBits.len);
3628 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3630 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3632 ut_params->obuf = ut_params->op->sym->m_dst;
3633 if (ut_params->obuf)
3634 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3635 plaintext_pad_len, buffer);
3637 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3638 tdata->validCipherOffsetInBits.len >> 3,
3639 plaintext_pad_len, buffer);
3641 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3642 (tdata->validCipherOffsetInBits.len >> 3);
3644 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3646 reference_ciphertext,
3647 tdata->validCipherLenInBits.len,
3648 "KASUMI Ciphertext data not as expected");
3654 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3656 struct crypto_testsuite_params *ts_params = &testsuite_params;
3657 struct crypto_unittest_params *ut_params = &unittest_params;
3660 uint8_t *ciphertext, *plaintext;
3661 unsigned ciphertext_pad_len;
3662 unsigned ciphertext_len;
3664 /* Create KASUMI session */
3665 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3666 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3667 RTE_CRYPTO_CIPHER_KASUMI_F8,
3668 tdata->key.data, tdata->key.len,
3669 tdata->cipher_iv.len);
3673 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3674 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3676 /* Clear mbuf payload */
3677 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3678 rte_pktmbuf_tailroom(ut_params->ibuf));
3680 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3681 /* Append data which is padded to a multiple */
3682 /* of the algorithms block size */
3683 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3684 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3685 ciphertext_pad_len);
3686 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3687 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3689 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3691 /* Create KASUMI operation */
3692 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3693 tdata->cipher_iv.len,
3694 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3695 tdata->validCipherOffsetInBits.len);
3699 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3701 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3703 ut_params->obuf = ut_params->op->sym->m_dst;
3704 if (ut_params->obuf)
3705 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3707 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3709 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3711 const uint8_t *reference_plaintext = tdata->plaintext.data +
3712 (tdata->validCipherOffsetInBits.len >> 3);
3714 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3716 reference_plaintext,
3717 tdata->validCipherLenInBits.len,
3718 "KASUMI Plaintext data not as expected");
3723 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3725 struct crypto_testsuite_params *ts_params = &testsuite_params;
3726 struct crypto_unittest_params *ut_params = &unittest_params;
3729 uint8_t *ciphertext, *plaintext;
3730 unsigned ciphertext_pad_len;
3731 unsigned ciphertext_len;
3733 /* Create KASUMI session */
3734 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3735 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3736 RTE_CRYPTO_CIPHER_KASUMI_F8,
3737 tdata->key.data, tdata->key.len,
3738 tdata->cipher_iv.len);
3742 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3744 /* Clear mbuf payload */
3745 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3746 rte_pktmbuf_tailroom(ut_params->ibuf));
3748 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3749 /* Append data which is padded to a multiple */
3750 /* of the algorithms block size */
3751 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3752 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3753 ciphertext_pad_len);
3754 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3756 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3758 /* Create KASUMI operation */
3759 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760 tdata->cipher_iv.len,
3761 tdata->ciphertext.len,
3762 tdata->validCipherOffsetInBits.len);
3766 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3768 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3770 ut_params->obuf = ut_params->op->sym->m_dst;
3771 if (ut_params->obuf)
3772 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3774 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3776 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3778 const uint8_t *reference_plaintext = tdata->plaintext.data +
3779 (tdata->validCipherOffsetInBits.len >> 3);
3781 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3783 reference_plaintext,
3784 tdata->validCipherLenInBits.len,
3785 "KASUMI Plaintext data not as expected");
3790 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3792 struct crypto_testsuite_params *ts_params = &testsuite_params;
3793 struct crypto_unittest_params *ut_params = &unittest_params;
3796 uint8_t *plaintext, *ciphertext;
3797 unsigned plaintext_pad_len;
3798 unsigned plaintext_len;
3800 /* Create SNOW 3G session */
3801 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3802 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3803 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3804 tdata->key.data, tdata->key.len,
3805 tdata->cipher_iv.len);
3809 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3811 /* Clear mbuf payload */
3812 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3813 rte_pktmbuf_tailroom(ut_params->ibuf));
3815 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3816 /* Append data which is padded to a multiple of */
3817 /* the algorithms block size */
3818 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3819 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3821 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3823 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3825 /* Create SNOW 3G operation */
3826 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3827 tdata->cipher_iv.len,
3828 tdata->validCipherLenInBits.len,
3833 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3835 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3837 ut_params->obuf = ut_params->op->sym->m_dst;
3838 if (ut_params->obuf)
3839 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3841 ciphertext = plaintext;
3843 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3846 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3848 tdata->ciphertext.data,
3849 tdata->validDataLenInBits.len,
3850 "SNOW 3G Ciphertext data not as expected");
3856 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3858 struct crypto_testsuite_params *ts_params = &testsuite_params;
3859 struct crypto_unittest_params *ut_params = &unittest_params;
3860 uint8_t *plaintext, *ciphertext;
3863 unsigned plaintext_pad_len;
3864 unsigned plaintext_len;
3866 /* Create SNOW 3G session */
3867 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3868 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3869 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3870 tdata->key.data, tdata->key.len,
3871 tdata->cipher_iv.len);
3875 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3876 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3878 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3879 "Failed to allocate input buffer in mempool");
3880 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3881 "Failed to allocate output buffer in mempool");
3883 /* Clear mbuf payload */
3884 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3885 rte_pktmbuf_tailroom(ut_params->ibuf));
3887 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3888 /* Append data which is padded to a multiple of */
3889 /* the algorithms block size */
3890 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3891 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3893 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3894 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3896 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3898 /* Create SNOW 3G operation */
3899 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3900 tdata->cipher_iv.len,
3901 tdata->validCipherLenInBits.len,
3906 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3908 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3910 ut_params->obuf = ut_params->op->sym->m_dst;
3911 if (ut_params->obuf)
3912 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3914 ciphertext = plaintext;
3916 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3919 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3921 tdata->ciphertext.data,
3922 tdata->validDataLenInBits.len,
3923 "SNOW 3G Ciphertext data not as expected");
3928 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3930 struct crypto_testsuite_params *ts_params = &testsuite_params;
3931 struct crypto_unittest_params *ut_params = &unittest_params;
3934 unsigned int plaintext_pad_len;
3935 unsigned int plaintext_len;
3936 uint8_t buffer[10000];
3937 const uint8_t *ciphertext;
3939 struct rte_cryptodev_info dev_info;
3941 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3943 uint64_t feat_flags = dev_info.feature_flags;
3945 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3946 printf("Device doesn't support out-of-place scatter-gather "
3947 "in both input and output mbufs. "
3952 /* Create SNOW 3G session */
3953 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3954 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3955 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3956 tdata->key.data, tdata->key.len,
3957 tdata->cipher_iv.len);
3961 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3962 /* Append data which is padded to a multiple of */
3963 /* the algorithms block size */
3964 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3966 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3967 plaintext_pad_len, 10, 0);
3968 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3969 plaintext_pad_len, 3, 0);
3971 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3972 "Failed to allocate input buffer in mempool");
3973 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3974 "Failed to allocate output buffer in mempool");
3976 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3978 /* Create SNOW 3G operation */
3979 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3980 tdata->cipher_iv.len,
3981 tdata->validCipherLenInBits.len,
3986 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3988 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3990 ut_params->obuf = ut_params->op->sym->m_dst;
3991 if (ut_params->obuf)
3992 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3993 plaintext_len, buffer);
3995 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3996 plaintext_len, buffer);
3998 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4001 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4003 tdata->ciphertext.data,
4004 tdata->validDataLenInBits.len,
4005 "SNOW 3G Ciphertext data not as expected");
4010 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4012 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4014 uint8_t curr_byte, prev_byte;
4015 uint32_t length_in_bytes = ceil_byte_length(length + offset);
4016 uint8_t lower_byte_mask = (1 << offset) - 1;
4019 prev_byte = buffer[0];
4020 buffer[0] >>= offset;
4022 for (i = 1; i < length_in_bytes; i++) {
4023 curr_byte = buffer[i];
4024 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4025 (curr_byte >> offset);
4026 prev_byte = curr_byte;
4031 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4033 struct crypto_testsuite_params *ts_params = &testsuite_params;
4034 struct crypto_unittest_params *ut_params = &unittest_params;
4035 uint8_t *plaintext, *ciphertext;
4037 uint32_t plaintext_len;
4038 uint32_t plaintext_pad_len;
4039 uint8_t extra_offset = 4;
4040 uint8_t *expected_ciphertext_shifted;
4042 /* Create SNOW 3G session */
4043 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4044 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4045 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4046 tdata->key.data, tdata->key.len,
4047 tdata->cipher_iv.len);
4051 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4052 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4054 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4055 "Failed to allocate input buffer in mempool");
4056 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4057 "Failed to allocate output buffer in mempool");
4059 /* Clear mbuf payload */
4060 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4061 rte_pktmbuf_tailroom(ut_params->ibuf));
4063 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4065 * Append data which is padded to a
4066 * multiple of the algorithms block size
4068 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4070 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4073 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4075 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4076 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4078 #ifdef RTE_APP_TEST_DEBUG
4079 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4081 /* Create SNOW 3G operation */
4082 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4083 tdata->cipher_iv.len,
4084 tdata->validCipherLenInBits.len,
4089 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4091 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4093 ut_params->obuf = ut_params->op->sym->m_dst;
4094 if (ut_params->obuf)
4095 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4097 ciphertext = plaintext;
4099 #ifdef RTE_APP_TEST_DEBUG
4100 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4103 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4105 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4106 "failed to reserve memory for ciphertext shifted\n");
4108 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4109 ceil_byte_length(tdata->ciphertext.len));
4110 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4113 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4115 expected_ciphertext_shifted,
4116 tdata->validDataLenInBits.len,
4118 "SNOW 3G Ciphertext data not as expected");
4122 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4124 struct crypto_testsuite_params *ts_params = &testsuite_params;
4125 struct crypto_unittest_params *ut_params = &unittest_params;
4129 uint8_t *plaintext, *ciphertext;
4130 unsigned ciphertext_pad_len;
4131 unsigned ciphertext_len;
4133 /* Create SNOW 3G session */
4134 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4135 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4136 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4137 tdata->key.data, tdata->key.len,
4138 tdata->cipher_iv.len);
4142 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4144 /* Clear mbuf payload */
4145 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4146 rte_pktmbuf_tailroom(ut_params->ibuf));
4148 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4149 /* Append data which is padded to a multiple of */
4150 /* the algorithms block size */
4151 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4152 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4153 ciphertext_pad_len);
4154 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4156 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4158 /* Create SNOW 3G operation */
4159 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4160 tdata->cipher_iv.len,
4161 tdata->validCipherLenInBits.len,
4162 tdata->cipher.offset_bits);
4166 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4168 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4169 ut_params->obuf = ut_params->op->sym->m_dst;
4170 if (ut_params->obuf)
4171 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4173 plaintext = ciphertext;
4175 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4178 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4179 tdata->plaintext.data,
4180 tdata->validDataLenInBits.len,
4181 "SNOW 3G Plaintext data not as expected");
4185 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4187 struct crypto_testsuite_params *ts_params = &testsuite_params;
4188 struct crypto_unittest_params *ut_params = &unittest_params;
4192 uint8_t *plaintext, *ciphertext;
4193 unsigned ciphertext_pad_len;
4194 unsigned ciphertext_len;
4196 /* Create SNOW 3G session */
4197 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4198 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4199 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4200 tdata->key.data, tdata->key.len,
4201 tdata->cipher_iv.len);
4205 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4206 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4208 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4209 "Failed to allocate input buffer");
4210 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4211 "Failed to allocate output buffer");
4213 /* Clear mbuf payload */
4214 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4215 rte_pktmbuf_tailroom(ut_params->ibuf));
4217 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4218 rte_pktmbuf_tailroom(ut_params->obuf));
4220 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4221 /* Append data which is padded to a multiple of */
4222 /* the algorithms block size */
4223 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4224 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4225 ciphertext_pad_len);
4226 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4227 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4229 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4231 /* Create SNOW 3G operation */
4232 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4233 tdata->cipher_iv.len,
4234 tdata->validCipherLenInBits.len,
4239 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4241 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4242 ut_params->obuf = ut_params->op->sym->m_dst;
4243 if (ut_params->obuf)
4244 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4246 plaintext = ciphertext;
4248 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4251 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4252 tdata->plaintext.data,
4253 tdata->validDataLenInBits.len,
4254 "SNOW 3G Plaintext data not as expected");
4259 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4261 struct crypto_testsuite_params *ts_params = &testsuite_params;
4262 struct crypto_unittest_params *ut_params = &unittest_params;
4266 uint8_t *plaintext, *ciphertext;
4267 unsigned int plaintext_pad_len;
4268 unsigned int plaintext_len;
4270 struct rte_cryptodev_sym_capability_idx cap_idx;
4272 /* Check if device supports ZUC EEA3 */
4273 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4274 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4276 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4280 /* Check if device supports ZUC EIA3 */
4281 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4282 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4284 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4288 /* Create ZUC session */
4289 retval = create_zuc_cipher_auth_encrypt_generate_session(
4290 ts_params->valid_devs[0],
4294 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4296 /* clear mbuf payload */
4297 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4298 rte_pktmbuf_tailroom(ut_params->ibuf));
4300 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4301 /* Append data which is padded to a multiple of */
4302 /* the algorithms block size */
4303 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4304 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4306 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4308 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4310 /* Create ZUC operation */
4311 retval = create_zuc_cipher_hash_generate_operation(tdata);
4315 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4317 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4318 ut_params->obuf = ut_params->op->sym->m_src;
4319 if (ut_params->obuf)
4320 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4322 ciphertext = plaintext;
4324 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4326 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4328 tdata->ciphertext.data,
4329 tdata->validDataLenInBits.len,
4330 "ZUC Ciphertext data not as expected");
4332 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4333 + plaintext_pad_len;
4336 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4340 "ZUC Generated auth tag not as expected");
4345 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4347 struct crypto_testsuite_params *ts_params = &testsuite_params;
4348 struct crypto_unittest_params *ut_params = &unittest_params;
4352 uint8_t *plaintext, *ciphertext;
4353 unsigned plaintext_pad_len;
4354 unsigned plaintext_len;
4356 /* Create SNOW 3G session */
4357 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4358 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4359 RTE_CRYPTO_AUTH_OP_GENERATE,
4360 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4361 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4362 tdata->key.data, tdata->key.len,
4363 tdata->auth_iv.len, tdata->digest.len,
4364 tdata->cipher_iv.len);
4367 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4369 /* clear mbuf payload */
4370 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4371 rte_pktmbuf_tailroom(ut_params->ibuf));
4373 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4374 /* Append data which is padded to a multiple of */
4375 /* the algorithms block size */
4376 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4377 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4379 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4381 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4383 /* Create SNOW 3G operation */
4384 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4385 tdata->digest.len, tdata->auth_iv.data,
4387 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4388 tdata->cipher_iv.data, tdata->cipher_iv.len,
4389 tdata->validCipherLenInBits.len,
4391 tdata->validAuthLenInBits.len,
4397 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4399 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4400 ut_params->obuf = ut_params->op->sym->m_src;
4401 if (ut_params->obuf)
4402 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4404 ciphertext = plaintext;
4406 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4408 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4410 tdata->ciphertext.data,
4411 tdata->validDataLenInBits.len,
4412 "SNOW 3G Ciphertext data not as expected");
4414 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4415 + plaintext_pad_len;
4418 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4421 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4422 "SNOW 3G Generated auth tag not as expected");
4427 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4428 uint8_t op_mode, uint8_t verify)
4430 struct crypto_testsuite_params *ts_params = &testsuite_params;
4431 struct crypto_unittest_params *ut_params = &unittest_params;
4435 uint8_t *plaintext = NULL, *ciphertext = NULL;
4436 unsigned int plaintext_pad_len;
4437 unsigned int plaintext_len;
4438 unsigned int ciphertext_pad_len;
4439 unsigned int ciphertext_len;
4441 struct rte_cryptodev_info dev_info;
4443 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4445 uint64_t feat_flags = dev_info.feature_flags;
4447 if (op_mode == OUT_OF_PLACE) {
4448 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4449 printf("Device doesn't support digest encrypted.\n");
4454 /* Create SNOW 3G session */
4455 retval = create_wireless_algo_auth_cipher_session(
4456 ts_params->valid_devs[0],
4457 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4458 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4459 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4460 : RTE_CRYPTO_AUTH_OP_GENERATE),
4461 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4462 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4463 tdata->key.data, tdata->key.len,
4464 tdata->auth_iv.len, tdata->digest.len,
4465 tdata->cipher_iv.len);
4470 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4471 if (op_mode == OUT_OF_PLACE)
4472 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4474 /* clear mbuf payload */
4475 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4476 rte_pktmbuf_tailroom(ut_params->ibuf));
4477 if (op_mode == OUT_OF_PLACE)
4478 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4479 rte_pktmbuf_tailroom(ut_params->obuf));
4481 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4482 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4483 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4484 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4487 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4488 ciphertext_pad_len);
4489 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4490 if (op_mode == OUT_OF_PLACE)
4491 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4492 debug_hexdump(stdout, "ciphertext:", ciphertext,
4495 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4497 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4498 if (op_mode == OUT_OF_PLACE)
4499 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4500 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4503 /* Create SNOW 3G operation */
4504 retval = create_wireless_algo_auth_cipher_operation(
4506 tdata->cipher_iv.data, tdata->cipher_iv.len,
4507 tdata->auth_iv.data, tdata->auth_iv.len,
4508 (tdata->digest.offset_bytes == 0 ?
4509 (verify ? ciphertext_pad_len : plaintext_pad_len)
4510 : tdata->digest.offset_bytes),
4511 tdata->validCipherLenInBits.len,
4512 tdata->cipher.offset_bits,
4513 tdata->validAuthLenInBits.len,
4514 tdata->auth.offset_bits,
4520 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4523 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4525 ut_params->obuf = (op_mode == IN_PLACE ?
4526 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4529 if (ut_params->obuf)
4530 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4533 plaintext = ciphertext +
4534 (tdata->cipher.offset_bits >> 3);
4536 debug_hexdump(stdout, "plaintext:", plaintext,
4537 (tdata->plaintext.len >> 3) - tdata->digest.len);
4538 debug_hexdump(stdout, "plaintext expected:",
4539 tdata->plaintext.data,
4540 (tdata->plaintext.len >> 3) - tdata->digest.len);
4542 if (ut_params->obuf)
4543 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4546 ciphertext = plaintext;
4548 debug_hexdump(stdout, "ciphertext:", ciphertext,
4550 debug_hexdump(stdout, "ciphertext expected:",
4551 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4553 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4554 + (tdata->digest.offset_bytes == 0 ?
4555 plaintext_pad_len : tdata->digest.offset_bytes);
4557 debug_hexdump(stdout, "digest:", ut_params->digest,
4559 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4565 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4567 tdata->plaintext.data,
4568 tdata->plaintext.len >> 3,
4569 "SNOW 3G Plaintext data not as expected");
4571 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4573 tdata->ciphertext.data,
4574 tdata->validDataLenInBits.len,
4575 "SNOW 3G Ciphertext data not as expected");
4577 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4580 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4581 "SNOW 3G Generated auth tag not as expected");
4587 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4588 uint8_t op_mode, uint8_t verify)
4590 struct crypto_testsuite_params *ts_params = &testsuite_params;
4591 struct crypto_unittest_params *ut_params = &unittest_params;
4595 const uint8_t *plaintext = NULL;
4596 const uint8_t *ciphertext = NULL;
4597 const uint8_t *digest = NULL;
4598 unsigned int plaintext_pad_len;
4599 unsigned int plaintext_len;
4600 unsigned int ciphertext_pad_len;
4601 unsigned int ciphertext_len;
4602 uint8_t buffer[10000];
4603 uint8_t digest_buffer[10000];
4605 struct rte_cryptodev_info dev_info;
4607 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4609 uint64_t feat_flags = dev_info.feature_flags;
4611 if (op_mode == IN_PLACE) {
4612 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4613 printf("Device doesn't support in-place scatter-gather "
4614 "in both input and output mbufs.\n");
4618 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4619 printf("Device doesn't support out-of-place scatter-gather "
4620 "in both input and output mbufs.\n");
4623 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4624 printf("Device doesn't support digest encrypted.\n");
4629 /* Create SNOW 3G session */
4630 retval = create_wireless_algo_auth_cipher_session(
4631 ts_params->valid_devs[0],
4632 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4633 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4634 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4635 : RTE_CRYPTO_AUTH_OP_GENERATE),
4636 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4637 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4638 tdata->key.data, tdata->key.len,
4639 tdata->auth_iv.len, tdata->digest.len,
4640 tdata->cipher_iv.len);
4645 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4646 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4647 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4648 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4650 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4651 plaintext_pad_len, 15, 0);
4652 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4653 "Failed to allocate input buffer in mempool");
4655 if (op_mode == OUT_OF_PLACE) {
4656 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4657 plaintext_pad_len, 15, 0);
4658 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4659 "Failed to allocate output buffer in mempool");
4663 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4664 tdata->ciphertext.data);
4665 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4666 ciphertext_len, buffer);
4667 debug_hexdump(stdout, "ciphertext:", ciphertext,
4670 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4671 tdata->plaintext.data);
4672 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4673 plaintext_len, buffer);
4674 debug_hexdump(stdout, "plaintext:", plaintext,
4677 memset(buffer, 0, sizeof(buffer));
4679 /* Create SNOW 3G operation */
4680 retval = create_wireless_algo_auth_cipher_operation(
4682 tdata->cipher_iv.data, tdata->cipher_iv.len,
4683 tdata->auth_iv.data, tdata->auth_iv.len,
4684 (tdata->digest.offset_bytes == 0 ?
4685 (verify ? ciphertext_pad_len : plaintext_pad_len)
4686 : tdata->digest.offset_bytes),
4687 tdata->validCipherLenInBits.len,
4688 tdata->cipher.offset_bits,
4689 tdata->validAuthLenInBits.len,
4690 tdata->auth.offset_bits,
4696 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4699 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4701 ut_params->obuf = (op_mode == IN_PLACE ?
4702 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4705 if (ut_params->obuf)
4706 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4707 plaintext_len, buffer);
4709 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4710 plaintext_len, buffer);
4712 debug_hexdump(stdout, "plaintext:", plaintext,
4713 (tdata->plaintext.len >> 3) - tdata->digest.len);
4714 debug_hexdump(stdout, "plaintext expected:",
4715 tdata->plaintext.data,
4716 (tdata->plaintext.len >> 3) - tdata->digest.len);
4718 if (ut_params->obuf)
4719 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4720 ciphertext_len, buffer);
4722 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4723 ciphertext_len, buffer);
4725 debug_hexdump(stdout, "ciphertext:", ciphertext,
4727 debug_hexdump(stdout, "ciphertext expected:",
4728 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4730 if (ut_params->obuf)
4731 digest = rte_pktmbuf_read(ut_params->obuf,
4732 (tdata->digest.offset_bytes == 0 ?
4733 plaintext_pad_len : tdata->digest.offset_bytes),
4734 tdata->digest.len, digest_buffer);
4736 digest = rte_pktmbuf_read(ut_params->ibuf,
4737 (tdata->digest.offset_bytes == 0 ?
4738 plaintext_pad_len : tdata->digest.offset_bytes),
4739 tdata->digest.len, digest_buffer);
4741 debug_hexdump(stdout, "digest:", digest,
4743 debug_hexdump(stdout, "digest expected:",
4744 tdata->digest.data, tdata->digest.len);
4749 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4751 tdata->plaintext.data,
4752 tdata->plaintext.len >> 3,
4753 "SNOW 3G Plaintext data not as expected");
4755 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4757 tdata->ciphertext.data,
4758 tdata->validDataLenInBits.len,
4759 "SNOW 3G Ciphertext data not as expected");
4761 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4764 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4765 "SNOW 3G Generated auth tag not as expected");
4771 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4772 uint8_t op_mode, uint8_t verify)
4774 struct crypto_testsuite_params *ts_params = &testsuite_params;
4775 struct crypto_unittest_params *ut_params = &unittest_params;
4779 uint8_t *plaintext = NULL, *ciphertext = NULL;
4780 unsigned int plaintext_pad_len;
4781 unsigned int plaintext_len;
4782 unsigned int ciphertext_pad_len;
4783 unsigned int ciphertext_len;
4785 struct rte_cryptodev_info dev_info;
4787 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4789 uint64_t feat_flags = dev_info.feature_flags;
4791 if (op_mode == OUT_OF_PLACE) {
4792 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4793 printf("Device doesn't support digest encrypted.\n");
4798 /* Create KASUMI session */
4799 retval = create_wireless_algo_auth_cipher_session(
4800 ts_params->valid_devs[0],
4801 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4802 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4803 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4804 : RTE_CRYPTO_AUTH_OP_GENERATE),
4805 RTE_CRYPTO_AUTH_KASUMI_F9,
4806 RTE_CRYPTO_CIPHER_KASUMI_F8,
4807 tdata->key.data, tdata->key.len,
4808 0, tdata->digest.len,
4809 tdata->cipher_iv.len);
4814 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4815 if (op_mode == OUT_OF_PLACE)
4816 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4818 /* clear mbuf payload */
4819 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4820 rte_pktmbuf_tailroom(ut_params->ibuf));
4821 if (op_mode == OUT_OF_PLACE)
4822 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4823 rte_pktmbuf_tailroom(ut_params->obuf));
4825 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4826 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4827 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4828 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4831 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4832 ciphertext_pad_len);
4833 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4834 if (op_mode == OUT_OF_PLACE)
4835 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4836 debug_hexdump(stdout, "ciphertext:", ciphertext,
4839 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4841 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4842 if (op_mode == OUT_OF_PLACE)
4843 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4844 debug_hexdump(stdout, "plaintext:", plaintext,
4848 /* Create KASUMI operation */
4849 retval = create_wireless_algo_auth_cipher_operation(
4851 tdata->cipher_iv.data, tdata->cipher_iv.len,
4853 (tdata->digest.offset_bytes == 0 ?
4854 (verify ? ciphertext_pad_len : plaintext_pad_len)
4855 : tdata->digest.offset_bytes),
4856 tdata->validCipherLenInBits.len,
4857 tdata->validCipherOffsetInBits.len,
4858 tdata->validAuthLenInBits.len,
4865 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4868 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4870 ut_params->obuf = (op_mode == IN_PLACE ?
4871 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4875 if (ut_params->obuf)
4876 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4879 plaintext = ciphertext;
4881 debug_hexdump(stdout, "plaintext:", plaintext,
4882 (tdata->plaintext.len >> 3) - tdata->digest.len);
4883 debug_hexdump(stdout, "plaintext expected:",
4884 tdata->plaintext.data,
4885 (tdata->plaintext.len >> 3) - tdata->digest.len);
4887 if (ut_params->obuf)
4888 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4891 ciphertext = plaintext;
4893 debug_hexdump(stdout, "ciphertext:", ciphertext,
4895 debug_hexdump(stdout, "ciphertext expected:",
4896 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4898 ut_params->digest = rte_pktmbuf_mtod(
4899 ut_params->obuf, uint8_t *) +
4900 (tdata->digest.offset_bytes == 0 ?
4901 plaintext_pad_len : tdata->digest.offset_bytes);
4903 debug_hexdump(stdout, "digest:", ut_params->digest,
4905 debug_hexdump(stdout, "digest expected:",
4906 tdata->digest.data, tdata->digest.len);
4911 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4913 tdata->plaintext.data,
4914 tdata->plaintext.len >> 3,
4915 "KASUMI Plaintext data not as expected");
4917 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4919 tdata->ciphertext.data,
4920 tdata->ciphertext.len >> 3,
4921 "KASUMI Ciphertext data not as expected");
4923 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4926 DIGEST_BYTE_LENGTH_KASUMI_F9,
4927 "KASUMI Generated auth tag not as expected");
4933 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
4934 uint8_t op_mode, uint8_t verify)
4936 struct crypto_testsuite_params *ts_params = &testsuite_params;
4937 struct crypto_unittest_params *ut_params = &unittest_params;
4941 const uint8_t *plaintext = NULL;
4942 const uint8_t *ciphertext = NULL;
4943 const uint8_t *digest = NULL;
4944 unsigned int plaintext_pad_len;
4945 unsigned int plaintext_len;
4946 unsigned int ciphertext_pad_len;
4947 unsigned int ciphertext_len;
4948 uint8_t buffer[10000];
4949 uint8_t digest_buffer[10000];
4951 struct rte_cryptodev_info dev_info;
4953 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4955 uint64_t feat_flags = dev_info.feature_flags;
4957 if (op_mode == IN_PLACE) {
4958 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4959 printf("Device doesn't support in-place scatter-gather "
4960 "in both input and output mbufs.\n");
4964 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4965 printf("Device doesn't support out-of-place scatter-gather "
4966 "in both input and output mbufs.\n");
4969 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4970 printf("Device doesn't support digest encrypted.\n");
4975 /* Create KASUMI session */
4976 retval = create_wireless_algo_auth_cipher_session(
4977 ts_params->valid_devs[0],
4978 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4979 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4980 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4981 : RTE_CRYPTO_AUTH_OP_GENERATE),
4982 RTE_CRYPTO_AUTH_KASUMI_F9,
4983 RTE_CRYPTO_CIPHER_KASUMI_F8,
4984 tdata->key.data, tdata->key.len,
4985 0, tdata->digest.len,
4986 tdata->cipher_iv.len);
4991 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4992 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4993 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4994 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4996 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4997 plaintext_pad_len, 15, 0);
4998 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4999 "Failed to allocate input buffer in mempool");
5001 if (op_mode == OUT_OF_PLACE) {
5002 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5003 plaintext_pad_len, 15, 0);
5004 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5005 "Failed to allocate output buffer in mempool");
5009 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5010 tdata->ciphertext.data);
5011 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5012 ciphertext_len, buffer);
5013 debug_hexdump(stdout, "ciphertext:", ciphertext,
5016 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5017 tdata->plaintext.data);
5018 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5019 plaintext_len, buffer);
5020 debug_hexdump(stdout, "plaintext:", plaintext,
5023 memset(buffer, 0, sizeof(buffer));
5025 /* Create KASUMI operation */
5026 retval = create_wireless_algo_auth_cipher_operation(
5028 tdata->cipher_iv.data, tdata->cipher_iv.len,
5030 (tdata->digest.offset_bytes == 0 ?
5031 (verify ? ciphertext_pad_len : plaintext_pad_len)
5032 : tdata->digest.offset_bytes),
5033 tdata->validCipherLenInBits.len,
5034 tdata->validCipherOffsetInBits.len,
5035 tdata->validAuthLenInBits.len,
5042 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5045 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5047 ut_params->obuf = (op_mode == IN_PLACE ?
5048 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5051 if (ut_params->obuf)
5052 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5053 plaintext_len, buffer);
5055 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5056 plaintext_len, buffer);
5058 debug_hexdump(stdout, "plaintext:", plaintext,
5059 (tdata->plaintext.len >> 3) - tdata->digest.len);
5060 debug_hexdump(stdout, "plaintext expected:",
5061 tdata->plaintext.data,
5062 (tdata->plaintext.len >> 3) - tdata->digest.len);
5064 if (ut_params->obuf)
5065 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5066 ciphertext_len, buffer);
5068 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5069 ciphertext_len, buffer);
5071 debug_hexdump(stdout, "ciphertext:", ciphertext,
5073 debug_hexdump(stdout, "ciphertext expected:",
5074 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5076 if (ut_params->obuf)
5077 digest = rte_pktmbuf_read(ut_params->obuf,
5078 (tdata->digest.offset_bytes == 0 ?
5079 plaintext_pad_len : tdata->digest.offset_bytes),
5080 tdata->digest.len, digest_buffer);
5082 digest = rte_pktmbuf_read(ut_params->ibuf,
5083 (tdata->digest.offset_bytes == 0 ?
5084 plaintext_pad_len : tdata->digest.offset_bytes),
5085 tdata->digest.len, digest_buffer);
5087 debug_hexdump(stdout, "digest:", digest,
5089 debug_hexdump(stdout, "digest expected:",
5090 tdata->digest.data, tdata->digest.len);
5095 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5097 tdata->plaintext.data,
5098 tdata->plaintext.len >> 3,
5099 "KASUMI Plaintext data not as expected");
5101 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5103 tdata->ciphertext.data,
5104 tdata->validDataLenInBits.len,
5105 "KASUMI Ciphertext data not as expected");
5107 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5110 DIGEST_BYTE_LENGTH_KASUMI_F9,
5111 "KASUMI Generated auth tag not as expected");
5117 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5119 struct crypto_testsuite_params *ts_params = &testsuite_params;
5120 struct crypto_unittest_params *ut_params = &unittest_params;
5124 uint8_t *plaintext, *ciphertext;
5125 unsigned plaintext_pad_len;
5126 unsigned plaintext_len;
5128 /* Create KASUMI session */
5129 retval = create_wireless_algo_cipher_auth_session(
5130 ts_params->valid_devs[0],
5131 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5132 RTE_CRYPTO_AUTH_OP_GENERATE,
5133 RTE_CRYPTO_AUTH_KASUMI_F9,
5134 RTE_CRYPTO_CIPHER_KASUMI_F8,
5135 tdata->key.data, tdata->key.len,
5136 0, tdata->digest.len,
5137 tdata->cipher_iv.len);
5141 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5143 /* clear mbuf payload */
5144 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5145 rte_pktmbuf_tailroom(ut_params->ibuf));
5147 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5148 /* Append data which is padded to a multiple of */
5149 /* the algorithms block size */
5150 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5151 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5153 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5155 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5157 /* Create KASUMI operation */
5158 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5159 tdata->digest.len, NULL, 0,
5160 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5161 tdata->cipher_iv.data, tdata->cipher_iv.len,
5162 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5163 tdata->validCipherOffsetInBits.len,
5164 tdata->validAuthLenInBits.len,
5170 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5172 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5174 if (ut_params->op->sym->m_dst)
5175 ut_params->obuf = ut_params->op->sym->m_dst;
5177 ut_params->obuf = ut_params->op->sym->m_src;
5179 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5180 tdata->validCipherOffsetInBits.len >> 3);
5182 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5183 + plaintext_pad_len;
5185 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5186 (tdata->validCipherOffsetInBits.len >> 3);
5188 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5190 reference_ciphertext,
5191 tdata->validCipherLenInBits.len,
5192 "KASUMI Ciphertext data not as expected");
5195 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5198 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5199 "KASUMI Generated auth tag not as expected");
5204 test_zuc_encryption(const struct wireless_test_data *tdata)
5206 struct crypto_testsuite_params *ts_params = &testsuite_params;
5207 struct crypto_unittest_params *ut_params = &unittest_params;
5210 uint8_t *plaintext, *ciphertext;
5211 unsigned plaintext_pad_len;
5212 unsigned plaintext_len;
5214 struct rte_cryptodev_sym_capability_idx cap_idx;
5216 /* Check if device supports ZUC EEA3 */
5217 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5218 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5220 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5224 /* Create ZUC session */
5225 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5226 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5227 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5228 tdata->key.data, tdata->key.len,
5229 tdata->cipher_iv.len);
5233 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5235 /* Clear mbuf payload */
5236 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5237 rte_pktmbuf_tailroom(ut_params->ibuf));
5239 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5240 /* Append data which is padded to a multiple */
5241 /* of the algorithms block size */
5242 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5243 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5245 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5247 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5249 /* Create ZUC operation */
5250 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5251 tdata->cipher_iv.len,
5252 tdata->plaintext.len,
5257 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5259 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5261 ut_params->obuf = ut_params->op->sym->m_dst;
5262 if (ut_params->obuf)
5263 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5265 ciphertext = plaintext;
5267 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5270 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5272 tdata->ciphertext.data,
5273 tdata->validCipherLenInBits.len,
5274 "ZUC Ciphertext data not as expected");
5279 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5281 struct crypto_testsuite_params *ts_params = &testsuite_params;
5282 struct crypto_unittest_params *ut_params = &unittest_params;
5286 unsigned int plaintext_pad_len;
5287 unsigned int plaintext_len;
5288 const uint8_t *ciphertext;
5289 uint8_t ciphertext_buffer[2048];
5290 struct rte_cryptodev_info dev_info;
5292 struct rte_cryptodev_sym_capability_idx cap_idx;
5294 /* Check if device supports ZUC EEA3 */
5295 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5296 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5298 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5302 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5304 uint64_t feat_flags = dev_info.feature_flags;
5306 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5307 printf("Device doesn't support in-place scatter-gather. "
5312 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5314 /* Append data which is padded to a multiple */
5315 /* of the algorithms block size */
5316 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5318 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5319 plaintext_pad_len, 10, 0);
5321 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5322 tdata->plaintext.data);
5324 /* Create ZUC session */
5325 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5326 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5327 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5328 tdata->key.data, tdata->key.len,
5329 tdata->cipher_iv.len);
5333 /* Clear mbuf payload */
5335 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5337 /* Create ZUC operation */
5338 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5339 tdata->cipher_iv.len, tdata->plaintext.len,
5344 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5346 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5348 ut_params->obuf = ut_params->op->sym->m_dst;
5349 if (ut_params->obuf)
5350 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5351 0, plaintext_len, ciphertext_buffer);
5353 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5354 0, plaintext_len, ciphertext_buffer);
5357 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5360 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5362 tdata->ciphertext.data,
5363 tdata->validCipherLenInBits.len,
5364 "ZUC Ciphertext data not as expected");
5370 test_zuc_authentication(const struct wireless_test_data *tdata)
5372 struct crypto_testsuite_params *ts_params = &testsuite_params;
5373 struct crypto_unittest_params *ut_params = &unittest_params;
5376 unsigned plaintext_pad_len;
5377 unsigned plaintext_len;
5380 struct rte_cryptodev_sym_capability_idx cap_idx;
5382 /* Check if device supports ZUC EIA3 */
5383 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5384 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5386 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5390 /* Create ZUC session */
5391 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5392 tdata->key.data, tdata->key.len,
5393 tdata->auth_iv.len, tdata->digest.len,
5394 RTE_CRYPTO_AUTH_OP_GENERATE,
5395 RTE_CRYPTO_AUTH_ZUC_EIA3);
5399 /* alloc mbuf and set payload */
5400 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5402 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5403 rte_pktmbuf_tailroom(ut_params->ibuf));
5405 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5406 /* Append data which is padded to a multiple of */
5407 /* the algorithms block size */
5408 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5409 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5411 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5413 /* Create ZUC operation */
5414 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5415 tdata->auth_iv.data, tdata->auth_iv.len,
5416 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5417 tdata->validAuthLenInBits.len,
5422 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5424 ut_params->obuf = ut_params->op->sym->m_src;
5425 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5426 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5427 + plaintext_pad_len;
5430 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5433 DIGEST_BYTE_LENGTH_KASUMI_F9,
5434 "ZUC Generated auth tag not as expected");
5440 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5441 uint8_t op_mode, uint8_t verify)
5443 struct crypto_testsuite_params *ts_params = &testsuite_params;
5444 struct crypto_unittest_params *ut_params = &unittest_params;
5448 uint8_t *plaintext = NULL, *ciphertext = NULL;
5449 unsigned int plaintext_pad_len;
5450 unsigned int plaintext_len;
5451 unsigned int ciphertext_pad_len;
5452 unsigned int ciphertext_len;
5454 struct rte_cryptodev_info dev_info;
5455 struct rte_cryptodev_sym_capability_idx cap_idx;
5457 /* Check if device supports ZUC EIA3 */
5458 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5459 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5461 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5465 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5467 uint64_t feat_flags = dev_info.feature_flags;
5469 if (op_mode == OUT_OF_PLACE) {
5470 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5471 printf("Device doesn't support digest encrypted.\n");
5476 /* Create ZUC session */
5477 retval = create_wireless_algo_auth_cipher_session(
5478 ts_params->valid_devs[0],
5479 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5480 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5481 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5482 : RTE_CRYPTO_AUTH_OP_GENERATE),
5483 RTE_CRYPTO_AUTH_ZUC_EIA3,
5484 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5485 tdata->key.data, tdata->key.len,
5486 tdata->auth_iv.len, tdata->digest.len,
5487 tdata->cipher_iv.len);
5492 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5493 if (op_mode == OUT_OF_PLACE)
5494 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5496 /* clear mbuf payload */
5497 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5498 rte_pktmbuf_tailroom(ut_params->ibuf));
5499 if (op_mode == OUT_OF_PLACE)
5500 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5501 rte_pktmbuf_tailroom(ut_params->obuf));
5503 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5504 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5505 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5506 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5509 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5510 ciphertext_pad_len);
5511 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5512 if (op_mode == OUT_OF_PLACE)
5513 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5514 debug_hexdump(stdout, "ciphertext:", ciphertext,
5517 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5519 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5520 if (op_mode == OUT_OF_PLACE)
5521 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5522 debug_hexdump(stdout, "plaintext:", plaintext,
5526 /* Create ZUC operation */
5527 retval = create_wireless_algo_auth_cipher_operation(
5529 tdata->cipher_iv.data, tdata->cipher_iv.len,
5530 tdata->auth_iv.data, tdata->auth_iv.len,
5531 (tdata->digest.offset_bytes == 0 ?
5532 (verify ? ciphertext_pad_len : plaintext_pad_len)
5533 : tdata->digest.offset_bytes),
5534 tdata->validCipherLenInBits.len,
5535 tdata->validCipherOffsetInBits.len,
5536 tdata->validAuthLenInBits.len,
5543 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5546 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5548 ut_params->obuf = (op_mode == IN_PLACE ?
5549 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5553 if (ut_params->obuf)
5554 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5557 plaintext = ciphertext;
5559 debug_hexdump(stdout, "plaintext:", plaintext,
5560 (tdata->plaintext.len >> 3) - tdata->digest.len);
5561 debug_hexdump(stdout, "plaintext expected:",
5562 tdata->plaintext.data,
5563 (tdata->plaintext.len >> 3) - tdata->digest.len);
5565 if (ut_params->obuf)
5566 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5569 ciphertext = plaintext;
5571 debug_hexdump(stdout, "ciphertext:", ciphertext,
5573 debug_hexdump(stdout, "ciphertext expected:",
5574 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5576 ut_params->digest = rte_pktmbuf_mtod(
5577 ut_params->obuf, uint8_t *) +
5578 (tdata->digest.offset_bytes == 0 ?
5579 plaintext_pad_len : tdata->digest.offset_bytes);
5581 debug_hexdump(stdout, "digest:", ut_params->digest,
5583 debug_hexdump(stdout, "digest expected:",
5584 tdata->digest.data, tdata->digest.len);
5589 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5591 tdata->plaintext.data,
5592 tdata->plaintext.len >> 3,
5593 "ZUC Plaintext data not as expected");
5595 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5597 tdata->ciphertext.data,
5598 tdata->ciphertext.len >> 3,
5599 "ZUC Ciphertext data not as expected");
5601 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5604 DIGEST_BYTE_LENGTH_KASUMI_F9,
5605 "ZUC Generated auth tag not as expected");
5611 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5612 uint8_t op_mode, uint8_t verify)
5614 struct crypto_testsuite_params *ts_params = &testsuite_params;
5615 struct crypto_unittest_params *ut_params = &unittest_params;
5619 const uint8_t *plaintext = NULL;
5620 const uint8_t *ciphertext = NULL;
5621 const uint8_t *digest = NULL;
5622 unsigned int plaintext_pad_len;
5623 unsigned int plaintext_len;
5624 unsigned int ciphertext_pad_len;
5625 unsigned int ciphertext_len;
5626 uint8_t buffer[10000];
5627 uint8_t digest_buffer[10000];
5629 struct rte_cryptodev_info dev_info;
5630 struct rte_cryptodev_sym_capability_idx cap_idx;
5632 /* Check if device supports ZUC EIA3 */
5633 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5634 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5636 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5640 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5642 uint64_t feat_flags = dev_info.feature_flags;
5644 if (op_mode == IN_PLACE) {
5645 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5646 printf("Device doesn't support in-place scatter-gather "
5647 "in both input and output mbufs.\n");
5651 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5652 printf("Device doesn't support out-of-place scatter-gather "
5653 "in both input and output mbufs.\n");
5656 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5657 printf("Device doesn't support digest encrypted.\n");
5662 /* Create ZUC session */
5663 retval = create_wireless_algo_auth_cipher_session(
5664 ts_params->valid_devs[0],
5665 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5666 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5667 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5668 : RTE_CRYPTO_AUTH_OP_GENERATE),
5669 RTE_CRYPTO_AUTH_ZUC_EIA3,
5670 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5671 tdata->key.data, tdata->key.len,
5672 tdata->auth_iv.len, tdata->digest.len,
5673 tdata->cipher_iv.len);
5678 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5679 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5680 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5681 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5683 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5684 plaintext_pad_len, 15, 0);
5685 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5686 "Failed to allocate input buffer in mempool");
5688 if (op_mode == OUT_OF_PLACE) {
5689 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5690 plaintext_pad_len, 15, 0);
5691 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5692 "Failed to allocate output buffer in mempool");
5696 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5697 tdata->ciphertext.data);
5698 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5699 ciphertext_len, buffer);
5700 debug_hexdump(stdout, "ciphertext:", ciphertext,
5703 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5704 tdata->plaintext.data);
5705 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5706 plaintext_len, buffer);
5707 debug_hexdump(stdout, "plaintext:", plaintext,
5710 memset(buffer, 0, sizeof(buffer));
5712 /* Create ZUC operation */
5713 retval = create_wireless_algo_auth_cipher_operation(
5715 tdata->cipher_iv.data, tdata->cipher_iv.len,
5717 (tdata->digest.offset_bytes == 0 ?
5718 (verify ? ciphertext_pad_len : plaintext_pad_len)
5719 : tdata->digest.offset_bytes),
5720 tdata->validCipherLenInBits.len,
5721 tdata->validCipherOffsetInBits.len,
5722 tdata->validAuthLenInBits.len,
5729 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5732 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5734 ut_params->obuf = (op_mode == IN_PLACE ?
5735 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5738 if (ut_params->obuf)
5739 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5740 plaintext_len, buffer);
5742 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5743 plaintext_len, buffer);
5745 debug_hexdump(stdout, "plaintext:", plaintext,
5746 (tdata->plaintext.len >> 3) - tdata->digest.len);
5747 debug_hexdump(stdout, "plaintext expected:",
5748 tdata->plaintext.data,
5749 (tdata->plaintext.len >> 3) - tdata->digest.len);
5751 if (ut_params->obuf)
5752 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5753 ciphertext_len, buffer);
5755 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5756 ciphertext_len, buffer);
5758 debug_hexdump(stdout, "ciphertext:", ciphertext,
5760 debug_hexdump(stdout, "ciphertext expected:",
5761 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5763 if (ut_params->obuf)
5764 digest = rte_pktmbuf_read(ut_params->obuf,
5765 (tdata->digest.offset_bytes == 0 ?
5766 plaintext_pad_len : tdata->digest.offset_bytes),
5767 tdata->digest.len, digest_buffer);
5769 digest = rte_pktmbuf_read(ut_params->ibuf,
5770 (tdata->digest.offset_bytes == 0 ?
5771 plaintext_pad_len : tdata->digest.offset_bytes),
5772 tdata->digest.len, digest_buffer);
5774 debug_hexdump(stdout, "digest:", digest,
5776 debug_hexdump(stdout, "digest expected:",
5777 tdata->digest.data, tdata->digest.len);
5782 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5784 tdata->plaintext.data,
5785 tdata->plaintext.len >> 3,
5786 "ZUC Plaintext data not as expected");
5788 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5790 tdata->ciphertext.data,
5791 tdata->validDataLenInBits.len,
5792 "ZUC Ciphertext data not as expected");
5794 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5797 DIGEST_BYTE_LENGTH_KASUMI_F9,
5798 "ZUC Generated auth tag not as expected");
5804 test_kasumi_encryption_test_case_1(void)
5806 return test_kasumi_encryption(&kasumi_test_case_1);
5810 test_kasumi_encryption_test_case_1_sgl(void)
5812 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
5816 test_kasumi_encryption_test_case_1_oop(void)
5818 return test_kasumi_encryption_oop(&kasumi_test_case_1);
5822 test_kasumi_encryption_test_case_1_oop_sgl(void)
5824 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
5828 test_kasumi_encryption_test_case_2(void)
5830 return test_kasumi_encryption(&kasumi_test_case_2);
5834 test_kasumi_encryption_test_case_3(void)
5836 return test_kasumi_encryption(&kasumi_test_case_3);
5840 test_kasumi_encryption_test_case_4(void)
5842 return test_kasumi_encryption(&kasumi_test_case_4);
5846 test_kasumi_encryption_test_case_5(void)
5848 return test_kasumi_encryption(&kasumi_test_case_5);
5852 test_kasumi_decryption_test_case_1(void)
5854 return test_kasumi_decryption(&kasumi_test_case_1);
5858 test_kasumi_decryption_test_case_1_oop(void)
5860 return test_kasumi_decryption_oop(&kasumi_test_case_1);
5864 test_kasumi_decryption_test_case_2(void)
5866 return test_kasumi_decryption(&kasumi_test_case_2);
5870 test_kasumi_decryption_test_case_3(void)
5872 return test_kasumi_decryption(&kasumi_test_case_3);
5876 test_kasumi_decryption_test_case_4(void)
5878 return test_kasumi_decryption(&kasumi_test_case_4);
5882 test_kasumi_decryption_test_case_5(void)
5884 return test_kasumi_decryption(&kasumi_test_case_5);
5887 test_snow3g_encryption_test_case_1(void)
5889 return test_snow3g_encryption(&snow3g_test_case_1);
5893 test_snow3g_encryption_test_case_1_oop(void)
5895 return test_snow3g_encryption_oop(&snow3g_test_case_1);
5899 test_snow3g_encryption_test_case_1_oop_sgl(void)
5901 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
5906 test_snow3g_encryption_test_case_1_offset_oop(void)
5908 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
5912 test_snow3g_encryption_test_case_2(void)
5914 return test_snow3g_encryption(&snow3g_test_case_2);
5918 test_snow3g_encryption_test_case_3(void)
5920 return test_snow3g_encryption(&snow3g_test_case_3);
5924 test_snow3g_encryption_test_case_4(void)
5926 return test_snow3g_encryption(&snow3g_test_case_4);
5930 test_snow3g_encryption_test_case_5(void)
5932 return test_snow3g_encryption(&snow3g_test_case_5);
5936 test_snow3g_decryption_test_case_1(void)
5938 return test_snow3g_decryption(&snow3g_test_case_1);
5942 test_snow3g_decryption_test_case_1_oop(void)
5944 return test_snow3g_decryption_oop(&snow3g_test_case_1);
5948 test_snow3g_decryption_test_case_2(void)
5950 return test_snow3g_decryption(&snow3g_test_case_2);
5954 test_snow3g_decryption_test_case_3(void)
5956 return test_snow3g_decryption(&snow3g_test_case_3);
5960 test_snow3g_decryption_test_case_4(void)
5962 return test_snow3g_decryption(&snow3g_test_case_4);
5966 test_snow3g_decryption_test_case_5(void)
5968 return test_snow3g_decryption(&snow3g_test_case_5);
5972 * Function prepares snow3g_hash_test_data from snow3g_test_data.
5973 * Pattern digest from snow3g_test_data must be allocated as
5974 * 4 last bytes in plaintext.
5977 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
5978 struct snow3g_hash_test_data *output)
5980 if ((pattern != NULL) && (output != NULL)) {
5981 output->key.len = pattern->key.len;
5983 memcpy(output->key.data,
5984 pattern->key.data, pattern->key.len);
5986 output->auth_iv.len = pattern->auth_iv.len;
5988 memcpy(output->auth_iv.data,
5989 pattern->auth_iv.data, pattern->auth_iv.len);
5991 output->plaintext.len = pattern->plaintext.len;
5993 memcpy(output->plaintext.data,
5994 pattern->plaintext.data, pattern->plaintext.len >> 3);
5996 output->digest.len = pattern->digest.len;
5998 memcpy(output->digest.data,
5999 &pattern->plaintext.data[pattern->digest.offset_bytes],
6000 pattern->digest.len);
6002 output->validAuthLenInBits.len =
6003 pattern->validAuthLenInBits.len;
6008 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6011 test_snow3g_decryption_with_digest_test_case_1(void)
6013 struct snow3g_hash_test_data snow3g_hash_data;
6016 * Function prepare data for hash veryfication test case.
6017 * Digest is allocated in 4 last bytes in plaintext, pattern.
6019 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6021 return test_snow3g_decryption(&snow3g_test_case_7) &
6022 test_snow3g_authentication_verify(&snow3g_hash_data);
6026 test_snow3g_cipher_auth_test_case_1(void)
6028 return test_snow3g_cipher_auth(&snow3g_test_case_3);
6032 test_snow3g_auth_cipher_test_case_1(void)
6034 return test_snow3g_auth_cipher(
6035 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6039 test_snow3g_auth_cipher_test_case_2(void)
6041 return test_snow3g_auth_cipher(
6042 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6046 test_snow3g_auth_cipher_test_case_2_oop(void)
6048 return test_snow3g_auth_cipher(
6049 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6053 test_snow3g_auth_cipher_part_digest_enc(void)
6055 return test_snow3g_auth_cipher(
6056 &snow3g_auth_cipher_partial_digest_encryption,
6061 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6063 return test_snow3g_auth_cipher(
6064 &snow3g_auth_cipher_partial_digest_encryption,
6069 test_snow3g_auth_cipher_test_case_3_sgl(void)
6071 return test_snow3g_auth_cipher_sgl(
6072 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6076 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6078 return test_snow3g_auth_cipher_sgl(
6079 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6083 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6085 return test_snow3g_auth_cipher_sgl(
6086 &snow3g_auth_cipher_partial_digest_encryption,
6091 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6093 return test_snow3g_auth_cipher_sgl(
6094 &snow3g_auth_cipher_partial_digest_encryption,
6099 test_snow3g_auth_cipher_verify_test_case_1(void)
6101 return test_snow3g_auth_cipher(
6102 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6106 test_snow3g_auth_cipher_verify_test_case_2(void)
6108 return test_snow3g_auth_cipher(
6109 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6113 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6115 return test_snow3g_auth_cipher(
6116 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6120 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6122 return test_snow3g_auth_cipher(
6123 &snow3g_auth_cipher_partial_digest_encryption,
6128 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6130 return test_snow3g_auth_cipher(
6131 &snow3g_auth_cipher_partial_digest_encryption,
6136 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6138 return test_snow3g_auth_cipher_sgl(
6139 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6143 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6145 return test_snow3g_auth_cipher_sgl(
6146 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6150 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6152 return test_snow3g_auth_cipher_sgl(
6153 &snow3g_auth_cipher_partial_digest_encryption,
6158 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6160 return test_snow3g_auth_cipher_sgl(
6161 &snow3g_auth_cipher_partial_digest_encryption,
6166 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6168 return test_snow3g_auth_cipher(
6169 &snow3g_test_case_7, IN_PLACE, 0);
6173 test_kasumi_auth_cipher_test_case_1(void)
6175 return test_kasumi_auth_cipher(
6176 &kasumi_test_case_3, IN_PLACE, 0);
6180 test_kasumi_auth_cipher_test_case_2(void)
6182 return test_kasumi_auth_cipher(
6183 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6187 test_kasumi_auth_cipher_test_case_2_oop(void)
6189 return test_kasumi_auth_cipher(
6190 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6194 test_kasumi_auth_cipher_test_case_2_sgl(void)
6196 return test_kasumi_auth_cipher_sgl(
6197 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6201 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6203 return test_kasumi_auth_cipher_sgl(
6204 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6208 test_kasumi_auth_cipher_verify_test_case_1(void)
6210 return test_kasumi_auth_cipher(
6211 &kasumi_test_case_3, IN_PLACE, 1);
6215 test_kasumi_auth_cipher_verify_test_case_2(void)
6217 return test_kasumi_auth_cipher(
6218 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6222 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6224 return test_kasumi_auth_cipher(
6225 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6229 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6231 return test_kasumi_auth_cipher_sgl(
6232 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6236 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6238 return test_kasumi_auth_cipher_sgl(
6239 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6243 test_kasumi_cipher_auth_test_case_1(void)
6245 return test_kasumi_cipher_auth(&kasumi_test_case_6);
6249 test_zuc_encryption_test_case_1(void)
6251 return test_zuc_encryption(&zuc_test_case_cipher_193b);
6255 test_zuc_encryption_test_case_2(void)
6257 return test_zuc_encryption(&zuc_test_case_cipher_800b);
6261 test_zuc_encryption_test_case_3(void)
6263 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6267 test_zuc_encryption_test_case_4(void)
6269 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6273 test_zuc_encryption_test_case_5(void)
6275 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6279 test_zuc_encryption_test_case_6_sgl(void)
6281 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6285 test_zuc_hash_generate_test_case_1(void)
6287 return test_zuc_authentication(&zuc_test_case_auth_1b);
6291 test_zuc_hash_generate_test_case_2(void)
6293 return test_zuc_authentication(&zuc_test_case_auth_90b);
6297 test_zuc_hash_generate_test_case_3(void)
6299 return test_zuc_authentication(&zuc_test_case_auth_577b);
6303 test_zuc_hash_generate_test_case_4(void)
6305 return test_zuc_authentication(&zuc_test_case_auth_2079b);
6309 test_zuc_hash_generate_test_case_5(void)
6311 return test_zuc_authentication(&zuc_test_auth_5670b);
6315 test_zuc_hash_generate_test_case_6(void)
6317 return test_zuc_authentication(&zuc_test_case_auth_128b);
6321 test_zuc_hash_generate_test_case_7(void)
6323 return test_zuc_authentication(&zuc_test_case_auth_2080b);
6327 test_zuc_hash_generate_test_case_8(void)
6329 return test_zuc_authentication(&zuc_test_case_auth_584b);
6333 test_zuc_cipher_auth_test_case_1(void)
6335 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6339 test_zuc_cipher_auth_test_case_2(void)
6341 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6345 test_zuc_auth_cipher_test_case_1(void)
6347 return test_zuc_auth_cipher(
6348 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6352 test_zuc_auth_cipher_test_case_1_oop(void)
6354 return test_zuc_auth_cipher(
6355 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6359 test_zuc_auth_cipher_test_case_1_sgl(void)
6361 return test_zuc_auth_cipher_sgl(
6362 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6366 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6368 return test_zuc_auth_cipher_sgl(
6369 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6373 test_zuc_auth_cipher_verify_test_case_1(void)
6375 return test_zuc_auth_cipher(
6376 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6380 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6382 return test_zuc_auth_cipher(
6383 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6387 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6389 return test_zuc_auth_cipher_sgl(
6390 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6394 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6396 return test_zuc_auth_cipher_sgl(
6397 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6401 test_3DES_chain_qat_all(void)
6403 struct crypto_testsuite_params *ts_params = &testsuite_params;
6406 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6407 ts_params->op_mpool,
6408 ts_params->session_mpool, ts_params->session_priv_mpool,
6409 ts_params->valid_devs[0],
6410 rte_cryptodev_driver_id_get(
6411 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
6412 BLKCIPHER_3DES_CHAIN_TYPE);
6414 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6416 return TEST_SUCCESS;
6420 test_DES_cipheronly_qat_all(void)
6422 struct crypto_testsuite_params *ts_params = &testsuite_params;
6425 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6426 ts_params->op_mpool,
6427 ts_params->session_mpool, ts_params->session_priv_mpool,
6428 ts_params->valid_devs[0],
6429 rte_cryptodev_driver_id_get(
6430 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
6431 BLKCIPHER_DES_CIPHERONLY_TYPE);
6433 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6435 return TEST_SUCCESS;
6439 test_DES_cipheronly_openssl_all(void)
6441 struct crypto_testsuite_params *ts_params = &testsuite_params;
6444 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6445 ts_params->op_mpool,
6446 ts_params->session_mpool, ts_params->session_priv_mpool,
6447 ts_params->valid_devs[0],
6448 rte_cryptodev_driver_id_get(
6449 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
6450 BLKCIPHER_DES_CIPHERONLY_TYPE);
6452 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6454 return TEST_SUCCESS;
6458 test_DES_docsis_openssl_all(void)
6460 struct crypto_testsuite_params *ts_params = &testsuite_params;
6463 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6464 ts_params->op_mpool,
6465 ts_params->session_mpool, ts_params->session_priv_mpool,
6466 ts_params->valid_devs[0],
6467 rte_cryptodev_driver_id_get(
6468 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
6469 BLKCIPHER_DES_DOCSIS_TYPE);
6471 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6473 return TEST_SUCCESS;
6477 test_DES_cipheronly_mb_all(void)
6479 struct crypto_testsuite_params *ts_params = &testsuite_params;
6482 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6483 ts_params->op_mpool,
6484 ts_params->session_mpool, ts_params->session_priv_mpool,
6485 ts_params->valid_devs[0],
6486 rte_cryptodev_driver_id_get(
6487 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
6488 BLKCIPHER_DES_CIPHERONLY_TYPE);
6490 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6492 return TEST_SUCCESS;
6495 test_3DES_cipheronly_mb_all(void)
6497 struct crypto_testsuite_params *ts_params = &testsuite_params;
6500 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6501 ts_params->op_mpool,
6502 ts_params->session_mpool, ts_params->session_priv_mpool,
6503 ts_params->valid_devs[0],
6504 rte_cryptodev_driver_id_get(
6505 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
6506 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6508 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6510 return TEST_SUCCESS;
6514 test_DES_docsis_mb_all(void)
6516 struct crypto_testsuite_params *ts_params = &testsuite_params;
6519 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6520 ts_params->op_mpool,
6521 ts_params->session_mpool, ts_params->session_priv_mpool,
6522 ts_params->valid_devs[0],
6523 rte_cryptodev_driver_id_get(
6524 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
6525 BLKCIPHER_DES_DOCSIS_TYPE);
6527 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6529 return TEST_SUCCESS;
6533 test_3DES_chain_caam_jr_all(void)
6535 struct crypto_testsuite_params *ts_params = &testsuite_params;
6538 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6539 ts_params->op_mpool,
6540 ts_params->session_mpool, ts_params->session_priv_mpool,
6541 ts_params->valid_devs[0],
6542 rte_cryptodev_driver_id_get(
6543 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
6544 BLKCIPHER_3DES_CHAIN_TYPE);
6546 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6548 return TEST_SUCCESS;
6552 test_3DES_cipheronly_caam_jr_all(void)
6554 struct crypto_testsuite_params *ts_params = &testsuite_params;
6557 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6558 ts_params->op_mpool,
6559 ts_params->session_mpool, ts_params->session_priv_mpool,
6560 ts_params->valid_devs[0],
6561 rte_cryptodev_driver_id_get(
6562 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
6563 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6565 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6567 return TEST_SUCCESS;
6571 test_3DES_chain_dpaa_sec_all(void)
6573 struct crypto_testsuite_params *ts_params = &testsuite_params;
6576 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6577 ts_params->op_mpool,
6578 ts_params->session_mpool, ts_params->session_priv_mpool,
6579 ts_params->valid_devs[0],
6580 rte_cryptodev_driver_id_get(
6581 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
6582 BLKCIPHER_3DES_CHAIN_TYPE);
6584 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6586 return TEST_SUCCESS;
6590 test_3DES_cipheronly_dpaa_sec_all(void)
6592 struct crypto_testsuite_params *ts_params = &testsuite_params;
6595 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6596 ts_params->op_mpool,
6597 ts_params->session_mpool, ts_params->session_priv_mpool,
6598 ts_params->valid_devs[0],
6599 rte_cryptodev_driver_id_get(
6600 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
6601 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6603 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6605 return TEST_SUCCESS;
6609 test_3DES_chain_dpaa2_sec_all(void)
6611 struct crypto_testsuite_params *ts_params = &testsuite_params;
6614 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6615 ts_params->op_mpool,
6616 ts_params->session_mpool, ts_params->session_priv_mpool,
6617 ts_params->valid_devs[0],
6618 rte_cryptodev_driver_id_get(
6619 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
6620 BLKCIPHER_3DES_CHAIN_TYPE);
6622 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6624 return TEST_SUCCESS;
6628 test_3DES_cipheronly_dpaa2_sec_all(void)
6630 struct crypto_testsuite_params *ts_params = &testsuite_params;
6633 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6634 ts_params->op_mpool,
6635 ts_params->session_mpool, ts_params->session_priv_mpool,
6636 ts_params->valid_devs[0],
6637 rte_cryptodev_driver_id_get(
6638 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
6639 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6641 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6643 return TEST_SUCCESS;
6647 test_3DES_chain_ccp_all(void)
6649 struct crypto_testsuite_params *ts_params = &testsuite_params;
6652 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6653 ts_params->op_mpool,
6654 ts_params->session_mpool, ts_params->session_priv_mpool,
6655 ts_params->valid_devs[0],
6656 rte_cryptodev_driver_id_get(
6657 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
6658 BLKCIPHER_3DES_CHAIN_TYPE);
6660 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6662 return TEST_SUCCESS;
6666 test_3DES_cipheronly_ccp_all(void)
6668 struct crypto_testsuite_params *ts_params = &testsuite_params;
6671 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6672 ts_params->op_mpool,
6673 ts_params->session_mpool, ts_params->session_priv_mpool,
6674 ts_params->valid_devs[0],
6675 rte_cryptodev_driver_id_get(
6676 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
6677 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6679 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6681 return TEST_SUCCESS;
6685 test_3DES_cipheronly_qat_all(void)
6687 struct crypto_testsuite_params *ts_params = &testsuite_params;
6690 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6691 ts_params->op_mpool,
6692 ts_params->session_mpool, ts_params->session_priv_mpool,
6693 ts_params->valid_devs[0],
6694 rte_cryptodev_driver_id_get(
6695 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
6696 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6698 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6700 return TEST_SUCCESS;
6704 test_3DES_chain_openssl_all(void)
6706 struct crypto_testsuite_params *ts_params = &testsuite_params;
6709 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6710 ts_params->op_mpool,
6711 ts_params->session_mpool, ts_params->session_priv_mpool,
6712 ts_params->valid_devs[0],
6713 rte_cryptodev_driver_id_get(
6714 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
6715 BLKCIPHER_3DES_CHAIN_TYPE);
6717 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6719 return TEST_SUCCESS;
6723 test_3DES_cipheronly_openssl_all(void)
6725 struct crypto_testsuite_params *ts_params = &testsuite_params;
6728 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
6729 ts_params->op_mpool,
6730 ts_params->session_mpool, ts_params->session_priv_mpool,
6731 ts_params->valid_devs[0],
6732 rte_cryptodev_driver_id_get(
6733 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
6734 BLKCIPHER_3DES_CIPHERONLY_TYPE);
6736 TEST_ASSERT_EQUAL(status, 0, "Test failed");
6738 return TEST_SUCCESS;
6741 /* ***** AEAD algorithm Tests ***** */
6744 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
6745 enum rte_crypto_aead_operation op,
6746 const uint8_t *key, const uint8_t key_len,
6747 const uint16_t aad_len, const uint8_t auth_len,
6750 uint8_t aead_key[key_len];
6752 struct crypto_testsuite_params *ts_params = &testsuite_params;
6753 struct crypto_unittest_params *ut_params = &unittest_params;
6755 memcpy(aead_key, key, key_len);
6757 /* Setup AEAD Parameters */
6758 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
6759 ut_params->aead_xform.next = NULL;
6760 ut_params->aead_xform.aead.algo = algo;
6761 ut_params->aead_xform.aead.op = op;
6762 ut_params->aead_xform.aead.key.data = aead_key;
6763 ut_params->aead_xform.aead.key.length = key_len;
6764 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
6765 ut_params->aead_xform.aead.iv.length = iv_len;
6766 ut_params->aead_xform.aead.digest_length = auth_len;
6767 ut_params->aead_xform.aead.aad_length = aad_len;
6769 debug_hexdump(stdout, "key:", key, key_len);
6771 /* Create Crypto session*/
6772 ut_params->sess = rte_cryptodev_sym_session_create(
6773 ts_params->session_mpool);
6775 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6776 &ut_params->aead_xform,
6777 ts_params->session_priv_mpool);
6779 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6785 create_aead_xform(struct rte_crypto_op *op,
6786 enum rte_crypto_aead_algorithm algo,
6787 enum rte_crypto_aead_operation aead_op,
6788 uint8_t *key, const uint8_t key_len,
6789 const uint8_t aad_len, const uint8_t auth_len,
6792 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
6793 "failed to allocate space for crypto transform");
6795 struct rte_crypto_sym_op *sym_op = op->sym;
6797 /* Setup AEAD Parameters */
6798 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
6799 sym_op->xform->next = NULL;
6800 sym_op->xform->aead.algo = algo;
6801 sym_op->xform->aead.op = aead_op;
6802 sym_op->xform->aead.key.data = key;
6803 sym_op->xform->aead.key.length = key_len;
6804 sym_op->xform->aead.iv.offset = IV_OFFSET;
6805 sym_op->xform->aead.iv.length = iv_len;
6806 sym_op->xform->aead.digest_length = auth_len;
6807 sym_op->xform->aead.aad_length = aad_len;
6809 debug_hexdump(stdout, "key:", key, key_len);
6815 create_aead_operation(enum rte_crypto_aead_operation op,
6816 const struct aead_test_data *tdata)
6818 struct crypto_testsuite_params *ts_params = &testsuite_params;
6819 struct crypto_unittest_params *ut_params = &unittest_params;
6821 uint8_t *plaintext, *ciphertext;
6822 unsigned int aad_pad_len, plaintext_pad_len;
6824 /* Generate Crypto op data structure */
6825 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6826 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6827 TEST_ASSERT_NOT_NULL(ut_params->op,
6828 "Failed to allocate symmetric crypto operation struct");
6830 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6832 /* Append aad data */
6833 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
6834 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
6835 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6837 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6838 "no room to append aad");
6840 sym_op->aead.aad.phys_addr =
6841 rte_pktmbuf_iova(ut_params->ibuf);
6842 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
6843 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
6844 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6847 /* Append IV at the end of the crypto operation*/
6848 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6849 uint8_t *, IV_OFFSET);
6851 /* Copy IV 1 byte after the IV pointer, according to the API */
6852 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
6853 debug_hexdump(stdout, "iv:", iv_ptr,
6856 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6857 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6859 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6860 "no room to append aad");
6862 sym_op->aead.aad.phys_addr =
6863 rte_pktmbuf_iova(ut_params->ibuf);
6864 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
6865 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6868 /* Append IV at the end of the crypto operation*/
6869 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6870 uint8_t *, IV_OFFSET);
6872 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
6873 debug_hexdump(stdout, "iv:", iv_ptr,
6877 /* Append plaintext/ciphertext */
6878 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6879 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6880 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6882 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6884 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6885 debug_hexdump(stdout, "plaintext:", plaintext,
6886 tdata->plaintext.len);
6888 if (ut_params->obuf) {
6889 ciphertext = (uint8_t *)rte_pktmbuf_append(
6891 plaintext_pad_len + aad_pad_len);
6892 TEST_ASSERT_NOT_NULL(ciphertext,
6893 "no room to append ciphertext");
6895 memset(ciphertext + aad_pad_len, 0,
6896 tdata->ciphertext.len);
6899 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
6900 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6902 TEST_ASSERT_NOT_NULL(ciphertext,
6903 "no room to append ciphertext");
6905 memcpy(ciphertext, tdata->ciphertext.data,
6906 tdata->ciphertext.len);
6907 debug_hexdump(stdout, "ciphertext:", ciphertext,
6908 tdata->ciphertext.len);
6910 if (ut_params->obuf) {
6911 plaintext = (uint8_t *)rte_pktmbuf_append(
6913 plaintext_pad_len + aad_pad_len);
6914 TEST_ASSERT_NOT_NULL(plaintext,
6915 "no room to append plaintext");
6917 memset(plaintext + aad_pad_len, 0,
6918 tdata->plaintext.len);
6922 /* Append digest data */
6923 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6924 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6925 ut_params->obuf ? ut_params->obuf :
6927 tdata->auth_tag.len);
6928 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6929 "no room to append digest");
6930 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
6931 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6932 ut_params->obuf ? ut_params->obuf :
6937 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6938 ut_params->ibuf, tdata->auth_tag.len);
6939 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6940 "no room to append digest");
6941 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6943 plaintext_pad_len + aad_pad_len);
6945 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
6946 tdata->auth_tag.len);
6947 debug_hexdump(stdout, "digest:",
6948 sym_op->aead.digest.data,
6949 tdata->auth_tag.len);
6952 sym_op->aead.data.length = tdata->plaintext.len;
6953 sym_op->aead.data.offset = aad_pad_len;
6959 test_authenticated_encryption(const struct aead_test_data *tdata)
6961 struct crypto_testsuite_params *ts_params = &testsuite_params;
6962 struct crypto_unittest_params *ut_params = &unittest_params;
6965 uint8_t *ciphertext, *auth_tag;
6966 uint16_t plaintext_pad_len;
6969 /* Create AEAD session */
6970 retval = create_aead_session(ts_params->valid_devs[0],
6972 RTE_CRYPTO_AEAD_OP_ENCRYPT,
6973 tdata->key.data, tdata->key.len,
6974 tdata->aad.len, tdata->auth_tag.len,
6979 if (tdata->aad.len > MBUF_SIZE) {
6980 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6981 /* Populate full size of add data */
6982 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
6983 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
6985 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6987 /* clear mbuf payload */
6988 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6989 rte_pktmbuf_tailroom(ut_params->ibuf));
6991 /* Create AEAD operation */
6992 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
6996 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6998 ut_params->op->sym->m_src = ut_params->ibuf;
7000 /* Process crypto operation */
7001 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7002 ut_params->op), "failed to process sym crypto op");
7004 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7005 "crypto op processing failed");
7007 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7009 if (ut_params->op->sym->m_dst) {
7010 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7012 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7013 uint8_t *, plaintext_pad_len);
7015 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7017 ut_params->op->sym->cipher.data.offset);
7018 auth_tag = ciphertext + plaintext_pad_len;
7021 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7022 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7025 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7027 tdata->ciphertext.data,
7028 tdata->ciphertext.len,
7029 "Ciphertext data not as expected");
7031 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7033 tdata->auth_tag.data,
7034 tdata->auth_tag.len,
7035 "Generated auth tag not as expected");
7041 #ifdef RTE_LIBRTE_SECURITY
7042 /* Basic algorithm run function for async inplace mode.
7043 * Creates a session from input parameters and runs one operation
7044 * on input_vec. Checks the output of the crypto operation against
7048 test_pdcp_proto(int i, int oop,
7049 enum rte_crypto_cipher_operation opc,
7050 enum rte_crypto_auth_operation opa,
7052 unsigned int input_vec_len,
7053 uint8_t *output_vec,
7054 unsigned int output_vec_len)
7056 struct crypto_testsuite_params *ts_params = &testsuite_params;
7057 struct crypto_unittest_params *ut_params = &unittest_params;
7059 int ret = TEST_SUCCESS;
7061 /* Generate test mbuf data */
7062 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7064 /* clear mbuf payload */
7065 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7066 rte_pktmbuf_tailroom(ut_params->ibuf));
7068 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7070 memcpy(plaintext, input_vec, input_vec_len);
7072 /* Out of place support */
7075 * For out-op-place we need to alloc another mbuf
7077 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7078 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7081 /* Set crypto type as IPSEC */
7082 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7084 /* Setup Cipher Parameters */
7085 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7086 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7087 ut_params->cipher_xform.cipher.op = opc;
7088 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7089 ut_params->cipher_xform.cipher.key.length =
7090 pdcp_test_params[i].cipher_key_len;
7091 ut_params->cipher_xform.cipher.iv.length = 0;
7093 /* Setup HMAC Parameters if ICV header is required */
7094 if (pdcp_test_params[i].auth_alg != 0) {
7095 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7096 ut_params->auth_xform.next = NULL;
7097 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7098 ut_params->auth_xform.auth.op = opa;
7099 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7100 ut_params->auth_xform.auth.key.length =
7101 pdcp_test_params[i].auth_key_len;
7103 ut_params->cipher_xform.next = &ut_params->auth_xform;
7105 ut_params->cipher_xform.next = NULL;
7108 struct rte_security_session_conf sess_conf = {
7109 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7110 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7112 .bearer = pdcp_test_bearer[i],
7113 .domain = pdcp_test_params[i].domain,
7114 .pkt_dir = pdcp_test_packet_direction[i],
7115 .sn_size = pdcp_test_data_sn_size[i],
7116 .hfn = pdcp_test_hfn[i],
7117 .hfn_threshold = pdcp_test_hfn_threshold[i],
7119 .crypto_xform = &ut_params->cipher_xform
7122 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7123 rte_cryptodev_get_sec_ctx(
7124 ts_params->valid_devs[0]);
7126 /* Create security session */
7127 ut_params->sec_session = rte_security_session_create(ctx,
7128 &sess_conf, ts_params->session_mpool);
7130 if (!ut_params->sec_session) {
7131 printf("TestCase %s()-%d line %d failed %s: ",
7132 __func__, i, __LINE__, "Failed to allocate session");
7137 /* Generate crypto op data structure */
7138 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7139 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7140 if (!ut_params->op) {
7141 printf("TestCase %s()-%d line %d failed %s: ",
7142 __func__, i, __LINE__,
7143 "Failed to allocate symmetric crypto operation struct");
7148 rte_security_attach_session(ut_params->op, ut_params->sec_session);
7150 /* set crypto operation source mbuf */
7151 ut_params->op->sym->m_src = ut_params->ibuf;
7153 ut_params->op->sym->m_dst = ut_params->obuf;
7155 /* Process crypto operation */
7156 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7158 printf("TestCase %s()-%d line %d failed %s: ",
7159 __func__, i, __LINE__,
7160 "failed to process sym crypto op");
7165 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7166 printf("TestCase %s()-%d line %d failed %s: ",
7167 __func__, i, __LINE__, "crypto op processing failed");
7173 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7176 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7180 if (memcmp(ciphertext, output_vec, output_vec_len)) {
7181 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7182 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7183 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7189 rte_crypto_op_free(ut_params->op);
7190 ut_params->op = NULL;
7192 if (ut_params->sec_session)
7193 rte_security_session_destroy(ctx, ut_params->sec_session);
7194 ut_params->sec_session = NULL;
7196 rte_pktmbuf_free(ut_params->ibuf);
7197 ut_params->ibuf = NULL;
7199 rte_pktmbuf_free(ut_params->obuf);
7200 ut_params->obuf = NULL;
7207 test_pdcp_proto_cplane_encap(int i)
7209 return test_pdcp_proto(i, 0,
7210 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7211 RTE_CRYPTO_AUTH_OP_GENERATE,
7212 pdcp_test_data_in[i],
7213 pdcp_test_data_in_len[i],
7214 pdcp_test_data_out[i],
7215 pdcp_test_data_in_len[i]+4);
7219 test_pdcp_proto_uplane_encap(int i)
7221 return test_pdcp_proto(i, 0,
7222 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7223 RTE_CRYPTO_AUTH_OP_GENERATE,
7224 pdcp_test_data_in[i],
7225 pdcp_test_data_in_len[i],
7226 pdcp_test_data_out[i],
7227 pdcp_test_data_in_len[i]);
7232 test_pdcp_proto_uplane_encap_with_int(int i)
7234 return test_pdcp_proto(i, 0,
7235 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7236 RTE_CRYPTO_AUTH_OP_GENERATE,
7237 pdcp_test_data_in[i],
7238 pdcp_test_data_in_len[i],
7239 pdcp_test_data_out[i],
7240 pdcp_test_data_in_len[i] + 4);
7244 test_pdcp_proto_cplane_decap(int i)
7246 return test_pdcp_proto(i, 0,
7247 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7248 RTE_CRYPTO_AUTH_OP_VERIFY,
7249 pdcp_test_data_out[i],
7250 pdcp_test_data_in_len[i] + 4,
7251 pdcp_test_data_in[i],
7252 pdcp_test_data_in_len[i]);
7258 test_AES_GCM_authenticated_encryption_test_case_1(void)
7260 return test_authenticated_encryption(&gcm_test_case_1);
7264 test_AES_GCM_authenticated_encryption_test_case_2(void)
7266 return test_authenticated_encryption(&gcm_test_case_2);
7270 test_AES_GCM_authenticated_encryption_test_case_3(void)
7272 return test_authenticated_encryption(&gcm_test_case_3);
7276 test_AES_GCM_authenticated_encryption_test_case_4(void)
7278 return test_authenticated_encryption(&gcm_test_case_4);
7282 test_AES_GCM_authenticated_encryption_test_case_5(void)
7284 return test_authenticated_encryption(&gcm_test_case_5);
7288 test_AES_GCM_authenticated_encryption_test_case_6(void)
7290 return test_authenticated_encryption(&gcm_test_case_6);
7294 test_AES_GCM_authenticated_encryption_test_case_7(void)
7296 return test_authenticated_encryption(&gcm_test_case_7);
7300 test_AES_GCM_auth_encryption_test_case_192_1(void)
7302 return test_authenticated_encryption(&gcm_test_case_192_1);
7306 test_AES_GCM_auth_encryption_test_case_192_2(void)
7308 return test_authenticated_encryption(&gcm_test_case_192_2);
7312 test_AES_GCM_auth_encryption_test_case_192_3(void)
7314 return test_authenticated_encryption(&gcm_test_case_192_3);
7318 test_AES_GCM_auth_encryption_test_case_192_4(void)
7320 return test_authenticated_encryption(&gcm_test_case_192_4);
7324 test_AES_GCM_auth_encryption_test_case_192_5(void)
7326 return test_authenticated_encryption(&gcm_test_case_192_5);
7330 test_AES_GCM_auth_encryption_test_case_192_6(void)
7332 return test_authenticated_encryption(&gcm_test_case_192_6);
7336 test_AES_GCM_auth_encryption_test_case_192_7(void)
7338 return test_authenticated_encryption(&gcm_test_case_192_7);
7342 test_AES_GCM_auth_encryption_test_case_256_1(void)
7344 return test_authenticated_encryption(&gcm_test_case_256_1);
7348 test_AES_GCM_auth_encryption_test_case_256_2(void)
7350 return test_authenticated_encryption(&gcm_test_case_256_2);
7354 test_AES_GCM_auth_encryption_test_case_256_3(void)
7356 return test_authenticated_encryption(&gcm_test_case_256_3);
7360 test_AES_GCM_auth_encryption_test_case_256_4(void)
7362 return test_authenticated_encryption(&gcm_test_case_256_4);
7366 test_AES_GCM_auth_encryption_test_case_256_5(void)
7368 return test_authenticated_encryption(&gcm_test_case_256_5);
7372 test_AES_GCM_auth_encryption_test_case_256_6(void)
7374 return test_authenticated_encryption(&gcm_test_case_256_6);
7378 test_AES_GCM_auth_encryption_test_case_256_7(void)
7380 return test_authenticated_encryption(&gcm_test_case_256_7);
7384 test_AES_GCM_auth_encryption_test_case_aad_1(void)
7386 return test_authenticated_encryption(&gcm_test_case_aad_1);
7390 test_AES_GCM_auth_encryption_test_case_aad_2(void)
7392 return test_authenticated_encryption(&gcm_test_case_aad_2);
7396 test_authenticated_decryption(const struct aead_test_data *tdata)
7398 struct crypto_testsuite_params *ts_params = &testsuite_params;
7399 struct crypto_unittest_params *ut_params = &unittest_params;
7405 /* Create AEAD session */
7406 retval = create_aead_session(ts_params->valid_devs[0],
7408 RTE_CRYPTO_AEAD_OP_DECRYPT,
7409 tdata->key.data, tdata->key.len,
7410 tdata->aad.len, tdata->auth_tag.len,
7415 /* alloc mbuf and set payload */
7416 if (tdata->aad.len > MBUF_SIZE) {
7417 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7418 /* Populate full size of add data */
7419 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7420 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7422 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7424 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7425 rte_pktmbuf_tailroom(ut_params->ibuf));
7427 /* Create AEAD operation */
7428 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7432 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7434 ut_params->op->sym->m_src = ut_params->ibuf;
7436 /* Process crypto operation */
7437 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7438 ut_params->op), "failed to process sym crypto op");
7440 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7441 "crypto op processing failed");
7443 if (ut_params->op->sym->m_dst)
7444 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7447 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7449 ut_params->op->sym->cipher.data.offset);
7451 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7454 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7456 tdata->plaintext.data,
7457 tdata->plaintext.len,
7458 "Plaintext data not as expected");
7460 TEST_ASSERT_EQUAL(ut_params->op->status,
7461 RTE_CRYPTO_OP_STATUS_SUCCESS,
7462 "Authentication failed");
7467 test_AES_GCM_authenticated_decryption_test_case_1(void)
7469 return test_authenticated_decryption(&gcm_test_case_1);
7473 test_AES_GCM_authenticated_decryption_test_case_2(void)
7475 return test_authenticated_decryption(&gcm_test_case_2);
7479 test_AES_GCM_authenticated_decryption_test_case_3(void)
7481 return test_authenticated_decryption(&gcm_test_case_3);
7485 test_AES_GCM_authenticated_decryption_test_case_4(void)
7487 return test_authenticated_decryption(&gcm_test_case_4);
7491 test_AES_GCM_authenticated_decryption_test_case_5(void)
7493 return test_authenticated_decryption(&gcm_test_case_5);
7497 test_AES_GCM_authenticated_decryption_test_case_6(void)
7499 return test_authenticated_decryption(&gcm_test_case_6);
7503 test_AES_GCM_authenticated_decryption_test_case_7(void)
7505 return test_authenticated_decryption(&gcm_test_case_7);
7509 test_AES_GCM_auth_decryption_test_case_192_1(void)
7511 return test_authenticated_decryption(&gcm_test_case_192_1);
7515 test_AES_GCM_auth_decryption_test_case_192_2(void)
7517 return test_authenticated_decryption(&gcm_test_case_192_2);
7521 test_AES_GCM_auth_decryption_test_case_192_3(void)
7523 return test_authenticated_decryption(&gcm_test_case_192_3);
7527 test_AES_GCM_auth_decryption_test_case_192_4(void)
7529 return test_authenticated_decryption(&gcm_test_case_192_4);
7533 test_AES_GCM_auth_decryption_test_case_192_5(void)
7535 return test_authenticated_decryption(&gcm_test_case_192_5);
7539 test_AES_GCM_auth_decryption_test_case_192_6(void)
7541 return test_authenticated_decryption(&gcm_test_case_192_6);
7545 test_AES_GCM_auth_decryption_test_case_192_7(void)
7547 return test_authenticated_decryption(&gcm_test_case_192_7);
7551 test_AES_GCM_auth_decryption_test_case_256_1(void)
7553 return test_authenticated_decryption(&gcm_test_case_256_1);
7557 test_AES_GCM_auth_decryption_test_case_256_2(void)
7559 return test_authenticated_decryption(&gcm_test_case_256_2);
7563 test_AES_GCM_auth_decryption_test_case_256_3(void)
7565 return test_authenticated_decryption(&gcm_test_case_256_3);
7569 test_AES_GCM_auth_decryption_test_case_256_4(void)
7571 return test_authenticated_decryption(&gcm_test_case_256_4);
7575 test_AES_GCM_auth_decryption_test_case_256_5(void)
7577 return test_authenticated_decryption(&gcm_test_case_256_5);
7581 test_AES_GCM_auth_decryption_test_case_256_6(void)
7583 return test_authenticated_decryption(&gcm_test_case_256_6);
7587 test_AES_GCM_auth_decryption_test_case_256_7(void)
7589 return test_authenticated_decryption(&gcm_test_case_256_7);
7593 test_AES_GCM_auth_decryption_test_case_aad_1(void)
7595 return test_authenticated_decryption(&gcm_test_case_aad_1);
7599 test_AES_GCM_auth_decryption_test_case_aad_2(void)
7601 return test_authenticated_decryption(&gcm_test_case_aad_2);
7605 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
7607 struct crypto_testsuite_params *ts_params = &testsuite_params;
7608 struct crypto_unittest_params *ut_params = &unittest_params;
7611 uint8_t *ciphertext, *auth_tag;
7612 uint16_t plaintext_pad_len;
7614 /* Create AEAD session */
7615 retval = create_aead_session(ts_params->valid_devs[0],
7617 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7618 tdata->key.data, tdata->key.len,
7619 tdata->aad.len, tdata->auth_tag.len,
7624 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7625 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7627 /* clear mbuf payload */
7628 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7629 rte_pktmbuf_tailroom(ut_params->ibuf));
7630 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7631 rte_pktmbuf_tailroom(ut_params->obuf));
7633 /* Create AEAD operation */
7634 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7638 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7640 ut_params->op->sym->m_src = ut_params->ibuf;
7641 ut_params->op->sym->m_dst = ut_params->obuf;
7643 /* Process crypto operation */
7644 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7645 ut_params->op), "failed to process sym crypto op");
7647 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7648 "crypto op processing failed");
7650 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7652 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
7653 ut_params->op->sym->cipher.data.offset);
7654 auth_tag = ciphertext + plaintext_pad_len;
7656 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7657 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7660 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7662 tdata->ciphertext.data,
7663 tdata->ciphertext.len,
7664 "Ciphertext data not as expected");
7666 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7668 tdata->auth_tag.data,
7669 tdata->auth_tag.len,
7670 "Generated auth tag not as expected");
7677 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
7679 return test_authenticated_encryption_oop(&gcm_test_case_5);
7683 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
7685 struct crypto_testsuite_params *ts_params = &testsuite_params;
7686 struct crypto_unittest_params *ut_params = &unittest_params;
7691 /* Create AEAD session */
7692 retval = create_aead_session(ts_params->valid_devs[0],
7694 RTE_CRYPTO_AEAD_OP_DECRYPT,
7695 tdata->key.data, tdata->key.len,
7696 tdata->aad.len, tdata->auth_tag.len,
7701 /* alloc mbuf and set payload */
7702 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7703 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7705 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7706 rte_pktmbuf_tailroom(ut_params->ibuf));
7707 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7708 rte_pktmbuf_tailroom(ut_params->obuf));
7710 /* Create AEAD operation */
7711 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7715 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7717 ut_params->op->sym->m_src = ut_params->ibuf;
7718 ut_params->op->sym->m_dst = ut_params->obuf;
7720 /* Process crypto operation */
7721 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7722 ut_params->op), "failed to process sym crypto op");
7724 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7725 "crypto op processing failed");
7727 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
7728 ut_params->op->sym->cipher.data.offset);
7730 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7733 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7735 tdata->plaintext.data,
7736 tdata->plaintext.len,
7737 "Plaintext data not as expected");
7739 TEST_ASSERT_EQUAL(ut_params->op->status,
7740 RTE_CRYPTO_OP_STATUS_SUCCESS,
7741 "Authentication failed");
7746 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
7748 return test_authenticated_decryption_oop(&gcm_test_case_5);
7752 test_authenticated_encryption_sessionless(
7753 const struct aead_test_data *tdata)
7755 struct crypto_testsuite_params *ts_params = &testsuite_params;
7756 struct crypto_unittest_params *ut_params = &unittest_params;
7759 uint8_t *ciphertext, *auth_tag;
7760 uint16_t plaintext_pad_len;
7761 uint8_t key[tdata->key.len + 1];
7763 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7765 /* clear mbuf payload */
7766 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7767 rte_pktmbuf_tailroom(ut_params->ibuf));
7769 /* Create AEAD operation */
7770 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7774 /* Create GCM xform */
7775 memcpy(key, tdata->key.data, tdata->key.len);
7776 retval = create_aead_xform(ut_params->op,
7778 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7779 key, tdata->key.len,
7780 tdata->aad.len, tdata->auth_tag.len,
7785 ut_params->op->sym->m_src = ut_params->ibuf;
7787 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
7788 RTE_CRYPTO_OP_SESSIONLESS,
7789 "crypto op session type not sessionless");
7791 /* Process crypto operation */
7792 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7793 ut_params->op), "failed to process sym crypto op");
7795 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7797 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7798 "crypto op status not success");
7800 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7802 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7803 ut_params->op->sym->cipher.data.offset);
7804 auth_tag = ciphertext + plaintext_pad_len;
7806 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7807 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7810 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7812 tdata->ciphertext.data,
7813 tdata->ciphertext.len,
7814 "Ciphertext data not as expected");
7816 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7818 tdata->auth_tag.data,
7819 tdata->auth_tag.len,
7820 "Generated auth tag not as expected");
7827 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
7829 return test_authenticated_encryption_sessionless(
7834 test_authenticated_decryption_sessionless(
7835 const struct aead_test_data *tdata)
7837 struct crypto_testsuite_params *ts_params = &testsuite_params;
7838 struct crypto_unittest_params *ut_params = &unittest_params;
7842 uint8_t key[tdata->key.len + 1];
7844 /* alloc mbuf and set payload */
7845 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7847 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7848 rte_pktmbuf_tailroom(ut_params->ibuf));
7850 /* Create AEAD operation */
7851 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7855 /* Create AEAD xform */
7856 memcpy(key, tdata->key.data, tdata->key.len);
7857 retval = create_aead_xform(ut_params->op,
7859 RTE_CRYPTO_AEAD_OP_DECRYPT,
7860 key, tdata->key.len,
7861 tdata->aad.len, tdata->auth_tag.len,
7866 ut_params->op->sym->m_src = ut_params->ibuf;
7868 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
7869 RTE_CRYPTO_OP_SESSIONLESS,
7870 "crypto op session type not sessionless");
7872 /* Process crypto operation */
7873 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7874 ut_params->op), "failed to process sym crypto op");
7876 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7878 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7879 "crypto op status not success");
7881 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7882 ut_params->op->sym->cipher.data.offset);
7884 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7887 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7889 tdata->plaintext.data,
7890 tdata->plaintext.len,
7891 "Plaintext data not as expected");
7893 TEST_ASSERT_EQUAL(ut_params->op->status,
7894 RTE_CRYPTO_OP_STATUS_SUCCESS,
7895 "Authentication failed");
7900 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
7902 return test_authenticated_decryption_sessionless(
7907 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
7909 return test_authenticated_encryption(&ccm_test_case_128_1);
7913 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
7915 return test_authenticated_encryption(&ccm_test_case_128_2);
7919 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
7921 return test_authenticated_encryption(&ccm_test_case_128_3);
7925 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
7927 return test_authenticated_decryption(&ccm_test_case_128_1);
7931 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
7933 return test_authenticated_decryption(&ccm_test_case_128_2);
7937 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
7939 return test_authenticated_decryption(&ccm_test_case_128_3);
7943 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
7945 return test_authenticated_encryption(&ccm_test_case_192_1);
7949 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
7951 return test_authenticated_encryption(&ccm_test_case_192_2);
7955 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
7957 return test_authenticated_encryption(&ccm_test_case_192_3);
7961 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
7963 return test_authenticated_decryption(&ccm_test_case_192_1);
7967 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
7969 return test_authenticated_decryption(&ccm_test_case_192_2);
7973 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
7975 return test_authenticated_decryption(&ccm_test_case_192_3);
7979 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
7981 return test_authenticated_encryption(&ccm_test_case_256_1);
7985 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
7987 return test_authenticated_encryption(&ccm_test_case_256_2);
7991 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
7993 return test_authenticated_encryption(&ccm_test_case_256_3);
7997 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
7999 return test_authenticated_decryption(&ccm_test_case_256_1);
8003 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
8005 return test_authenticated_decryption(&ccm_test_case_256_2);
8009 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
8011 return test_authenticated_decryption(&ccm_test_case_256_3);
8017 struct crypto_testsuite_params *ts_params = &testsuite_params;
8018 struct rte_cryptodev_stats stats;
8019 struct rte_cryptodev *dev;
8020 cryptodev_stats_get_t temp_pfn;
8022 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
8023 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
8024 &stats) == -ENODEV),
8025 "rte_cryptodev_stats_get invalid dev failed");
8026 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
8027 "rte_cryptodev_stats_get invalid Param failed");
8028 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
8029 temp_pfn = dev->dev_ops->stats_get;
8030 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
8031 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
8033 "rte_cryptodev_stats_get invalid Param failed");
8034 dev->dev_ops->stats_get = temp_pfn;
8036 /* Test expected values */
8038 test_AES_CBC_HMAC_SHA1_encrypt_digest();
8040 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8042 "rte_cryptodev_stats_get failed");
8043 TEST_ASSERT((stats.enqueued_count == 1),
8044 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8045 TEST_ASSERT((stats.dequeued_count == 1),
8046 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8047 TEST_ASSERT((stats.enqueue_err_count == 0),
8048 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8049 TEST_ASSERT((stats.dequeue_err_count == 0),
8050 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8052 /* invalid device but should ignore and not reset device stats*/
8053 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
8054 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8056 "rte_cryptodev_stats_get failed");
8057 TEST_ASSERT((stats.enqueued_count == 1),
8058 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8060 /* check that a valid reset clears stats */
8061 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
8062 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8064 "rte_cryptodev_stats_get failed");
8065 TEST_ASSERT((stats.enqueued_count == 0),
8066 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8067 TEST_ASSERT((stats.dequeued_count == 0),
8068 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8070 return TEST_SUCCESS;
8073 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
8074 struct crypto_unittest_params *ut_params,
8075 enum rte_crypto_auth_operation op,
8076 const struct HMAC_MD5_vector *test_case)
8080 memcpy(key, test_case->key.data, test_case->key.len);
8082 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8083 ut_params->auth_xform.next = NULL;
8084 ut_params->auth_xform.auth.op = op;
8086 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
8088 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
8089 ut_params->auth_xform.auth.key.length = test_case->key.len;
8090 ut_params->auth_xform.auth.key.data = key;
8092 ut_params->sess = rte_cryptodev_sym_session_create(
8093 ts_params->session_mpool);
8095 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8096 ut_params->sess, &ut_params->auth_xform,
8097 ts_params->session_priv_mpool);
8099 if (ut_params->sess == NULL)
8102 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8104 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8105 rte_pktmbuf_tailroom(ut_params->ibuf));
8110 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
8111 const struct HMAC_MD5_vector *test_case,
8112 uint8_t **plaintext)
8114 uint16_t plaintext_pad_len;
8116 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8118 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8121 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8123 memcpy(*plaintext, test_case->plaintext.data,
8124 test_case->plaintext.len);
8126 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8127 ut_params->ibuf, MD5_DIGEST_LEN);
8128 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8129 "no room to append digest");
8130 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8131 ut_params->ibuf, plaintext_pad_len);
8133 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
8134 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
8135 test_case->auth_tag.len);
8138 sym_op->auth.data.offset = 0;
8139 sym_op->auth.data.length = test_case->plaintext.len;
8141 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8142 ut_params->op->sym->m_src = ut_params->ibuf;
8148 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
8150 uint16_t plaintext_pad_len;
8151 uint8_t *plaintext, *auth_tag;
8153 struct crypto_testsuite_params *ts_params = &testsuite_params;
8154 struct crypto_unittest_params *ut_params = &unittest_params;
8156 if (MD5_HMAC_create_session(ts_params, ut_params,
8157 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
8160 /* Generate Crypto op data structure */
8161 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8162 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8163 TEST_ASSERT_NOT_NULL(ut_params->op,
8164 "Failed to allocate symmetric crypto operation struct");
8166 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8169 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
8172 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8173 ut_params->op), "failed to process sym crypto op");
8175 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8176 "crypto op processing failed");
8178 if (ut_params->op->sym->m_dst) {
8179 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8180 uint8_t *, plaintext_pad_len);
8182 auth_tag = plaintext + plaintext_pad_len;
8185 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8187 test_case->auth_tag.data,
8188 test_case->auth_tag.len,
8189 "HMAC_MD5 generated tag not as expected");
8191 return TEST_SUCCESS;
8195 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
8199 struct crypto_testsuite_params *ts_params = &testsuite_params;
8200 struct crypto_unittest_params *ut_params = &unittest_params;
8202 if (MD5_HMAC_create_session(ts_params, ut_params,
8203 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
8207 /* Generate Crypto op data structure */
8208 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8209 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8210 TEST_ASSERT_NOT_NULL(ut_params->op,
8211 "Failed to allocate symmetric crypto operation struct");
8213 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
8216 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8217 ut_params->op), "failed to process sym crypto op");
8219 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8220 "HMAC_MD5 crypto op processing failed");
8222 return TEST_SUCCESS;
8226 test_MD5_HMAC_generate_case_1(void)
8228 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
8232 test_MD5_HMAC_verify_case_1(void)
8234 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
8238 test_MD5_HMAC_generate_case_2(void)
8240 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
8244 test_MD5_HMAC_verify_case_2(void)
8246 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
8250 test_multi_session(void)
8252 struct crypto_testsuite_params *ts_params = &testsuite_params;
8253 struct crypto_unittest_params *ut_params = &unittest_params;
8255 struct rte_cryptodev_info dev_info;
8256 struct rte_cryptodev_sym_session **sessions;
8260 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
8261 aes_cbc_key, hmac_sha512_key);
8264 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8266 sessions = rte_malloc(NULL,
8267 (sizeof(struct rte_cryptodev_sym_session *) *
8268 MAX_NB_SESSIONS) + 1, 0);
8270 /* Create multiple crypto sessions*/
8271 for (i = 0; i < MAX_NB_SESSIONS; i++) {
8273 sessions[i] = rte_cryptodev_sym_session_create(
8274 ts_params->session_mpool);
8276 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8277 sessions[i], &ut_params->auth_xform,
8278 ts_params->session_priv_mpool);
8279 TEST_ASSERT_NOT_NULL(sessions[i],
8280 "Session creation failed at session number %u",
8283 /* Attempt to send a request on each session */
8284 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
8288 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
8289 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
8291 "Failed to perform decrypt on request number %u.", i);
8292 /* free crypto operation structure */
8294 rte_crypto_op_free(ut_params->op);
8297 * free mbuf - both obuf and ibuf are usually the same,
8298 * so check if they point at the same address is necessary,
8299 * to avoid freeing the mbuf twice.
8301 if (ut_params->obuf) {
8302 rte_pktmbuf_free(ut_params->obuf);
8303 if (ut_params->ibuf == ut_params->obuf)
8304 ut_params->ibuf = 0;
8305 ut_params->obuf = 0;
8307 if (ut_params->ibuf) {
8308 rte_pktmbuf_free(ut_params->ibuf);
8309 ut_params->ibuf = 0;
8313 /* Next session create should fail */
8314 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8315 sessions[i], &ut_params->auth_xform,
8316 ts_params->session_priv_mpool);
8317 TEST_ASSERT_NULL(sessions[i],
8318 "Session creation succeeded unexpectedly!");
8320 for (i = 0; i < MAX_NB_SESSIONS; i++) {
8321 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
8323 rte_cryptodev_sym_session_free(sessions[i]);
8328 return TEST_SUCCESS;
8331 struct multi_session_params {
8332 struct crypto_unittest_params ut_params;
8333 uint8_t *cipher_key;
8335 const uint8_t *cipher;
8336 const uint8_t *digest;
8340 #define MB_SESSION_NUMBER 3
8343 test_multi_session_random_usage(void)
8345 struct crypto_testsuite_params *ts_params = &testsuite_params;
8346 struct rte_cryptodev_info dev_info;
8347 struct rte_cryptodev_sym_session **sessions;
8349 struct multi_session_params ut_paramz[] = {
8352 .cipher_key = ms_aes_cbc_key0,
8353 .hmac_key = ms_hmac_key0,
8354 .cipher = ms_aes_cbc_cipher0,
8355 .digest = ms_hmac_digest0,
8356 .iv = ms_aes_cbc_iv0
8359 .cipher_key = ms_aes_cbc_key1,
8360 .hmac_key = ms_hmac_key1,
8361 .cipher = ms_aes_cbc_cipher1,
8362 .digest = ms_hmac_digest1,
8363 .iv = ms_aes_cbc_iv1
8366 .cipher_key = ms_aes_cbc_key2,
8367 .hmac_key = ms_hmac_key2,
8368 .cipher = ms_aes_cbc_cipher2,
8369 .digest = ms_hmac_digest2,
8370 .iv = ms_aes_cbc_iv2
8375 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8377 sessions = rte_malloc(NULL,
8378 (sizeof(struct rte_cryptodev_sym_session *)
8379 * MAX_NB_SESSIONS) + 1, 0);
8381 for (i = 0; i < MB_SESSION_NUMBER; i++) {
8382 sessions[i] = rte_cryptodev_sym_session_create(
8383 ts_params->session_mpool);
8385 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
8386 sizeof(struct crypto_unittest_params));
8388 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
8389 &ut_paramz[i].ut_params,
8390 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
8392 /* Create multiple crypto sessions*/
8393 rte_cryptodev_sym_session_init(
8394 ts_params->valid_devs[0],
8396 &ut_paramz[i].ut_params.auth_xform,
8397 ts_params->session_priv_mpool);
8399 TEST_ASSERT_NOT_NULL(sessions[i],
8400 "Session creation failed at session number %u",
8406 for (i = 0; i < 40000; i++) {
8408 j = rand() % MB_SESSION_NUMBER;
8410 TEST_ASSERT_SUCCESS(
8411 test_AES_CBC_HMAC_SHA512_decrypt_perform(
8413 &ut_paramz[j].ut_params,
8414 ts_params, ut_paramz[j].cipher,
8415 ut_paramz[j].digest,
8417 "Failed to perform decrypt on request number %u.", i);
8419 if (ut_paramz[j].ut_params.op)
8420 rte_crypto_op_free(ut_paramz[j].ut_params.op);
8423 * free mbuf - both obuf and ibuf are usually the same,
8424 * so check if they point at the same address is necessary,
8425 * to avoid freeing the mbuf twice.
8427 if (ut_paramz[j].ut_params.obuf) {
8428 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
8429 if (ut_paramz[j].ut_params.ibuf
8430 == ut_paramz[j].ut_params.obuf)
8431 ut_paramz[j].ut_params.ibuf = 0;
8432 ut_paramz[j].ut_params.obuf = 0;
8434 if (ut_paramz[j].ut_params.ibuf) {
8435 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
8436 ut_paramz[j].ut_params.ibuf = 0;
8440 for (i = 0; i < MB_SESSION_NUMBER; i++) {
8441 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
8443 rte_cryptodev_sym_session_free(sessions[i]);
8448 return TEST_SUCCESS;
8452 test_null_cipher_only_operation(void)
8454 struct crypto_testsuite_params *ts_params = &testsuite_params;
8455 struct crypto_unittest_params *ut_params = &unittest_params;
8457 /* Generate test mbuf data and space for digest */
8458 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8459 catch_22_quote, QUOTE_512_BYTES, 0);
8461 /* Setup Cipher Parameters */
8462 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8463 ut_params->cipher_xform.next = NULL;
8465 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8466 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8468 ut_params->sess = rte_cryptodev_sym_session_create(
8469 ts_params->session_mpool);
8471 /* Create Crypto session*/
8472 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8474 &ut_params->cipher_xform,
8475 ts_params->session_priv_mpool);
8476 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8478 /* Generate Crypto op data structure */
8479 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8480 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8481 TEST_ASSERT_NOT_NULL(ut_params->op,
8482 "Failed to allocate symmetric crypto operation struct");
8484 /* Set crypto operation data parameters */
8485 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8487 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8489 /* set crypto operation source mbuf */
8490 sym_op->m_src = ut_params->ibuf;
8492 sym_op->cipher.data.offset = 0;
8493 sym_op->cipher.data.length = QUOTE_512_BYTES;
8495 /* Process crypto operation */
8496 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8498 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8500 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8501 "crypto operation processing failed");
8504 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8505 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8508 "Ciphertext data not as expected");
8510 return TEST_SUCCESS;
8512 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
8513 0xab, 0xab, 0xab, 0xab,
8514 0xab, 0xab, 0xab, 0xab,
8515 0xab, 0xab, 0xab, 0xab};
8517 test_null_auth_only_operation(void)
8519 struct crypto_testsuite_params *ts_params = &testsuite_params;
8520 struct crypto_unittest_params *ut_params = &unittest_params;
8523 /* Generate test mbuf data and space for digest */
8524 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8525 catch_22_quote, QUOTE_512_BYTES, 0);
8527 /* create a pointer for digest, but don't expect anything to be written
8528 * here in a NULL auth algo so no mbuf append done.
8530 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8532 /* prefill the memory pointed to by digest */
8533 memcpy(digest, orig_data, sizeof(orig_data));
8535 /* Setup HMAC Parameters */
8536 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8537 ut_params->auth_xform.next = NULL;
8539 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8540 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8542 ut_params->sess = rte_cryptodev_sym_session_create(
8543 ts_params->session_mpool);
8545 /* Create Crypto session*/
8546 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8547 ut_params->sess, &ut_params->auth_xform,
8548 ts_params->session_priv_mpool);
8549 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8551 /* Generate Crypto op data structure */
8552 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8553 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8554 TEST_ASSERT_NOT_NULL(ut_params->op,
8555 "Failed to allocate symmetric crypto operation struct");
8557 /* Set crypto operation data parameters */
8558 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8560 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8562 sym_op->m_src = ut_params->ibuf;
8564 sym_op->auth.data.offset = 0;
8565 sym_op->auth.data.length = QUOTE_512_BYTES;
8566 sym_op->auth.digest.data = digest;
8567 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8570 /* Process crypto operation */
8571 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8573 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8575 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8576 "crypto operation processing failed");
8577 /* Make sure memory pointed to by digest hasn't been overwritten */
8578 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8582 "Memory at digest ptr overwritten unexpectedly");
8584 return TEST_SUCCESS;
8589 test_null_cipher_auth_operation(void)
8591 struct crypto_testsuite_params *ts_params = &testsuite_params;
8592 struct crypto_unittest_params *ut_params = &unittest_params;
8595 /* Generate test mbuf data and space for digest */
8596 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8597 catch_22_quote, QUOTE_512_BYTES, 0);
8599 /* create a pointer for digest, but don't expect anything to be written
8600 * here in a NULL auth algo so no mbuf append done.
8602 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8604 /* prefill the memory pointed to by digest */
8605 memcpy(digest, orig_data, sizeof(orig_data));
8607 /* Setup Cipher Parameters */
8608 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8609 ut_params->cipher_xform.next = &ut_params->auth_xform;
8611 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8612 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8614 /* Setup HMAC Parameters */
8615 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8616 ut_params->auth_xform.next = NULL;
8618 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8619 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8621 ut_params->sess = rte_cryptodev_sym_session_create(
8622 ts_params->session_mpool);
8624 /* Create Crypto session*/
8625 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8626 ut_params->sess, &ut_params->cipher_xform,
8627 ts_params->session_priv_mpool);
8628 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8630 /* Generate Crypto op data structure */
8631 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8632 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8633 TEST_ASSERT_NOT_NULL(ut_params->op,
8634 "Failed to allocate symmetric crypto operation struct");
8636 /* Set crypto operation data parameters */
8637 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8639 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8641 sym_op->m_src = ut_params->ibuf;
8643 sym_op->cipher.data.offset = 0;
8644 sym_op->cipher.data.length = QUOTE_512_BYTES;
8646 sym_op->auth.data.offset = 0;
8647 sym_op->auth.data.length = QUOTE_512_BYTES;
8648 sym_op->auth.digest.data = digest;
8649 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8652 /* Process crypto operation */
8653 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8655 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8657 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8658 "crypto operation processing failed");
8661 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8662 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8665 "Ciphertext data not as expected");
8666 /* Make sure memory pointed to by digest hasn't been overwritten */
8667 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8671 "Memory at digest ptr overwritten unexpectedly");
8673 return TEST_SUCCESS;
8677 test_null_auth_cipher_operation(void)
8679 struct crypto_testsuite_params *ts_params = &testsuite_params;
8680 struct crypto_unittest_params *ut_params = &unittest_params;
8683 /* Generate test mbuf data */
8684 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8685 catch_22_quote, QUOTE_512_BYTES, 0);
8687 /* create a pointer for digest, but don't expect anything to be written
8688 * here in a NULL auth algo so no mbuf append done.
8690 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8692 /* prefill the memory pointed to by digest */
8693 memcpy(digest, orig_data, sizeof(orig_data));
8695 /* Setup Cipher Parameters */
8696 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8697 ut_params->cipher_xform.next = NULL;
8699 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8700 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8702 /* Setup HMAC Parameters */
8703 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8704 ut_params->auth_xform.next = &ut_params->cipher_xform;
8706 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8707 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8709 ut_params->sess = rte_cryptodev_sym_session_create(
8710 ts_params->session_mpool);
8712 /* Create Crypto session*/
8713 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8714 ut_params->sess, &ut_params->cipher_xform,
8715 ts_params->session_priv_mpool);
8716 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8718 /* Generate Crypto op data structure */
8719 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8720 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8721 TEST_ASSERT_NOT_NULL(ut_params->op,
8722 "Failed to allocate symmetric crypto operation struct");
8724 /* Set crypto operation data parameters */
8725 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8727 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8729 sym_op->m_src = ut_params->ibuf;
8731 sym_op->cipher.data.offset = 0;
8732 sym_op->cipher.data.length = QUOTE_512_BYTES;
8734 sym_op->auth.data.offset = 0;
8735 sym_op->auth.data.length = QUOTE_512_BYTES;
8736 sym_op->auth.digest.data = digest;
8737 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8740 /* Process crypto operation */
8741 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8743 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8745 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8746 "crypto operation processing failed");
8749 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8750 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8753 "Ciphertext data not as expected");
8754 /* Make sure memory pointed to by digest hasn't been overwritten */
8755 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8759 "Memory at digest ptr overwritten unexpectedly");
8761 return TEST_SUCCESS;
8766 test_null_invalid_operation(void)
8768 struct crypto_testsuite_params *ts_params = &testsuite_params;
8769 struct crypto_unittest_params *ut_params = &unittest_params;
8772 /* Setup Cipher Parameters */
8773 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8774 ut_params->cipher_xform.next = NULL;
8776 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
8777 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8779 ut_params->sess = rte_cryptodev_sym_session_create(
8780 ts_params->session_mpool);
8782 /* Create Crypto session*/
8783 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8784 ut_params->sess, &ut_params->cipher_xform,
8785 ts_params->session_priv_mpool);
8786 TEST_ASSERT(ret < 0,
8787 "Session creation succeeded unexpectedly");
8790 /* Setup HMAC Parameters */
8791 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8792 ut_params->auth_xform.next = NULL;
8794 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
8795 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8797 ut_params->sess = rte_cryptodev_sym_session_create(
8798 ts_params->session_mpool);
8800 /* Create Crypto session*/
8801 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8802 ut_params->sess, &ut_params->auth_xform,
8803 ts_params->session_priv_mpool);
8804 TEST_ASSERT(ret < 0,
8805 "Session creation succeeded unexpectedly");
8807 return TEST_SUCCESS;
8811 #define NULL_BURST_LENGTH (32)
8814 test_null_burst_operation(void)
8816 struct crypto_testsuite_params *ts_params = &testsuite_params;
8817 struct crypto_unittest_params *ut_params = &unittest_params;
8819 unsigned i, burst_len = NULL_BURST_LENGTH;
8821 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
8822 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
8824 /* Setup Cipher Parameters */
8825 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8826 ut_params->cipher_xform.next = &ut_params->auth_xform;
8828 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8829 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8831 /* Setup HMAC Parameters */
8832 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8833 ut_params->auth_xform.next = NULL;
8835 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8836 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8838 ut_params->sess = rte_cryptodev_sym_session_create(
8839 ts_params->session_mpool);
8841 /* Create Crypto session*/
8842 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8843 ut_params->sess, &ut_params->cipher_xform,
8844 ts_params->session_priv_mpool);
8845 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8847 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
8848 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
8849 burst_len, "failed to generate burst of crypto ops");
8851 /* Generate an operation for each mbuf in burst */
8852 for (i = 0; i < burst_len; i++) {
8853 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8855 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
8857 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
8861 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
8863 burst[i]->sym->m_src = m;
8866 /* Process crypto operation */
8867 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
8868 0, burst, burst_len),
8870 "Error enqueuing burst");
8872 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
8873 0, burst_dequeued, burst_len),
8875 "Error dequeuing burst");
8878 for (i = 0; i < burst_len; i++) {
8880 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
8881 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
8883 "data not as expected");
8885 rte_pktmbuf_free(burst[i]->sym->m_src);
8886 rte_crypto_op_free(burst[i]);
8889 return TEST_SUCCESS;
8893 generate_gmac_large_plaintext(uint8_t *data)
8897 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
8898 memcpy(&data[i], &data[0], 32);
8902 create_gmac_operation(enum rte_crypto_auth_operation op,
8903 const struct gmac_test_data *tdata)
8905 struct crypto_testsuite_params *ts_params = &testsuite_params;
8906 struct crypto_unittest_params *ut_params = &unittest_params;
8907 struct rte_crypto_sym_op *sym_op;
8909 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8911 /* Generate Crypto op data structure */
8912 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8913 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8914 TEST_ASSERT_NOT_NULL(ut_params->op,
8915 "Failed to allocate symmetric crypto operation struct");
8917 sym_op = ut_params->op->sym;
8919 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8920 ut_params->ibuf, tdata->gmac_tag.len);
8921 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8922 "no room to append digest");
8924 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8925 ut_params->ibuf, plaintext_pad_len);
8927 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
8928 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
8929 tdata->gmac_tag.len);
8930 debug_hexdump(stdout, "digest:",
8931 sym_op->auth.digest.data,
8932 tdata->gmac_tag.len);
8935 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8936 uint8_t *, IV_OFFSET);
8938 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8940 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
8942 sym_op->cipher.data.length = 0;
8943 sym_op->cipher.data.offset = 0;
8945 sym_op->auth.data.offset = 0;
8946 sym_op->auth.data.length = tdata->plaintext.len;
8951 static int create_gmac_session(uint8_t dev_id,
8952 const struct gmac_test_data *tdata,
8953 enum rte_crypto_auth_operation auth_op)
8955 uint8_t auth_key[tdata->key.len];
8957 struct crypto_testsuite_params *ts_params = &testsuite_params;
8958 struct crypto_unittest_params *ut_params = &unittest_params;
8960 memcpy(auth_key, tdata->key.data, tdata->key.len);
8962 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8963 ut_params->auth_xform.next = NULL;
8965 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
8966 ut_params->auth_xform.auth.op = auth_op;
8967 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
8968 ut_params->auth_xform.auth.key.length = tdata->key.len;
8969 ut_params->auth_xform.auth.key.data = auth_key;
8970 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
8971 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
8974 ut_params->sess = rte_cryptodev_sym_session_create(
8975 ts_params->session_mpool);
8977 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8978 &ut_params->auth_xform,
8979 ts_params->session_priv_mpool);
8981 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8987 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
8989 struct crypto_testsuite_params *ts_params = &testsuite_params;
8990 struct crypto_unittest_params *ut_params = &unittest_params;
8994 uint8_t *auth_tag, *plaintext;
8995 uint16_t plaintext_pad_len;
8997 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
8998 "No GMAC length in the source data");
9000 retval = create_gmac_session(ts_params->valid_devs[0],
9001 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
9006 if (tdata->plaintext.len > MBUF_SIZE)
9007 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9009 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9010 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9011 "Failed to allocate input buffer in mempool");
9013 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9014 rte_pktmbuf_tailroom(ut_params->ibuf));
9016 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9018 * Runtime generate the large plain text instead of use hard code
9019 * plain text vector. It is done to avoid create huge source file
9020 * with the test vector.
9022 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
9023 generate_gmac_large_plaintext(tdata->plaintext.data);
9025 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9027 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9029 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
9030 debug_hexdump(stdout, "plaintext:", plaintext,
9031 tdata->plaintext.len);
9033 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
9039 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9041 ut_params->op->sym->m_src = ut_params->ibuf;
9043 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9044 ut_params->op), "failed to process sym crypto op");
9046 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9047 "crypto op processing failed");
9049 if (ut_params->op->sym->m_dst) {
9050 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
9051 uint8_t *, plaintext_pad_len);
9053 auth_tag = plaintext + plaintext_pad_len;
9056 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
9058 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9060 tdata->gmac_tag.data,
9061 tdata->gmac_tag.len,
9062 "GMAC Generated auth tag not as expected");
9068 test_AES_GMAC_authentication_test_case_1(void)
9070 return test_AES_GMAC_authentication(&gmac_test_case_1);
9074 test_AES_GMAC_authentication_test_case_2(void)
9076 return test_AES_GMAC_authentication(&gmac_test_case_2);
9080 test_AES_GMAC_authentication_test_case_3(void)
9082 return test_AES_GMAC_authentication(&gmac_test_case_3);
9086 test_AES_GMAC_authentication_test_case_4(void)
9088 return test_AES_GMAC_authentication(&gmac_test_case_4);
9092 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
9094 struct crypto_testsuite_params *ts_params = &testsuite_params;
9095 struct crypto_unittest_params *ut_params = &unittest_params;
9097 uint32_t plaintext_pad_len;
9100 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
9101 "No GMAC length in the source data");
9103 retval = create_gmac_session(ts_params->valid_devs[0],
9104 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
9109 if (tdata->plaintext.len > MBUF_SIZE)
9110 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9112 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9113 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9114 "Failed to allocate input buffer in mempool");
9116 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9117 rte_pktmbuf_tailroom(ut_params->ibuf));
9119 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9122 * Runtime generate the large plain text instead of use hard code
9123 * plain text vector. It is done to avoid create huge source file
9124 * with the test vector.
9126 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
9127 generate_gmac_large_plaintext(tdata->plaintext.data);
9129 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9131 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9133 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
9134 debug_hexdump(stdout, "plaintext:", plaintext,
9135 tdata->plaintext.len);
9137 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
9143 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9145 ut_params->op->sym->m_src = ut_params->ibuf;
9147 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9148 ut_params->op), "failed to process sym crypto op");
9150 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9151 "crypto op processing failed");
9158 test_AES_GMAC_authentication_verify_test_case_1(void)
9160 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
9164 test_AES_GMAC_authentication_verify_test_case_2(void)
9166 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
9170 test_AES_GMAC_authentication_verify_test_case_3(void)
9172 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
9176 test_AES_GMAC_authentication_verify_test_case_4(void)
9178 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
9181 struct test_crypto_vector {
9182 enum rte_crypto_cipher_algorithm crypto_algo;
9195 const uint8_t *data;
9200 const uint8_t *data;
9204 enum rte_crypto_auth_algorithm auth_algo;
9212 const uint8_t *data;
9222 static const struct test_crypto_vector
9223 hmac_sha1_test_crypto_vector = {
9224 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
9226 .data = plaintext_hash,
9231 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
9232 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
9233 0xDE, 0xF4, 0xDE, 0xAD
9239 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
9240 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
9241 0x3F, 0x91, 0x64, 0x59
9247 static const struct test_crypto_vector
9248 aes128_gmac_test_vector = {
9249 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
9251 .data = plaintext_hash,
9256 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
9257 0x08, 0x09, 0x0A, 0x0B
9263 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
9264 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
9270 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
9271 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
9277 static const struct test_crypto_vector
9278 aes128cbc_hmac_sha1_test_vector = {
9279 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
9282 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
9283 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
9289 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
9290 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
9295 .data = plaintext_hash,
9299 .data = ciphertext512_aes128cbc,
9302 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
9305 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
9306 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
9307 0xDE, 0xF4, 0xDE, 0xAD
9313 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
9314 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
9315 0x18, 0x8C, 0x1D, 0x32
9322 data_corruption(uint8_t *data)
9328 tag_corruption(uint8_t *data, unsigned int tag_offset)
9330 data[tag_offset] += 1;
9334 create_auth_session(struct crypto_unittest_params *ut_params,
9336 const struct test_crypto_vector *reference,
9337 enum rte_crypto_auth_operation auth_op)
9339 struct crypto_testsuite_params *ts_params = &testsuite_params;
9340 uint8_t auth_key[reference->auth_key.len + 1];
9342 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
9344 /* Setup Authentication Parameters */
9345 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9346 ut_params->auth_xform.auth.op = auth_op;
9347 ut_params->auth_xform.next = NULL;
9348 ut_params->auth_xform.auth.algo = reference->auth_algo;
9349 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
9350 ut_params->auth_xform.auth.key.data = auth_key;
9351 ut_params->auth_xform.auth.digest_length = reference->digest.len;
9353 /* Create Crypto session*/
9354 ut_params->sess = rte_cryptodev_sym_session_create(
9355 ts_params->session_mpool);
9357 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
9358 &ut_params->auth_xform,
9359 ts_params->session_priv_mpool);
9361 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9367 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
9369 const struct test_crypto_vector *reference,
9370 enum rte_crypto_auth_operation auth_op,
9371 enum rte_crypto_cipher_operation cipher_op)
9373 struct crypto_testsuite_params *ts_params = &testsuite_params;
9374 uint8_t cipher_key[reference->cipher_key.len + 1];
9375 uint8_t auth_key[reference->auth_key.len + 1];
9377 memcpy(cipher_key, reference->cipher_key.data,
9378 reference->cipher_key.len);
9379 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
9381 /* Setup Authentication Parameters */
9382 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9383 ut_params->auth_xform.auth.op = auth_op;
9384 ut_params->auth_xform.auth.algo = reference->auth_algo;
9385 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
9386 ut_params->auth_xform.auth.key.data = auth_key;
9387 ut_params->auth_xform.auth.digest_length = reference->digest.len;
9389 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
9390 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
9391 ut_params->auth_xform.auth.iv.length = reference->iv.len;
9393 ut_params->auth_xform.next = &ut_params->cipher_xform;
9395 /* Setup Cipher Parameters */
9396 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9397 ut_params->cipher_xform.next = NULL;
9398 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
9399 ut_params->cipher_xform.cipher.op = cipher_op;
9400 ut_params->cipher_xform.cipher.key.data = cipher_key;
9401 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
9402 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9403 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
9406 /* Create Crypto session*/
9407 ut_params->sess = rte_cryptodev_sym_session_create(
9408 ts_params->session_mpool);
9410 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
9411 &ut_params->auth_xform,
9412 ts_params->session_priv_mpool);
9414 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9420 create_auth_operation(struct crypto_testsuite_params *ts_params,
9421 struct crypto_unittest_params *ut_params,
9422 const struct test_crypto_vector *reference,
9423 unsigned int auth_generate)
9425 /* Generate Crypto op data structure */
9426 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9427 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9428 TEST_ASSERT_NOT_NULL(ut_params->op,
9429 "Failed to allocate pktmbuf offload");
9431 /* Set crypto operation data parameters */
9432 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9434 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9436 /* set crypto operation source mbuf */
9437 sym_op->m_src = ut_params->ibuf;
9440 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9441 ut_params->ibuf, reference->digest.len);
9443 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9444 "no room to append auth tag");
9446 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9447 ut_params->ibuf, reference->plaintext.len);
9450 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9452 memcpy(sym_op->auth.digest.data,
9453 reference->digest.data,
9454 reference->digest.len);
9456 debug_hexdump(stdout, "digest:",
9457 sym_op->auth.digest.data,
9458 reference->digest.len);
9460 sym_op->auth.data.length = reference->plaintext.len;
9461 sym_op->auth.data.offset = 0;
9467 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
9468 struct crypto_unittest_params *ut_params,
9469 const struct test_crypto_vector *reference,
9470 unsigned int auth_generate)
9472 /* Generate Crypto op data structure */
9473 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9474 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9475 TEST_ASSERT_NOT_NULL(ut_params->op,
9476 "Failed to allocate pktmbuf offload");
9478 /* Set crypto operation data parameters */
9479 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9481 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9483 /* set crypto operation source mbuf */
9484 sym_op->m_src = ut_params->ibuf;
9487 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9488 ut_params->ibuf, reference->digest.len);
9490 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9491 "no room to append auth tag");
9493 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9494 ut_params->ibuf, reference->ciphertext.len);
9497 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9499 memcpy(sym_op->auth.digest.data,
9500 reference->digest.data,
9501 reference->digest.len);
9503 debug_hexdump(stdout, "digest:",
9504 sym_op->auth.digest.data,
9505 reference->digest.len);
9507 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
9508 reference->iv.data, reference->iv.len);
9510 sym_op->cipher.data.length = 0;
9511 sym_op->cipher.data.offset = 0;
9513 sym_op->auth.data.length = reference->plaintext.len;
9514 sym_op->auth.data.offset = 0;
9520 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
9521 struct crypto_unittest_params *ut_params,
9522 const struct test_crypto_vector *reference,
9523 unsigned int auth_generate)
9525 /* Generate Crypto op data structure */
9526 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9527 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9528 TEST_ASSERT_NOT_NULL(ut_params->op,
9529 "Failed to allocate pktmbuf offload");
9531 /* Set crypto operation data parameters */
9532 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9534 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9536 /* set crypto operation source mbuf */
9537 sym_op->m_src = ut_params->ibuf;
9540 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9541 ut_params->ibuf, reference->digest.len);
9543 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9544 "no room to append auth tag");
9546 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9547 ut_params->ibuf, reference->ciphertext.len);
9550 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9552 memcpy(sym_op->auth.digest.data,
9553 reference->digest.data,
9554 reference->digest.len);
9556 debug_hexdump(stdout, "digest:",
9557 sym_op->auth.digest.data,
9558 reference->digest.len);
9560 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
9561 reference->iv.data, reference->iv.len);
9563 sym_op->cipher.data.length = reference->ciphertext.len;
9564 sym_op->cipher.data.offset = 0;
9566 sym_op->auth.data.length = reference->ciphertext.len;
9567 sym_op->auth.data.offset = 0;
9573 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
9574 struct crypto_unittest_params *ut_params,
9575 const struct test_crypto_vector *reference)
9577 return create_auth_operation(ts_params, ut_params, reference, 0);
9581 create_auth_verify_GMAC_operation(
9582 struct crypto_testsuite_params *ts_params,
9583 struct crypto_unittest_params *ut_params,
9584 const struct test_crypto_vector *reference)
9586 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
9590 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
9591 struct crypto_unittest_params *ut_params,
9592 const struct test_crypto_vector *reference)
9594 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
9598 test_authentication_verify_fail_when_data_corruption(
9599 struct crypto_testsuite_params *ts_params,
9600 struct crypto_unittest_params *ut_params,
9601 const struct test_crypto_vector *reference,
9602 unsigned int data_corrupted)
9608 /* Create session */
9609 retval = create_auth_session(ut_params,
9610 ts_params->valid_devs[0],
9612 RTE_CRYPTO_AUTH_OP_VERIFY);
9616 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9617 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9618 "Failed to allocate input buffer in mempool");
9620 /* clear mbuf payload */
9621 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9622 rte_pktmbuf_tailroom(ut_params->ibuf));
9624 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9625 reference->plaintext.len);
9626 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9627 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
9629 debug_hexdump(stdout, "plaintext:", plaintext,
9630 reference->plaintext.len);
9632 /* Create operation */
9633 retval = create_auth_verify_operation(ts_params, ut_params, reference);
9639 data_corruption(plaintext);
9641 tag_corruption(plaintext, reference->plaintext.len);
9643 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9645 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9646 TEST_ASSERT_EQUAL(ut_params->op->status,
9647 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9648 "authentication not failed");
9650 ut_params->obuf = ut_params->op->sym->m_src;
9651 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9657 test_authentication_verify_GMAC_fail_when_corruption(
9658 struct crypto_testsuite_params *ts_params,
9659 struct crypto_unittest_params *ut_params,
9660 const struct test_crypto_vector *reference,
9661 unsigned int data_corrupted)
9666 /* Create session */
9667 retval = create_auth_cipher_session(ut_params,
9668 ts_params->valid_devs[0],
9670 RTE_CRYPTO_AUTH_OP_VERIFY,
9671 RTE_CRYPTO_CIPHER_OP_DECRYPT);
9675 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9676 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9677 "Failed to allocate input buffer in mempool");
9679 /* clear mbuf payload */
9680 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9681 rte_pktmbuf_tailroom(ut_params->ibuf));
9683 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9684 reference->plaintext.len);
9685 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9686 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
9688 debug_hexdump(stdout, "plaintext:", plaintext,
9689 reference->plaintext.len);
9691 /* Create operation */
9692 retval = create_auth_verify_GMAC_operation(ts_params,
9700 data_corruption(plaintext);
9702 tag_corruption(plaintext, reference->aad.len);
9704 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9706 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9707 TEST_ASSERT_EQUAL(ut_params->op->status,
9708 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9709 "authentication not failed");
9711 ut_params->obuf = ut_params->op->sym->m_src;
9712 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9718 test_authenticated_decryption_fail_when_corruption(
9719 struct crypto_testsuite_params *ts_params,
9720 struct crypto_unittest_params *ut_params,
9721 const struct test_crypto_vector *reference,
9722 unsigned int data_corrupted)
9726 uint8_t *ciphertext;
9728 /* Create session */
9729 retval = create_auth_cipher_session(ut_params,
9730 ts_params->valid_devs[0],
9732 RTE_CRYPTO_AUTH_OP_VERIFY,
9733 RTE_CRYPTO_CIPHER_OP_DECRYPT);
9737 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9738 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9739 "Failed to allocate input buffer in mempool");
9741 /* clear mbuf payload */
9742 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9743 rte_pktmbuf_tailroom(ut_params->ibuf));
9745 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9746 reference->ciphertext.len);
9747 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
9748 memcpy(ciphertext, reference->ciphertext.data,
9749 reference->ciphertext.len);
9751 /* Create operation */
9752 retval = create_cipher_auth_verify_operation(ts_params,
9760 data_corruption(ciphertext);
9762 tag_corruption(ciphertext, reference->ciphertext.len);
9764 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9767 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9768 TEST_ASSERT_EQUAL(ut_params->op->status,
9769 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9770 "authentication not failed");
9772 ut_params->obuf = ut_params->op->sym->m_src;
9773 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9779 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
9780 const struct aead_test_data *tdata,
9781 void *digest_mem, uint64_t digest_phys)
9783 struct crypto_testsuite_params *ts_params = &testsuite_params;
9784 struct crypto_unittest_params *ut_params = &unittest_params;
9786 const unsigned int auth_tag_len = tdata->auth_tag.len;
9787 const unsigned int iv_len = tdata->iv.len;
9788 unsigned int aad_len = tdata->aad.len;
9790 /* Generate Crypto op data structure */
9791 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9792 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9793 TEST_ASSERT_NOT_NULL(ut_params->op,
9794 "Failed to allocate symmetric crypto operation struct");
9796 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9798 sym_op->aead.digest.data = digest_mem;
9800 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
9801 "no room to append digest");
9803 sym_op->aead.digest.phys_addr = digest_phys;
9805 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
9806 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
9808 debug_hexdump(stdout, "digest:",
9809 sym_op->aead.digest.data,
9813 /* Append aad data */
9814 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
9815 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
9816 uint8_t *, IV_OFFSET);
9818 /* Copy IV 1 byte after the IV pointer, according to the API */
9819 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
9821 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
9823 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
9824 ut_params->ibuf, aad_len);
9825 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
9826 "no room to prepend aad");
9827 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
9830 memset(sym_op->aead.aad.data, 0, aad_len);
9831 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
9832 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
9834 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
9835 debug_hexdump(stdout, "aad:",
9836 sym_op->aead.aad.data, aad_len);
9838 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
9839 uint8_t *, IV_OFFSET);
9841 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
9843 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
9844 ut_params->ibuf, aad_len);
9845 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
9846 "no room to prepend aad");
9847 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
9850 memset(sym_op->aead.aad.data, 0, aad_len);
9851 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
9853 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
9854 debug_hexdump(stdout, "aad:",
9855 sym_op->aead.aad.data, aad_len);
9858 sym_op->aead.data.length = tdata->plaintext.len;
9859 sym_op->aead.data.offset = aad_len;
9864 #define SGL_MAX_NO 16
9867 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
9868 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
9870 struct crypto_testsuite_params *ts_params = &testsuite_params;
9871 struct crypto_unittest_params *ut_params = &unittest_params;
9872 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
9875 int to_trn_tbl[SGL_MAX_NO];
9877 unsigned int trn_data = 0;
9878 uint8_t *plaintext, *ciphertext, *auth_tag;
9880 if (fragsz > tdata->plaintext.len)
9881 fragsz = tdata->plaintext.len;
9883 uint16_t plaintext_len = fragsz;
9884 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
9886 if (fragsz_oop > tdata->plaintext.len)
9887 frag_size_oop = tdata->plaintext.len;
9890 void *digest_mem = NULL;
9892 uint32_t prepend_len = tdata->aad.len;
9894 if (tdata->plaintext.len % fragsz != 0) {
9895 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
9898 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
9903 * For out-op-place we need to alloc another mbuf
9906 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9907 rte_pktmbuf_append(ut_params->obuf,
9908 frag_size_oop + prepend_len);
9909 buf_oop = ut_params->obuf;
9912 /* Create AEAD session */
9913 retval = create_aead_session(ts_params->valid_devs[0],
9915 RTE_CRYPTO_AEAD_OP_ENCRYPT,
9916 tdata->key.data, tdata->key.len,
9917 tdata->aad.len, tdata->auth_tag.len,
9922 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9924 /* clear mbuf payload */
9925 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9926 rte_pktmbuf_tailroom(ut_params->ibuf));
9928 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9931 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
9933 trn_data += plaintext_len;
9935 buf = ut_params->ibuf;
9938 * Loop until no more fragments
9941 while (trn_data < tdata->plaintext.len) {
9943 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
9944 (tdata->plaintext.len - trn_data) : fragsz;
9946 to_trn_tbl[ecx++] = to_trn;
9948 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9951 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
9952 rte_pktmbuf_tailroom(buf));
9955 if (oop && !fragsz_oop) {
9956 buf_last_oop = buf_oop->next =
9957 rte_pktmbuf_alloc(ts_params->mbuf_pool);
9958 buf_oop = buf_oop->next;
9959 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
9960 0, rte_pktmbuf_tailroom(buf_oop));
9961 rte_pktmbuf_append(buf_oop, to_trn);
9964 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
9967 memcpy(plaintext, tdata->plaintext.data + trn_data,
9970 if (trn_data == tdata->plaintext.len) {
9973 digest_mem = rte_pktmbuf_append(buf_oop,
9974 tdata->auth_tag.len);
9976 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
9977 tdata->auth_tag.len);
9981 uint64_t digest_phys = 0;
9983 ut_params->ibuf->nb_segs = segs;
9986 if (fragsz_oop && oop) {
9990 if (frag_size_oop == tdata->plaintext.len) {
9991 digest_mem = rte_pktmbuf_append(ut_params->obuf,
9992 tdata->auth_tag.len);
9994 digest_phys = rte_pktmbuf_iova_offset(
9996 tdata->plaintext.len + prepend_len);
9999 trn_data = frag_size_oop;
10000 while (trn_data < tdata->plaintext.len) {
10003 (tdata->plaintext.len - trn_data <
10005 (tdata->plaintext.len - trn_data) :
10008 to_trn_tbl[ecx++] = to_trn;
10010 buf_last_oop = buf_oop->next =
10011 rte_pktmbuf_alloc(ts_params->mbuf_pool);
10012 buf_oop = buf_oop->next;
10013 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
10014 0, rte_pktmbuf_tailroom(buf_oop));
10015 rte_pktmbuf_append(buf_oop, to_trn);
10017 trn_data += to_trn;
10019 if (trn_data == tdata->plaintext.len) {
10020 digest_mem = rte_pktmbuf_append(buf_oop,
10021 tdata->auth_tag.len);
10025 ut_params->obuf->nb_segs = segs;
10029 * Place digest at the end of the last buffer
10032 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
10033 if (oop && buf_last_oop)
10034 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
10036 if (!digest_mem && !oop) {
10037 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10038 + tdata->auth_tag.len);
10039 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
10040 tdata->plaintext.len);
10043 /* Create AEAD operation */
10044 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
10045 tdata, digest_mem, digest_phys);
10050 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10052 ut_params->op->sym->m_src = ut_params->ibuf;
10054 ut_params->op->sym->m_dst = ut_params->obuf;
10056 /* Process crypto operation */
10057 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10058 ut_params->op), "failed to process sym crypto op");
10060 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10061 "crypto op processing failed");
10064 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10065 uint8_t *, prepend_len);
10067 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10068 uint8_t *, prepend_len);
10072 fragsz = fragsz_oop;
10074 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10076 tdata->ciphertext.data,
10078 "Ciphertext data not as expected");
10080 buf = ut_params->op->sym->m_src->next;
10082 buf = ut_params->op->sym->m_dst->next;
10084 unsigned int off = fragsz;
10088 ciphertext = rte_pktmbuf_mtod(buf,
10091 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10093 tdata->ciphertext.data + off,
10095 "Ciphertext data not as expected");
10097 off += to_trn_tbl[ecx++];
10101 auth_tag = digest_mem;
10102 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10104 tdata->auth_tag.data,
10105 tdata->auth_tag.len,
10106 "Generated auth tag not as expected");
10112 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
10114 return test_authenticated_encryption_SGL(
10115 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
10119 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
10121 return test_authenticated_encryption_SGL(
10122 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
10126 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
10128 return test_authenticated_encryption_SGL(
10129 &gcm_test_case_8, OUT_OF_PLACE, 400,
10130 gcm_test_case_8.plaintext.len);
10134 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
10137 return test_authenticated_encryption_SGL(
10138 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
10142 test_authentication_verify_fail_when_data_corrupted(
10143 struct crypto_testsuite_params *ts_params,
10144 struct crypto_unittest_params *ut_params,
10145 const struct test_crypto_vector *reference)
10147 return test_authentication_verify_fail_when_data_corruption(
10148 ts_params, ut_params, reference, 1);
10152 test_authentication_verify_fail_when_tag_corrupted(
10153 struct crypto_testsuite_params *ts_params,
10154 struct crypto_unittest_params *ut_params,
10155 const struct test_crypto_vector *reference)
10157 return test_authentication_verify_fail_when_data_corruption(
10158 ts_params, ut_params, reference, 0);
10162 test_authentication_verify_GMAC_fail_when_data_corrupted(
10163 struct crypto_testsuite_params *ts_params,
10164 struct crypto_unittest_params *ut_params,
10165 const struct test_crypto_vector *reference)
10167 return test_authentication_verify_GMAC_fail_when_corruption(
10168 ts_params, ut_params, reference, 1);
10172 test_authentication_verify_GMAC_fail_when_tag_corrupted(
10173 struct crypto_testsuite_params *ts_params,
10174 struct crypto_unittest_params *ut_params,
10175 const struct test_crypto_vector *reference)
10177 return test_authentication_verify_GMAC_fail_when_corruption(
10178 ts_params, ut_params, reference, 0);
10182 test_authenticated_decryption_fail_when_data_corrupted(
10183 struct crypto_testsuite_params *ts_params,
10184 struct crypto_unittest_params *ut_params,
10185 const struct test_crypto_vector *reference)
10187 return test_authenticated_decryption_fail_when_corruption(
10188 ts_params, ut_params, reference, 1);
10192 test_authenticated_decryption_fail_when_tag_corrupted(
10193 struct crypto_testsuite_params *ts_params,
10194 struct crypto_unittest_params *ut_params,
10195 const struct test_crypto_vector *reference)
10197 return test_authenticated_decryption_fail_when_corruption(
10198 ts_params, ut_params, reference, 0);
10202 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
10204 return test_authentication_verify_fail_when_data_corrupted(
10205 &testsuite_params, &unittest_params,
10206 &hmac_sha1_test_crypto_vector);
10210 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
10212 return test_authentication_verify_fail_when_tag_corrupted(
10213 &testsuite_params, &unittest_params,
10214 &hmac_sha1_test_crypto_vector);
10218 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
10220 return test_authentication_verify_GMAC_fail_when_data_corrupted(
10221 &testsuite_params, &unittest_params,
10222 &aes128_gmac_test_vector);
10226 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
10228 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
10229 &testsuite_params, &unittest_params,
10230 &aes128_gmac_test_vector);
10234 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
10236 return test_authenticated_decryption_fail_when_data_corrupted(
10239 &aes128cbc_hmac_sha1_test_vector);
10243 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
10245 return test_authenticated_decryption_fail_when_tag_corrupted(
10248 &aes128cbc_hmac_sha1_test_vector);
10251 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
10253 /* global AESNI slave IDs for the scheduler test */
10254 uint8_t aesni_ids[2];
10257 test_scheduler_attach_slave_op(void)
10259 struct crypto_testsuite_params *ts_params = &testsuite_params;
10260 uint8_t sched_id = ts_params->valid_devs[0];
10261 uint32_t nb_devs, i, nb_devs_attached = 0;
10263 char vdev_name[32];
10265 /* create 2 AESNI_MB if necessary */
10266 nb_devs = rte_cryptodev_device_count_by_driver(
10267 rte_cryptodev_driver_id_get(
10268 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
10270 for (i = nb_devs; i < 2; i++) {
10271 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
10272 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
10274 ret = rte_vdev_init(vdev_name, NULL);
10276 TEST_ASSERT(ret == 0,
10277 "Failed to create instance %u of"
10279 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
10283 /* attach 2 AESNI_MB cdevs */
10284 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
10286 struct rte_cryptodev_info info;
10287 unsigned int session_size;
10289 rte_cryptodev_info_get(i, &info);
10290 if (info.driver_id != rte_cryptodev_driver_id_get(
10291 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
10294 session_size = rte_cryptodev_sym_get_private_session_size(i);
10296 * Create the session mempool again, since now there are new devices
10297 * to use the mempool.
10299 if (ts_params->session_mpool) {
10300 rte_mempool_free(ts_params->session_mpool);
10301 ts_params->session_mpool = NULL;
10303 if (ts_params->session_priv_mpool) {
10304 rte_mempool_free(ts_params->session_priv_mpool);
10305 ts_params->session_priv_mpool = NULL;
10308 if (info.sym.max_nb_sessions != 0 &&
10309 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
10310 RTE_LOG(ERR, USER1,
10311 "Device does not support "
10312 "at least %u sessions\n",
10314 return TEST_FAILED;
10317 * Create mempool with maximum number of sessions,
10318 * to include the session headers
10320 if (ts_params->session_mpool == NULL) {
10321 ts_params->session_mpool =
10322 rte_cryptodev_sym_session_pool_create(
10324 MAX_NB_SESSIONS, 0, 0, 0,
10326 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
10327 "session mempool allocation failed");
10331 * Create mempool with maximum number of sessions,
10332 * to include device specific session private data
10334 if (ts_params->session_priv_mpool == NULL) {
10335 ts_params->session_priv_mpool = rte_mempool_create(
10336 "test_sess_mp_priv",
10339 0, 0, NULL, NULL, NULL,
10340 NULL, SOCKET_ID_ANY,
10343 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
10344 "session mempool allocation failed");
10347 ts_params->qp_conf.mp_session = ts_params->session_mpool;
10348 ts_params->qp_conf.mp_session_private =
10349 ts_params->session_priv_mpool;
10351 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
10354 TEST_ASSERT(ret == 0,
10355 "Failed to attach device %u of pmd : %s", i,
10356 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
10358 aesni_ids[nb_devs_attached] = (uint8_t)i;
10360 nb_devs_attached++;
10367 test_scheduler_detach_slave_op(void)
10369 struct crypto_testsuite_params *ts_params = &testsuite_params;
10370 uint8_t sched_id = ts_params->valid_devs[0];
10374 for (i = 0; i < 2; i++) {
10375 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
10377 TEST_ASSERT(ret == 0,
10378 "Failed to detach device %u", aesni_ids[i]);
10385 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
10387 struct crypto_testsuite_params *ts_params = &testsuite_params;
10388 uint8_t sched_id = ts_params->valid_devs[0];
10390 return rte_cryptodev_scheduler_mode_set(sched_id,
10395 test_scheduler_mode_roundrobin_op(void)
10397 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
10398 0, "Failed to set roundrobin mode");
10404 test_scheduler_mode_multicore_op(void)
10406 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
10407 0, "Failed to set multicore mode");
10413 test_scheduler_mode_failover_op(void)
10415 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
10416 0, "Failed to set failover mode");
10422 test_scheduler_mode_pkt_size_distr_op(void)
10424 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
10425 0, "Failed to set pktsize mode");
10430 static struct unit_test_suite cryptodev_scheduler_testsuite = {
10431 .suite_name = "Crypto Device Scheduler Unit Test Suite",
10432 .setup = testsuite_setup,
10433 .teardown = testsuite_teardown,
10434 .unit_test_cases = {
10436 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10437 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
10438 TEST_CASE_ST(ut_setup, ut_teardown,
10439 test_AES_chain_scheduler_all),
10440 TEST_CASE_ST(ut_setup, ut_teardown,
10441 test_AES_cipheronly_scheduler_all),
10442 TEST_CASE_ST(ut_setup, ut_teardown,
10443 test_authonly_scheduler_all),
10444 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10447 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10448 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
10449 TEST_CASE_ST(ut_setup, ut_teardown,
10450 test_AES_chain_scheduler_all),
10451 TEST_CASE_ST(ut_setup, ut_teardown,
10452 test_AES_cipheronly_scheduler_all),
10453 TEST_CASE_ST(ut_setup, ut_teardown,
10454 test_authonly_scheduler_all),
10455 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10458 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10459 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
10460 TEST_CASE_ST(ut_setup, ut_teardown,
10461 test_AES_chain_scheduler_all),
10462 TEST_CASE_ST(ut_setup, ut_teardown,
10463 test_AES_cipheronly_scheduler_all),
10464 TEST_CASE_ST(ut_setup, ut_teardown,
10465 test_authonly_scheduler_all),
10466 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10469 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10470 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
10471 TEST_CASE_ST(ut_setup, ut_teardown,
10472 test_AES_chain_scheduler_all),
10473 TEST_CASE_ST(ut_setup, ut_teardown,
10474 test_AES_cipheronly_scheduler_all),
10475 TEST_CASE_ST(ut_setup, ut_teardown,
10476 test_authonly_scheduler_all),
10477 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10479 TEST_CASES_END() /**< NULL terminate unit test array */
10483 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
10485 static struct unit_test_suite cryptodev_qat_testsuite = {
10486 .suite_name = "Crypto QAT Unit Test Suite",
10487 .setup = testsuite_setup,
10488 .teardown = testsuite_teardown,
10489 .unit_test_cases = {
10490 TEST_CASE_ST(ut_setup, ut_teardown,
10491 test_device_configure_invalid_dev_id),
10492 TEST_CASE_ST(ut_setup, ut_teardown,
10493 test_device_configure_invalid_queue_pair_ids),
10494 TEST_CASE_ST(ut_setup, ut_teardown,
10495 test_queue_pair_descriptor_setup),
10496 TEST_CASE_ST(ut_setup, ut_teardown,
10497 test_multi_session),
10499 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
10500 TEST_CASE_ST(ut_setup, ut_teardown,
10501 test_AES_cipheronly_qat_all),
10502 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
10503 TEST_CASE_ST(ut_setup, ut_teardown,
10504 test_3DES_cipheronly_qat_all),
10505 TEST_CASE_ST(ut_setup, ut_teardown,
10506 test_DES_cipheronly_qat_all),
10507 TEST_CASE_ST(ut_setup, ut_teardown,
10508 test_AES_docsis_qat_all),
10509 TEST_CASE_ST(ut_setup, ut_teardown,
10510 test_DES_docsis_qat_all),
10511 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
10512 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
10514 /** AES CCM Authenticated Encryption 128 bits key */
10515 TEST_CASE_ST(ut_setup, ut_teardown,
10516 test_AES_CCM_authenticated_encryption_test_case_128_1),
10517 TEST_CASE_ST(ut_setup, ut_teardown,
10518 test_AES_CCM_authenticated_encryption_test_case_128_2),
10519 TEST_CASE_ST(ut_setup, ut_teardown,
10520 test_AES_CCM_authenticated_encryption_test_case_128_3),
10522 /** AES CCM Authenticated Decryption 128 bits key*/
10523 TEST_CASE_ST(ut_setup, ut_teardown,
10524 test_AES_CCM_authenticated_decryption_test_case_128_1),
10525 TEST_CASE_ST(ut_setup, ut_teardown,
10526 test_AES_CCM_authenticated_decryption_test_case_128_2),
10527 TEST_CASE_ST(ut_setup, ut_teardown,
10528 test_AES_CCM_authenticated_decryption_test_case_128_3),
10530 /** AES GCM Authenticated Encryption */
10531 TEST_CASE_ST(ut_setup, ut_teardown,
10532 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
10533 TEST_CASE_ST(ut_setup, ut_teardown,
10534 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
10535 TEST_CASE_ST(ut_setup, ut_teardown,
10536 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
10537 TEST_CASE_ST(ut_setup, ut_teardown,
10538 test_AES_GCM_authenticated_encryption_test_case_1),
10539 TEST_CASE_ST(ut_setup, ut_teardown,
10540 test_AES_GCM_authenticated_encryption_test_case_2),
10541 TEST_CASE_ST(ut_setup, ut_teardown,
10542 test_AES_GCM_authenticated_encryption_test_case_3),
10543 TEST_CASE_ST(ut_setup, ut_teardown,
10544 test_AES_GCM_authenticated_encryption_test_case_4),
10545 TEST_CASE_ST(ut_setup, ut_teardown,
10546 test_AES_GCM_authenticated_encryption_test_case_5),
10547 TEST_CASE_ST(ut_setup, ut_teardown,
10548 test_AES_GCM_authenticated_encryption_test_case_6),
10549 TEST_CASE_ST(ut_setup, ut_teardown,
10550 test_AES_GCM_authenticated_encryption_test_case_7),
10552 /** AES GCM Authenticated Decryption */
10553 TEST_CASE_ST(ut_setup, ut_teardown,
10554 test_AES_GCM_authenticated_decryption_test_case_1),
10555 TEST_CASE_ST(ut_setup, ut_teardown,
10556 test_AES_GCM_authenticated_decryption_test_case_2),
10557 TEST_CASE_ST(ut_setup, ut_teardown,
10558 test_AES_GCM_authenticated_decryption_test_case_3),
10559 TEST_CASE_ST(ut_setup, ut_teardown,
10560 test_AES_GCM_authenticated_decryption_test_case_4),
10561 TEST_CASE_ST(ut_setup, ut_teardown,
10562 test_AES_GCM_authenticated_decryption_test_case_5),
10563 TEST_CASE_ST(ut_setup, ut_teardown,
10564 test_AES_GCM_authenticated_decryption_test_case_6),
10565 TEST_CASE_ST(ut_setup, ut_teardown,
10566 test_AES_GCM_authenticated_decryption_test_case_7),
10568 /** AES GCM Authenticated Encryption 192 bits key */
10569 TEST_CASE_ST(ut_setup, ut_teardown,
10570 test_AES_GCM_auth_encryption_test_case_192_1),
10571 TEST_CASE_ST(ut_setup, ut_teardown,
10572 test_AES_GCM_auth_encryption_test_case_192_2),
10573 TEST_CASE_ST(ut_setup, ut_teardown,
10574 test_AES_GCM_auth_encryption_test_case_192_3),
10575 TEST_CASE_ST(ut_setup, ut_teardown,
10576 test_AES_GCM_auth_encryption_test_case_192_4),
10577 TEST_CASE_ST(ut_setup, ut_teardown,
10578 test_AES_GCM_auth_encryption_test_case_192_5),
10579 TEST_CASE_ST(ut_setup, ut_teardown,
10580 test_AES_GCM_auth_encryption_test_case_192_6),
10581 TEST_CASE_ST(ut_setup, ut_teardown,
10582 test_AES_GCM_auth_encryption_test_case_192_7),
10584 /** AES GCM Authenticated Decryption 192 bits key */
10585 TEST_CASE_ST(ut_setup, ut_teardown,
10586 test_AES_GCM_auth_decryption_test_case_192_1),
10587 TEST_CASE_ST(ut_setup, ut_teardown,
10588 test_AES_GCM_auth_decryption_test_case_192_2),
10589 TEST_CASE_ST(ut_setup, ut_teardown,
10590 test_AES_GCM_auth_decryption_test_case_192_3),
10591 TEST_CASE_ST(ut_setup, ut_teardown,
10592 test_AES_GCM_auth_decryption_test_case_192_4),
10593 TEST_CASE_ST(ut_setup, ut_teardown,
10594 test_AES_GCM_auth_decryption_test_case_192_5),
10595 TEST_CASE_ST(ut_setup, ut_teardown,
10596 test_AES_GCM_auth_decryption_test_case_192_6),
10597 TEST_CASE_ST(ut_setup, ut_teardown,
10598 test_AES_GCM_auth_decryption_test_case_192_7),
10600 /** AES GCM Authenticated Encryption 256 bits key */
10601 TEST_CASE_ST(ut_setup, ut_teardown,
10602 test_AES_GCM_auth_encryption_test_case_256_1),
10603 TEST_CASE_ST(ut_setup, ut_teardown,
10604 test_AES_GCM_auth_encryption_test_case_256_2),
10605 TEST_CASE_ST(ut_setup, ut_teardown,
10606 test_AES_GCM_auth_encryption_test_case_256_3),
10607 TEST_CASE_ST(ut_setup, ut_teardown,
10608 test_AES_GCM_auth_encryption_test_case_256_4),
10609 TEST_CASE_ST(ut_setup, ut_teardown,
10610 test_AES_GCM_auth_encryption_test_case_256_5),
10611 TEST_CASE_ST(ut_setup, ut_teardown,
10612 test_AES_GCM_auth_encryption_test_case_256_6),
10613 TEST_CASE_ST(ut_setup, ut_teardown,
10614 test_AES_GCM_auth_encryption_test_case_256_7),
10616 /** AES GMAC Authentication */
10617 TEST_CASE_ST(ut_setup, ut_teardown,
10618 test_AES_GMAC_authentication_test_case_1),
10619 TEST_CASE_ST(ut_setup, ut_teardown,
10620 test_AES_GMAC_authentication_verify_test_case_1),
10621 TEST_CASE_ST(ut_setup, ut_teardown,
10622 test_AES_GMAC_authentication_test_case_2),
10623 TEST_CASE_ST(ut_setup, ut_teardown,
10624 test_AES_GMAC_authentication_verify_test_case_2),
10625 TEST_CASE_ST(ut_setup, ut_teardown,
10626 test_AES_GMAC_authentication_test_case_3),
10627 TEST_CASE_ST(ut_setup, ut_teardown,
10628 test_AES_GMAC_authentication_verify_test_case_3),
10630 /** SNOW 3G encrypt only (UEA2) */
10631 TEST_CASE_ST(ut_setup, ut_teardown,
10632 test_snow3g_encryption_test_case_1),
10633 TEST_CASE_ST(ut_setup, ut_teardown,
10634 test_snow3g_encryption_test_case_2),
10635 TEST_CASE_ST(ut_setup, ut_teardown,
10636 test_snow3g_encryption_test_case_3),
10637 TEST_CASE_ST(ut_setup, ut_teardown,
10638 test_snow3g_encryption_test_case_4),
10639 TEST_CASE_ST(ut_setup, ut_teardown,
10640 test_snow3g_encryption_test_case_5),
10642 TEST_CASE_ST(ut_setup, ut_teardown,
10643 test_snow3g_encryption_test_case_1_oop),
10644 TEST_CASE_ST(ut_setup, ut_teardown,
10645 test_snow3g_decryption_test_case_1_oop),
10647 /** SNOW 3G generate auth, then encrypt (UEA2) */
10648 TEST_CASE_ST(ut_setup, ut_teardown,
10649 test_snow3g_auth_cipher_test_case_1),
10650 TEST_CASE_ST(ut_setup, ut_teardown,
10651 test_snow3g_auth_cipher_test_case_2),
10652 TEST_CASE_ST(ut_setup, ut_teardown,
10653 test_snow3g_auth_cipher_test_case_2_oop),
10654 TEST_CASE_ST(ut_setup, ut_teardown,
10655 test_snow3g_auth_cipher_part_digest_enc),
10656 TEST_CASE_ST(ut_setup, ut_teardown,
10657 test_snow3g_auth_cipher_part_digest_enc_oop),
10658 TEST_CASE_ST(ut_setup, ut_teardown,
10659 test_snow3g_auth_cipher_test_case_3_sgl),
10660 TEST_CASE_ST(ut_setup, ut_teardown,
10661 test_snow3g_auth_cipher_test_case_3_oop_sgl),
10662 TEST_CASE_ST(ut_setup, ut_teardown,
10663 test_snow3g_auth_cipher_part_digest_enc_sgl),
10664 TEST_CASE_ST(ut_setup, ut_teardown,
10665 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
10667 /** SNOW 3G decrypt (UEA2), then verify auth */
10668 TEST_CASE_ST(ut_setup, ut_teardown,
10669 test_snow3g_auth_cipher_verify_test_case_1),
10670 TEST_CASE_ST(ut_setup, ut_teardown,
10671 test_snow3g_auth_cipher_verify_test_case_2),
10672 TEST_CASE_ST(ut_setup, ut_teardown,
10673 test_snow3g_auth_cipher_verify_test_case_2_oop),
10674 TEST_CASE_ST(ut_setup, ut_teardown,
10675 test_snow3g_auth_cipher_verify_part_digest_enc),
10676 TEST_CASE_ST(ut_setup, ut_teardown,
10677 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
10678 TEST_CASE_ST(ut_setup, ut_teardown,
10679 test_snow3g_auth_cipher_verify_test_case_3_sgl),
10680 TEST_CASE_ST(ut_setup, ut_teardown,
10681 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
10682 TEST_CASE_ST(ut_setup, ut_teardown,
10683 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
10684 TEST_CASE_ST(ut_setup, ut_teardown,
10685 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
10687 /** SNOW 3G decrypt only (UEA2) */
10688 TEST_CASE_ST(ut_setup, ut_teardown,
10689 test_snow3g_decryption_test_case_1),
10690 TEST_CASE_ST(ut_setup, ut_teardown,
10691 test_snow3g_decryption_test_case_2),
10692 TEST_CASE_ST(ut_setup, ut_teardown,
10693 test_snow3g_decryption_test_case_3),
10694 TEST_CASE_ST(ut_setup, ut_teardown,
10695 test_snow3g_decryption_test_case_4),
10696 TEST_CASE_ST(ut_setup, ut_teardown,
10697 test_snow3g_decryption_test_case_5),
10698 TEST_CASE_ST(ut_setup, ut_teardown,
10699 test_snow3g_decryption_with_digest_test_case_1),
10700 TEST_CASE_ST(ut_setup, ut_teardown,
10701 test_snow3g_hash_generate_test_case_1),
10702 TEST_CASE_ST(ut_setup, ut_teardown,
10703 test_snow3g_hash_generate_test_case_2),
10704 TEST_CASE_ST(ut_setup, ut_teardown,
10705 test_snow3g_hash_generate_test_case_3),
10706 TEST_CASE_ST(ut_setup, ut_teardown,
10707 test_snow3g_hash_verify_test_case_1),
10708 TEST_CASE_ST(ut_setup, ut_teardown,
10709 test_snow3g_hash_verify_test_case_2),
10710 TEST_CASE_ST(ut_setup, ut_teardown,
10711 test_snow3g_hash_verify_test_case_3),
10712 TEST_CASE_ST(ut_setup, ut_teardown,
10713 test_snow3g_cipher_auth_test_case_1),
10714 TEST_CASE_ST(ut_setup, ut_teardown,
10715 test_snow3g_auth_cipher_with_digest_test_case_1),
10717 /** ZUC encrypt only (EEA3) */
10718 TEST_CASE_ST(ut_setup, ut_teardown,
10719 test_zuc_encryption_test_case_1),
10720 TEST_CASE_ST(ut_setup, ut_teardown,
10721 test_zuc_encryption_test_case_2),
10722 TEST_CASE_ST(ut_setup, ut_teardown,
10723 test_zuc_encryption_test_case_3),
10724 TEST_CASE_ST(ut_setup, ut_teardown,
10725 test_zuc_encryption_test_case_4),
10726 TEST_CASE_ST(ut_setup, ut_teardown,
10727 test_zuc_encryption_test_case_5),
10729 /** ZUC authenticate (EIA3) */
10730 TEST_CASE_ST(ut_setup, ut_teardown,
10731 test_zuc_hash_generate_test_case_6),
10732 TEST_CASE_ST(ut_setup, ut_teardown,
10733 test_zuc_hash_generate_test_case_7),
10734 TEST_CASE_ST(ut_setup, ut_teardown,
10735 test_zuc_hash_generate_test_case_8),
10737 /** ZUC alg-chain (EEA3/EIA3) */
10738 TEST_CASE_ST(ut_setup, ut_teardown,
10739 test_zuc_cipher_auth_test_case_1),
10740 TEST_CASE_ST(ut_setup, ut_teardown,
10741 test_zuc_cipher_auth_test_case_2),
10743 /** ZUC generate auth, then encrypt (EEA3) */
10744 TEST_CASE_ST(ut_setup, ut_teardown,
10745 test_zuc_auth_cipher_test_case_1),
10746 TEST_CASE_ST(ut_setup, ut_teardown,
10747 test_zuc_auth_cipher_test_case_1_oop),
10748 TEST_CASE_ST(ut_setup, ut_teardown,
10749 test_zuc_auth_cipher_test_case_1_sgl),
10750 TEST_CASE_ST(ut_setup, ut_teardown,
10751 test_zuc_auth_cipher_test_case_1_oop_sgl),
10753 /** ZUC decrypt (EEA3), then verify auth */
10754 TEST_CASE_ST(ut_setup, ut_teardown,
10755 test_zuc_auth_cipher_verify_test_case_1),
10756 TEST_CASE_ST(ut_setup, ut_teardown,
10757 test_zuc_auth_cipher_verify_test_case_1_oop),
10758 TEST_CASE_ST(ut_setup, ut_teardown,
10759 test_zuc_auth_cipher_verify_test_case_1_sgl),
10760 TEST_CASE_ST(ut_setup, ut_teardown,
10761 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
10763 /** HMAC_MD5 Authentication */
10764 TEST_CASE_ST(ut_setup, ut_teardown,
10765 test_MD5_HMAC_generate_case_1),
10766 TEST_CASE_ST(ut_setup, ut_teardown,
10767 test_MD5_HMAC_verify_case_1),
10768 TEST_CASE_ST(ut_setup, ut_teardown,
10769 test_MD5_HMAC_generate_case_2),
10770 TEST_CASE_ST(ut_setup, ut_teardown,
10771 test_MD5_HMAC_verify_case_2),
10773 /** NULL algo tests done in chain_all,
10774 * cipheronly and authonly suites
10777 /** KASUMI tests */
10778 TEST_CASE_ST(ut_setup, ut_teardown,
10779 test_kasumi_hash_generate_test_case_1),
10780 TEST_CASE_ST(ut_setup, ut_teardown,
10781 test_kasumi_hash_generate_test_case_2),
10782 TEST_CASE_ST(ut_setup, ut_teardown,
10783 test_kasumi_hash_generate_test_case_3),
10784 TEST_CASE_ST(ut_setup, ut_teardown,
10785 test_kasumi_hash_generate_test_case_4),
10786 TEST_CASE_ST(ut_setup, ut_teardown,
10787 test_kasumi_hash_generate_test_case_5),
10788 TEST_CASE_ST(ut_setup, ut_teardown,
10789 test_kasumi_hash_generate_test_case_6),
10791 TEST_CASE_ST(ut_setup, ut_teardown,
10792 test_kasumi_hash_verify_test_case_1),
10793 TEST_CASE_ST(ut_setup, ut_teardown,
10794 test_kasumi_hash_verify_test_case_2),
10795 TEST_CASE_ST(ut_setup, ut_teardown,
10796 test_kasumi_hash_verify_test_case_3),
10797 TEST_CASE_ST(ut_setup, ut_teardown,
10798 test_kasumi_hash_verify_test_case_4),
10799 TEST_CASE_ST(ut_setup, ut_teardown,
10800 test_kasumi_hash_verify_test_case_5),
10802 TEST_CASE_ST(ut_setup, ut_teardown,
10803 test_kasumi_encryption_test_case_1),
10804 TEST_CASE_ST(ut_setup, ut_teardown,
10805 test_kasumi_encryption_test_case_3),
10806 TEST_CASE_ST(ut_setup, ut_teardown,
10807 test_kasumi_cipher_auth_test_case_1),
10809 /** KASUMI generate auth, then encrypt (F8) */
10810 TEST_CASE_ST(ut_setup, ut_teardown,
10811 test_kasumi_auth_cipher_test_case_1),
10812 TEST_CASE_ST(ut_setup, ut_teardown,
10813 test_kasumi_auth_cipher_test_case_2),
10814 TEST_CASE_ST(ut_setup, ut_teardown,
10815 test_kasumi_auth_cipher_test_case_2_oop),
10816 TEST_CASE_ST(ut_setup, ut_teardown,
10817 test_kasumi_auth_cipher_test_case_2_sgl),
10818 TEST_CASE_ST(ut_setup, ut_teardown,
10819 test_kasumi_auth_cipher_test_case_2_oop_sgl),
10821 /** KASUMI decrypt (F8), then verify auth */
10822 TEST_CASE_ST(ut_setup, ut_teardown,
10823 test_kasumi_auth_cipher_verify_test_case_1),
10824 TEST_CASE_ST(ut_setup, ut_teardown,
10825 test_kasumi_auth_cipher_verify_test_case_2),
10826 TEST_CASE_ST(ut_setup, ut_teardown,
10827 test_kasumi_auth_cipher_verify_test_case_2_oop),
10828 TEST_CASE_ST(ut_setup, ut_teardown,
10829 test_kasumi_auth_cipher_verify_test_case_2_sgl),
10830 TEST_CASE_ST(ut_setup, ut_teardown,
10831 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
10833 /** Negative tests */
10834 TEST_CASE_ST(ut_setup, ut_teardown,
10835 authentication_verify_HMAC_SHA1_fail_data_corrupt),
10836 TEST_CASE_ST(ut_setup, ut_teardown,
10837 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
10838 TEST_CASE_ST(ut_setup, ut_teardown,
10839 authentication_verify_AES128_GMAC_fail_data_corrupt),
10840 TEST_CASE_ST(ut_setup, ut_teardown,
10841 authentication_verify_AES128_GMAC_fail_tag_corrupt),
10842 TEST_CASE_ST(ut_setup, ut_teardown,
10843 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10844 TEST_CASE_ST(ut_setup, ut_teardown,
10845 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10847 TEST_CASES_END() /**< NULL terminate unit test array */
10851 static struct unit_test_suite cryptodev_virtio_testsuite = {
10852 .suite_name = "Crypto VIRTIO Unit Test Suite",
10853 .setup = testsuite_setup,
10854 .teardown = testsuite_teardown,
10855 .unit_test_cases = {
10856 TEST_CASE_ST(ut_setup, ut_teardown,
10857 test_AES_cipheronly_virtio_all),
10859 TEST_CASES_END() /**< NULL terminate unit test array */
10863 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
10864 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
10865 .setup = testsuite_setup,
10866 .teardown = testsuite_teardown,
10867 .unit_test_cases = {
10868 #if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0)
10869 TEST_CASE_ST(ut_setup, ut_teardown,
10870 test_AES_GCM_authenticated_encryption_test_case_1),
10871 TEST_CASE_ST(ut_setup, ut_teardown,
10872 test_AES_GCM_authenticated_encryption_test_case_2),
10873 TEST_CASE_ST(ut_setup, ut_teardown,
10874 test_AES_GCM_authenticated_encryption_test_case_3),
10875 TEST_CASE_ST(ut_setup, ut_teardown,
10876 test_AES_GCM_authenticated_encryption_test_case_4),
10877 TEST_CASE_ST(ut_setup, ut_teardown,
10878 test_AES_GCM_authenticated_encryption_test_case_5),
10879 TEST_CASE_ST(ut_setup, ut_teardown,
10880 test_AES_GCM_authenticated_encryption_test_case_6),
10881 TEST_CASE_ST(ut_setup, ut_teardown,
10882 test_AES_GCM_authenticated_encryption_test_case_7),
10884 /** AES GCM Authenticated Decryption */
10885 TEST_CASE_ST(ut_setup, ut_teardown,
10886 test_AES_GCM_authenticated_decryption_test_case_1),
10887 TEST_CASE_ST(ut_setup, ut_teardown,
10888 test_AES_GCM_authenticated_decryption_test_case_2),
10889 TEST_CASE_ST(ut_setup, ut_teardown,
10890 test_AES_GCM_authenticated_decryption_test_case_3),
10891 TEST_CASE_ST(ut_setup, ut_teardown,
10892 test_AES_GCM_authenticated_decryption_test_case_4),
10893 TEST_CASE_ST(ut_setup, ut_teardown,
10894 test_AES_GCM_authenticated_decryption_test_case_5),
10895 TEST_CASE_ST(ut_setup, ut_teardown,
10896 test_AES_GCM_authenticated_decryption_test_case_6),
10897 TEST_CASE_ST(ut_setup, ut_teardown,
10898 test_AES_GCM_authenticated_decryption_test_case_7),
10900 /** AES GCM Authenticated Encryption 192 bits key */
10901 TEST_CASE_ST(ut_setup, ut_teardown,
10902 test_AES_GCM_auth_encryption_test_case_192_1),
10903 TEST_CASE_ST(ut_setup, ut_teardown,
10904 test_AES_GCM_auth_encryption_test_case_192_2),
10905 TEST_CASE_ST(ut_setup, ut_teardown,
10906 test_AES_GCM_auth_encryption_test_case_192_3),
10907 TEST_CASE_ST(ut_setup, ut_teardown,
10908 test_AES_GCM_auth_encryption_test_case_192_4),
10909 TEST_CASE_ST(ut_setup, ut_teardown,
10910 test_AES_GCM_auth_encryption_test_case_192_5),
10911 TEST_CASE_ST(ut_setup, ut_teardown,
10912 test_AES_GCM_auth_encryption_test_case_192_6),
10913 TEST_CASE_ST(ut_setup, ut_teardown,
10914 test_AES_GCM_auth_encryption_test_case_192_7),
10916 /** AES GCM Authenticated Decryption 192 bits key */
10917 TEST_CASE_ST(ut_setup, ut_teardown,
10918 test_AES_GCM_auth_decryption_test_case_192_1),
10919 TEST_CASE_ST(ut_setup, ut_teardown,
10920 test_AES_GCM_auth_decryption_test_case_192_2),
10921 TEST_CASE_ST(ut_setup, ut_teardown,
10922 test_AES_GCM_auth_decryption_test_case_192_3),
10923 TEST_CASE_ST(ut_setup, ut_teardown,
10924 test_AES_GCM_auth_decryption_test_case_192_4),
10925 TEST_CASE_ST(ut_setup, ut_teardown,
10926 test_AES_GCM_auth_decryption_test_case_192_5),
10927 TEST_CASE_ST(ut_setup, ut_teardown,
10928 test_AES_GCM_auth_decryption_test_case_192_6),
10929 TEST_CASE_ST(ut_setup, ut_teardown,
10930 test_AES_GCM_auth_decryption_test_case_192_7),
10932 /** AES GCM Authenticated Encryption 256 bits key */
10933 TEST_CASE_ST(ut_setup, ut_teardown,
10934 test_AES_GCM_auth_encryption_test_case_256_1),
10935 TEST_CASE_ST(ut_setup, ut_teardown,
10936 test_AES_GCM_auth_encryption_test_case_256_2),
10937 TEST_CASE_ST(ut_setup, ut_teardown,
10938 test_AES_GCM_auth_encryption_test_case_256_3),
10939 TEST_CASE_ST(ut_setup, ut_teardown,
10940 test_AES_GCM_auth_encryption_test_case_256_4),
10941 TEST_CASE_ST(ut_setup, ut_teardown,
10942 test_AES_GCM_auth_encryption_test_case_256_5),
10943 TEST_CASE_ST(ut_setup, ut_teardown,
10944 test_AES_GCM_auth_encryption_test_case_256_6),
10945 TEST_CASE_ST(ut_setup, ut_teardown,
10946 test_AES_GCM_auth_encryption_test_case_256_7),
10948 /** AES GCM Authenticated Decryption 256 bits key */
10949 TEST_CASE_ST(ut_setup, ut_teardown,
10950 test_AES_GCM_auth_decryption_test_case_256_1),
10951 TEST_CASE_ST(ut_setup, ut_teardown,
10952 test_AES_GCM_auth_decryption_test_case_256_2),
10953 TEST_CASE_ST(ut_setup, ut_teardown,
10954 test_AES_GCM_auth_decryption_test_case_256_3),
10955 TEST_CASE_ST(ut_setup, ut_teardown,
10956 test_AES_GCM_auth_decryption_test_case_256_4),
10957 TEST_CASE_ST(ut_setup, ut_teardown,
10958 test_AES_GCM_auth_decryption_test_case_256_5),
10959 TEST_CASE_ST(ut_setup, ut_teardown,
10960 test_AES_GCM_auth_decryption_test_case_256_6),
10961 TEST_CASE_ST(ut_setup, ut_teardown,
10962 test_AES_GCM_auth_decryption_test_case_256_7),
10964 /** AES GCM Authenticated Encryption big aad size */
10965 TEST_CASE_ST(ut_setup, ut_teardown,
10966 test_AES_GCM_auth_encryption_test_case_aad_1),
10967 TEST_CASE_ST(ut_setup, ut_teardown,
10968 test_AES_GCM_auth_encryption_test_case_aad_2),
10970 /** AES GCM Authenticated Decryption big aad size */
10971 TEST_CASE_ST(ut_setup, ut_teardown,
10972 test_AES_GCM_auth_decryption_test_case_aad_1),
10973 TEST_CASE_ST(ut_setup, ut_teardown,
10974 test_AES_GCM_auth_decryption_test_case_aad_2),
10976 /** Session-less tests */
10977 TEST_CASE_ST(ut_setup, ut_teardown,
10978 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
10979 TEST_CASE_ST(ut_setup, ut_teardown,
10980 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
10982 /** AES GMAC Authentication */
10983 TEST_CASE_ST(ut_setup, ut_teardown,
10984 test_AES_GMAC_authentication_test_case_1),
10985 TEST_CASE_ST(ut_setup, ut_teardown,
10986 test_AES_GMAC_authentication_verify_test_case_1),
10987 TEST_CASE_ST(ut_setup, ut_teardown,
10988 test_AES_GMAC_authentication_test_case_2),
10989 TEST_CASE_ST(ut_setup, ut_teardown,
10990 test_AES_GMAC_authentication_verify_test_case_2),
10991 TEST_CASE_ST(ut_setup, ut_teardown,
10992 test_AES_GMAC_authentication_test_case_3),
10993 TEST_CASE_ST(ut_setup, ut_teardown,
10994 test_AES_GMAC_authentication_verify_test_case_3),
10995 #endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */
10997 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
10998 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
10999 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
11000 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
11001 TEST_CASE_ST(ut_setup, ut_teardown,
11002 test_DES_cipheronly_mb_all),
11003 TEST_CASE_ST(ut_setup, ut_teardown,
11004 test_DES_docsis_mb_all),
11005 TEST_CASE_ST(ut_setup, ut_teardown,
11006 test_3DES_cipheronly_mb_all),
11007 TEST_CASE_ST(ut_setup, ut_teardown,
11008 test_AES_CCM_authenticated_encryption_test_case_128_1),
11009 TEST_CASE_ST(ut_setup, ut_teardown,
11010 test_AES_CCM_authenticated_decryption_test_case_128_1),
11011 TEST_CASE_ST(ut_setup, ut_teardown,
11012 test_AES_CCM_authenticated_encryption_test_case_128_2),
11013 TEST_CASE_ST(ut_setup, ut_teardown,
11014 test_AES_CCM_authenticated_decryption_test_case_128_2),
11015 TEST_CASE_ST(ut_setup, ut_teardown,
11016 test_AES_CCM_authenticated_encryption_test_case_128_3),
11017 TEST_CASE_ST(ut_setup, ut_teardown,
11018 test_AES_CCM_authenticated_decryption_test_case_128_3),
11020 TEST_CASES_END() /**< NULL terminate unit test array */
11024 static struct unit_test_suite cryptodev_openssl_testsuite = {
11025 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
11026 .setup = testsuite_setup,
11027 .teardown = testsuite_teardown,
11028 .unit_test_cases = {
11029 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11030 TEST_CASE_ST(ut_setup, ut_teardown,
11031 test_multi_session_random_usage),
11032 TEST_CASE_ST(ut_setup, ut_teardown,
11033 test_AES_chain_openssl_all),
11034 TEST_CASE_ST(ut_setup, ut_teardown,
11035 test_AES_cipheronly_openssl_all),
11036 TEST_CASE_ST(ut_setup, ut_teardown,
11037 test_3DES_chain_openssl_all),
11038 TEST_CASE_ST(ut_setup, ut_teardown,
11039 test_3DES_cipheronly_openssl_all),
11040 TEST_CASE_ST(ut_setup, ut_teardown,
11041 test_DES_cipheronly_openssl_all),
11042 TEST_CASE_ST(ut_setup, ut_teardown,
11043 test_DES_docsis_openssl_all),
11044 TEST_CASE_ST(ut_setup, ut_teardown,
11045 test_authonly_openssl_all),
11047 /** AES GCM Authenticated Encryption */
11048 TEST_CASE_ST(ut_setup, ut_teardown,
11049 test_AES_GCM_authenticated_encryption_test_case_1),
11050 TEST_CASE_ST(ut_setup, ut_teardown,
11051 test_AES_GCM_authenticated_encryption_test_case_2),
11052 TEST_CASE_ST(ut_setup, ut_teardown,
11053 test_AES_GCM_authenticated_encryption_test_case_3),
11054 TEST_CASE_ST(ut_setup, ut_teardown,
11055 test_AES_GCM_authenticated_encryption_test_case_4),
11056 TEST_CASE_ST(ut_setup, ut_teardown,
11057 test_AES_GCM_authenticated_encryption_test_case_5),
11058 TEST_CASE_ST(ut_setup, ut_teardown,
11059 test_AES_GCM_authenticated_encryption_test_case_6),
11060 TEST_CASE_ST(ut_setup, ut_teardown,
11061 test_AES_GCM_authenticated_encryption_test_case_7),
11063 /** AES GCM Authenticated Decryption */
11064 TEST_CASE_ST(ut_setup, ut_teardown,
11065 test_AES_GCM_authenticated_decryption_test_case_1),
11066 TEST_CASE_ST(ut_setup, ut_teardown,
11067 test_AES_GCM_authenticated_decryption_test_case_2),
11068 TEST_CASE_ST(ut_setup, ut_teardown,
11069 test_AES_GCM_authenticated_decryption_test_case_3),
11070 TEST_CASE_ST(ut_setup, ut_teardown,
11071 test_AES_GCM_authenticated_decryption_test_case_4),
11072 TEST_CASE_ST(ut_setup, ut_teardown,
11073 test_AES_GCM_authenticated_decryption_test_case_5),
11074 TEST_CASE_ST(ut_setup, ut_teardown,
11075 test_AES_GCM_authenticated_decryption_test_case_6),
11076 TEST_CASE_ST(ut_setup, ut_teardown,
11077 test_AES_GCM_authenticated_decryption_test_case_7),
11080 /** AES GCM Authenticated Encryption 192 bits key */
11081 TEST_CASE_ST(ut_setup, ut_teardown,
11082 test_AES_GCM_auth_encryption_test_case_192_1),
11083 TEST_CASE_ST(ut_setup, ut_teardown,
11084 test_AES_GCM_auth_encryption_test_case_192_2),
11085 TEST_CASE_ST(ut_setup, ut_teardown,
11086 test_AES_GCM_auth_encryption_test_case_192_3),
11087 TEST_CASE_ST(ut_setup, ut_teardown,
11088 test_AES_GCM_auth_encryption_test_case_192_4),
11089 TEST_CASE_ST(ut_setup, ut_teardown,
11090 test_AES_GCM_auth_encryption_test_case_192_5),
11091 TEST_CASE_ST(ut_setup, ut_teardown,
11092 test_AES_GCM_auth_encryption_test_case_192_6),
11093 TEST_CASE_ST(ut_setup, ut_teardown,
11094 test_AES_GCM_auth_encryption_test_case_192_7),
11096 /** AES GCM Authenticated Decryption 192 bits key */
11097 TEST_CASE_ST(ut_setup, ut_teardown,
11098 test_AES_GCM_auth_decryption_test_case_192_1),
11099 TEST_CASE_ST(ut_setup, ut_teardown,
11100 test_AES_GCM_auth_decryption_test_case_192_2),
11101 TEST_CASE_ST(ut_setup, ut_teardown,
11102 test_AES_GCM_auth_decryption_test_case_192_3),
11103 TEST_CASE_ST(ut_setup, ut_teardown,
11104 test_AES_GCM_auth_decryption_test_case_192_4),
11105 TEST_CASE_ST(ut_setup, ut_teardown,
11106 test_AES_GCM_auth_decryption_test_case_192_5),
11107 TEST_CASE_ST(ut_setup, ut_teardown,
11108 test_AES_GCM_auth_decryption_test_case_192_6),
11109 TEST_CASE_ST(ut_setup, ut_teardown,
11110 test_AES_GCM_auth_decryption_test_case_192_7),
11112 /** AES GCM Authenticated Encryption 256 bits key */
11113 TEST_CASE_ST(ut_setup, ut_teardown,
11114 test_AES_GCM_auth_encryption_test_case_256_1),
11115 TEST_CASE_ST(ut_setup, ut_teardown,
11116 test_AES_GCM_auth_encryption_test_case_256_2),
11117 TEST_CASE_ST(ut_setup, ut_teardown,
11118 test_AES_GCM_auth_encryption_test_case_256_3),
11119 TEST_CASE_ST(ut_setup, ut_teardown,
11120 test_AES_GCM_auth_encryption_test_case_256_4),
11121 TEST_CASE_ST(ut_setup, ut_teardown,
11122 test_AES_GCM_auth_encryption_test_case_256_5),
11123 TEST_CASE_ST(ut_setup, ut_teardown,
11124 test_AES_GCM_auth_encryption_test_case_256_6),
11125 TEST_CASE_ST(ut_setup, ut_teardown,
11126 test_AES_GCM_auth_encryption_test_case_256_7),
11128 /** AES GCM Authenticated Decryption 256 bits key */
11129 TEST_CASE_ST(ut_setup, ut_teardown,
11130 test_AES_GCM_auth_decryption_test_case_256_1),
11131 TEST_CASE_ST(ut_setup, ut_teardown,
11132 test_AES_GCM_auth_decryption_test_case_256_2),
11133 TEST_CASE_ST(ut_setup, ut_teardown,
11134 test_AES_GCM_auth_decryption_test_case_256_3),
11135 TEST_CASE_ST(ut_setup, ut_teardown,
11136 test_AES_GCM_auth_decryption_test_case_256_4),
11137 TEST_CASE_ST(ut_setup, ut_teardown,
11138 test_AES_GCM_auth_decryption_test_case_256_5),
11139 TEST_CASE_ST(ut_setup, ut_teardown,
11140 test_AES_GCM_auth_decryption_test_case_256_6),
11141 TEST_CASE_ST(ut_setup, ut_teardown,
11142 test_AES_GCM_auth_decryption_test_case_256_7),
11144 /** AES GMAC Authentication */
11145 TEST_CASE_ST(ut_setup, ut_teardown,
11146 test_AES_GMAC_authentication_test_case_1),
11147 TEST_CASE_ST(ut_setup, ut_teardown,
11148 test_AES_GMAC_authentication_verify_test_case_1),
11149 TEST_CASE_ST(ut_setup, ut_teardown,
11150 test_AES_GMAC_authentication_test_case_2),
11151 TEST_CASE_ST(ut_setup, ut_teardown,
11152 test_AES_GMAC_authentication_verify_test_case_2),
11153 TEST_CASE_ST(ut_setup, ut_teardown,
11154 test_AES_GMAC_authentication_test_case_3),
11155 TEST_CASE_ST(ut_setup, ut_teardown,
11156 test_AES_GMAC_authentication_verify_test_case_3),
11157 TEST_CASE_ST(ut_setup, ut_teardown,
11158 test_AES_GMAC_authentication_test_case_4),
11159 TEST_CASE_ST(ut_setup, ut_teardown,
11160 test_AES_GMAC_authentication_verify_test_case_4),
11162 /** AES CCM Authenticated Encryption 128 bits key */
11163 TEST_CASE_ST(ut_setup, ut_teardown,
11164 test_AES_CCM_authenticated_encryption_test_case_128_1),
11165 TEST_CASE_ST(ut_setup, ut_teardown,
11166 test_AES_CCM_authenticated_encryption_test_case_128_2),
11167 TEST_CASE_ST(ut_setup, ut_teardown,
11168 test_AES_CCM_authenticated_encryption_test_case_128_3),
11170 /** AES CCM Authenticated Decryption 128 bits key*/
11171 TEST_CASE_ST(ut_setup, ut_teardown,
11172 test_AES_CCM_authenticated_decryption_test_case_128_1),
11173 TEST_CASE_ST(ut_setup, ut_teardown,
11174 test_AES_CCM_authenticated_decryption_test_case_128_2),
11175 TEST_CASE_ST(ut_setup, ut_teardown,
11176 test_AES_CCM_authenticated_decryption_test_case_128_3),
11178 /** AES CCM Authenticated Encryption 192 bits key */
11179 TEST_CASE_ST(ut_setup, ut_teardown,
11180 test_AES_CCM_authenticated_encryption_test_case_192_1),
11181 TEST_CASE_ST(ut_setup, ut_teardown,
11182 test_AES_CCM_authenticated_encryption_test_case_192_2),
11183 TEST_CASE_ST(ut_setup, ut_teardown,
11184 test_AES_CCM_authenticated_encryption_test_case_192_3),
11186 /** AES CCM Authenticated Decryption 192 bits key*/
11187 TEST_CASE_ST(ut_setup, ut_teardown,
11188 test_AES_CCM_authenticated_decryption_test_case_192_1),
11189 TEST_CASE_ST(ut_setup, ut_teardown,
11190 test_AES_CCM_authenticated_decryption_test_case_192_2),
11191 TEST_CASE_ST(ut_setup, ut_teardown,
11192 test_AES_CCM_authenticated_decryption_test_case_192_3),
11194 /** AES CCM Authenticated Encryption 256 bits key */
11195 TEST_CASE_ST(ut_setup, ut_teardown,
11196 test_AES_CCM_authenticated_encryption_test_case_256_1),
11197 TEST_CASE_ST(ut_setup, ut_teardown,
11198 test_AES_CCM_authenticated_encryption_test_case_256_2),
11199 TEST_CASE_ST(ut_setup, ut_teardown,
11200 test_AES_CCM_authenticated_encryption_test_case_256_3),
11202 /** AES CCM Authenticated Decryption 256 bits key*/
11203 TEST_CASE_ST(ut_setup, ut_teardown,
11204 test_AES_CCM_authenticated_decryption_test_case_256_1),
11205 TEST_CASE_ST(ut_setup, ut_teardown,
11206 test_AES_CCM_authenticated_decryption_test_case_256_2),
11207 TEST_CASE_ST(ut_setup, ut_teardown,
11208 test_AES_CCM_authenticated_decryption_test_case_256_3),
11210 /** Scatter-Gather */
11211 TEST_CASE_ST(ut_setup, ut_teardown,
11212 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11214 /** Negative tests */
11215 TEST_CASE_ST(ut_setup, ut_teardown,
11216 authentication_verify_HMAC_SHA1_fail_data_corrupt),
11217 TEST_CASE_ST(ut_setup, ut_teardown,
11218 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
11219 TEST_CASE_ST(ut_setup, ut_teardown,
11220 authentication_verify_AES128_GMAC_fail_data_corrupt),
11221 TEST_CASE_ST(ut_setup, ut_teardown,
11222 authentication_verify_AES128_GMAC_fail_tag_corrupt),
11223 TEST_CASE_ST(ut_setup, ut_teardown,
11224 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11225 TEST_CASE_ST(ut_setup, ut_teardown,
11226 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11228 TEST_CASES_END() /**< NULL terminate unit test array */
11232 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
11233 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
11234 .setup = testsuite_setup,
11235 .teardown = testsuite_teardown,
11236 .unit_test_cases = {
11237 /** AES GCM Authenticated Encryption */
11238 TEST_CASE_ST(ut_setup, ut_teardown,
11239 test_AES_GCM_authenticated_encryption_test_case_1),
11240 TEST_CASE_ST(ut_setup, ut_teardown,
11241 test_AES_GCM_authenticated_encryption_test_case_2),
11242 TEST_CASE_ST(ut_setup, ut_teardown,
11243 test_AES_GCM_authenticated_encryption_test_case_3),
11244 TEST_CASE_ST(ut_setup, ut_teardown,
11245 test_AES_GCM_authenticated_encryption_test_case_4),
11246 TEST_CASE_ST(ut_setup, ut_teardown,
11247 test_AES_GCM_authenticated_encryption_test_case_5),
11248 TEST_CASE_ST(ut_setup, ut_teardown,
11249 test_AES_GCM_authenticated_encryption_test_case_6),
11250 TEST_CASE_ST(ut_setup, ut_teardown,
11251 test_AES_GCM_authenticated_encryption_test_case_7),
11253 /** AES GCM Authenticated Decryption */
11254 TEST_CASE_ST(ut_setup, ut_teardown,
11255 test_AES_GCM_authenticated_decryption_test_case_1),
11256 TEST_CASE_ST(ut_setup, ut_teardown,
11257 test_AES_GCM_authenticated_decryption_test_case_2),
11258 TEST_CASE_ST(ut_setup, ut_teardown,
11259 test_AES_GCM_authenticated_decryption_test_case_3),
11260 TEST_CASE_ST(ut_setup, ut_teardown,
11261 test_AES_GCM_authenticated_decryption_test_case_4),
11262 TEST_CASE_ST(ut_setup, ut_teardown,
11263 test_AES_GCM_authenticated_decryption_test_case_5),
11264 TEST_CASE_ST(ut_setup, ut_teardown,
11265 test_AES_GCM_authenticated_decryption_test_case_6),
11266 TEST_CASE_ST(ut_setup, ut_teardown,
11267 test_AES_GCM_authenticated_decryption_test_case_7),
11269 /** AES GCM Authenticated Encryption 192 bits key */
11270 TEST_CASE_ST(ut_setup, ut_teardown,
11271 test_AES_GCM_auth_encryption_test_case_192_1),
11272 TEST_CASE_ST(ut_setup, ut_teardown,
11273 test_AES_GCM_auth_encryption_test_case_192_2),
11274 TEST_CASE_ST(ut_setup, ut_teardown,
11275 test_AES_GCM_auth_encryption_test_case_192_3),
11276 TEST_CASE_ST(ut_setup, ut_teardown,
11277 test_AES_GCM_auth_encryption_test_case_192_4),
11278 TEST_CASE_ST(ut_setup, ut_teardown,
11279 test_AES_GCM_auth_encryption_test_case_192_5),
11280 TEST_CASE_ST(ut_setup, ut_teardown,
11281 test_AES_GCM_auth_encryption_test_case_192_6),
11282 TEST_CASE_ST(ut_setup, ut_teardown,
11283 test_AES_GCM_auth_encryption_test_case_192_7),
11285 /** AES GCM Authenticated Decryption 192 bits key */
11286 TEST_CASE_ST(ut_setup, ut_teardown,
11287 test_AES_GCM_auth_decryption_test_case_192_1),
11288 TEST_CASE_ST(ut_setup, ut_teardown,
11289 test_AES_GCM_auth_decryption_test_case_192_2),
11290 TEST_CASE_ST(ut_setup, ut_teardown,
11291 test_AES_GCM_auth_decryption_test_case_192_3),
11292 TEST_CASE_ST(ut_setup, ut_teardown,
11293 test_AES_GCM_auth_decryption_test_case_192_4),
11294 TEST_CASE_ST(ut_setup, ut_teardown,
11295 test_AES_GCM_auth_decryption_test_case_192_5),
11296 TEST_CASE_ST(ut_setup, ut_teardown,
11297 test_AES_GCM_auth_decryption_test_case_192_6),
11298 TEST_CASE_ST(ut_setup, ut_teardown,
11299 test_AES_GCM_auth_decryption_test_case_192_7),
11301 /** AES GCM Authenticated Encryption 256 bits key */
11302 TEST_CASE_ST(ut_setup, ut_teardown,
11303 test_AES_GCM_auth_encryption_test_case_256_1),
11304 TEST_CASE_ST(ut_setup, ut_teardown,
11305 test_AES_GCM_auth_encryption_test_case_256_2),
11306 TEST_CASE_ST(ut_setup, ut_teardown,
11307 test_AES_GCM_auth_encryption_test_case_256_3),
11308 TEST_CASE_ST(ut_setup, ut_teardown,
11309 test_AES_GCM_auth_encryption_test_case_256_4),
11310 TEST_CASE_ST(ut_setup, ut_teardown,
11311 test_AES_GCM_auth_encryption_test_case_256_5),
11312 TEST_CASE_ST(ut_setup, ut_teardown,
11313 test_AES_GCM_auth_encryption_test_case_256_6),
11314 TEST_CASE_ST(ut_setup, ut_teardown,
11315 test_AES_GCM_auth_encryption_test_case_256_7),
11317 /** AES GCM Authenticated Decryption 256 bits key */
11318 TEST_CASE_ST(ut_setup, ut_teardown,
11319 test_AES_GCM_auth_decryption_test_case_256_1),
11320 TEST_CASE_ST(ut_setup, ut_teardown,
11321 test_AES_GCM_auth_decryption_test_case_256_2),
11322 TEST_CASE_ST(ut_setup, ut_teardown,
11323 test_AES_GCM_auth_decryption_test_case_256_3),
11324 TEST_CASE_ST(ut_setup, ut_teardown,
11325 test_AES_GCM_auth_decryption_test_case_256_4),
11326 TEST_CASE_ST(ut_setup, ut_teardown,
11327 test_AES_GCM_auth_decryption_test_case_256_5),
11328 TEST_CASE_ST(ut_setup, ut_teardown,
11329 test_AES_GCM_auth_decryption_test_case_256_6),
11330 TEST_CASE_ST(ut_setup, ut_teardown,
11331 test_AES_GCM_auth_decryption_test_case_256_7),
11333 /** AES GCM Authenticated Encryption big aad size */
11334 TEST_CASE_ST(ut_setup, ut_teardown,
11335 test_AES_GCM_auth_encryption_test_case_aad_1),
11336 TEST_CASE_ST(ut_setup, ut_teardown,
11337 test_AES_GCM_auth_encryption_test_case_aad_2),
11339 /** AES GCM Authenticated Decryption big aad size */
11340 TEST_CASE_ST(ut_setup, ut_teardown,
11341 test_AES_GCM_auth_decryption_test_case_aad_1),
11342 TEST_CASE_ST(ut_setup, ut_teardown,
11343 test_AES_GCM_auth_decryption_test_case_aad_2),
11345 /** AES GMAC Authentication */
11346 TEST_CASE_ST(ut_setup, ut_teardown,
11347 test_AES_GMAC_authentication_test_case_1),
11348 TEST_CASE_ST(ut_setup, ut_teardown,
11349 test_AES_GMAC_authentication_verify_test_case_1),
11350 TEST_CASE_ST(ut_setup, ut_teardown,
11351 test_AES_GMAC_authentication_test_case_3),
11352 TEST_CASE_ST(ut_setup, ut_teardown,
11353 test_AES_GMAC_authentication_verify_test_case_3),
11354 TEST_CASE_ST(ut_setup, ut_teardown,
11355 test_AES_GMAC_authentication_test_case_4),
11356 TEST_CASE_ST(ut_setup, ut_teardown,
11357 test_AES_GMAC_authentication_verify_test_case_4),
11359 /** Negative tests */
11360 TEST_CASE_ST(ut_setup, ut_teardown,
11361 authentication_verify_AES128_GMAC_fail_data_corrupt),
11362 TEST_CASE_ST(ut_setup, ut_teardown,
11363 authentication_verify_AES128_GMAC_fail_tag_corrupt),
11365 /** Out of place tests */
11366 TEST_CASE_ST(ut_setup, ut_teardown,
11367 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11368 TEST_CASE_ST(ut_setup, ut_teardown,
11369 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11371 /** Session-less tests */
11372 TEST_CASE_ST(ut_setup, ut_teardown,
11373 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
11374 TEST_CASE_ST(ut_setup, ut_teardown,
11375 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
11377 /** Scatter-Gather */
11378 TEST_CASE_ST(ut_setup, ut_teardown,
11379 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11381 TEST_CASES_END() /**< NULL terminate unit test array */
11385 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
11386 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
11387 .setup = testsuite_setup,
11388 .teardown = testsuite_teardown,
11389 .unit_test_cases = {
11390 /** KASUMI encrypt only (UEA1) */
11391 TEST_CASE_ST(ut_setup, ut_teardown,
11392 test_kasumi_encryption_test_case_1),
11393 TEST_CASE_ST(ut_setup, ut_teardown,
11394 test_kasumi_encryption_test_case_1_sgl),
11395 TEST_CASE_ST(ut_setup, ut_teardown,
11396 test_kasumi_encryption_test_case_2),
11397 TEST_CASE_ST(ut_setup, ut_teardown,
11398 test_kasumi_encryption_test_case_3),
11399 TEST_CASE_ST(ut_setup, ut_teardown,
11400 test_kasumi_encryption_test_case_4),
11401 TEST_CASE_ST(ut_setup, ut_teardown,
11402 test_kasumi_encryption_test_case_5),
11403 /** KASUMI decrypt only (UEA1) */
11404 TEST_CASE_ST(ut_setup, ut_teardown,
11405 test_kasumi_decryption_test_case_1),
11406 TEST_CASE_ST(ut_setup, ut_teardown,
11407 test_kasumi_decryption_test_case_2),
11408 TEST_CASE_ST(ut_setup, ut_teardown,
11409 test_kasumi_decryption_test_case_3),
11410 TEST_CASE_ST(ut_setup, ut_teardown,
11411 test_kasumi_decryption_test_case_4),
11412 TEST_CASE_ST(ut_setup, ut_teardown,
11413 test_kasumi_decryption_test_case_5),
11415 TEST_CASE_ST(ut_setup, ut_teardown,
11416 test_kasumi_encryption_test_case_1_oop),
11417 TEST_CASE_ST(ut_setup, ut_teardown,
11418 test_kasumi_encryption_test_case_1_oop_sgl),
11421 TEST_CASE_ST(ut_setup, ut_teardown,
11422 test_kasumi_decryption_test_case_1_oop),
11424 /** KASUMI hash only (UIA1) */
11425 TEST_CASE_ST(ut_setup, ut_teardown,
11426 test_kasumi_hash_generate_test_case_1),
11427 TEST_CASE_ST(ut_setup, ut_teardown,
11428 test_kasumi_hash_generate_test_case_2),
11429 TEST_CASE_ST(ut_setup, ut_teardown,
11430 test_kasumi_hash_generate_test_case_3),
11431 TEST_CASE_ST(ut_setup, ut_teardown,
11432 test_kasumi_hash_generate_test_case_4),
11433 TEST_CASE_ST(ut_setup, ut_teardown,
11434 test_kasumi_hash_generate_test_case_5),
11435 TEST_CASE_ST(ut_setup, ut_teardown,
11436 test_kasumi_hash_generate_test_case_6),
11437 TEST_CASE_ST(ut_setup, ut_teardown,
11438 test_kasumi_hash_verify_test_case_1),
11439 TEST_CASE_ST(ut_setup, ut_teardown,
11440 test_kasumi_hash_verify_test_case_2),
11441 TEST_CASE_ST(ut_setup, ut_teardown,
11442 test_kasumi_hash_verify_test_case_3),
11443 TEST_CASE_ST(ut_setup, ut_teardown,
11444 test_kasumi_hash_verify_test_case_4),
11445 TEST_CASE_ST(ut_setup, ut_teardown,
11446 test_kasumi_hash_verify_test_case_5),
11447 TEST_CASE_ST(ut_setup, ut_teardown,
11448 test_kasumi_cipher_auth_test_case_1),
11450 /** KASUMI generate auth, then encrypt (F8) */
11451 TEST_CASE_ST(ut_setup, ut_teardown,
11452 test_kasumi_auth_cipher_test_case_1),
11453 TEST_CASE_ST(ut_setup, ut_teardown,
11454 test_kasumi_auth_cipher_test_case_2),
11455 TEST_CASE_ST(ut_setup, ut_teardown,
11456 test_kasumi_auth_cipher_test_case_2_oop),
11457 TEST_CASE_ST(ut_setup, ut_teardown,
11458 test_kasumi_auth_cipher_test_case_2_sgl),
11459 TEST_CASE_ST(ut_setup, ut_teardown,
11460 test_kasumi_auth_cipher_test_case_2_oop_sgl),
11462 /** KASUMI decrypt (F8), then verify auth */
11463 TEST_CASE_ST(ut_setup, ut_teardown,
11464 test_kasumi_auth_cipher_verify_test_case_1),
11465 TEST_CASE_ST(ut_setup, ut_teardown,
11466 test_kasumi_auth_cipher_verify_test_case_2),
11467 TEST_CASE_ST(ut_setup, ut_teardown,
11468 test_kasumi_auth_cipher_verify_test_case_2_oop),
11469 TEST_CASE_ST(ut_setup, ut_teardown,
11470 test_kasumi_auth_cipher_verify_test_case_2_sgl),
11471 TEST_CASE_ST(ut_setup, ut_teardown,
11472 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
11473 TEST_CASES_END() /**< NULL terminate unit test array */
11476 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
11477 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
11478 .setup = testsuite_setup,
11479 .teardown = testsuite_teardown,
11480 .unit_test_cases = {
11481 /** SNOW 3G encrypt only (UEA2) */
11482 TEST_CASE_ST(ut_setup, ut_teardown,
11483 test_snow3g_encryption_test_case_1),
11484 TEST_CASE_ST(ut_setup, ut_teardown,
11485 test_snow3g_encryption_test_case_2),
11486 TEST_CASE_ST(ut_setup, ut_teardown,
11487 test_snow3g_encryption_test_case_3),
11488 TEST_CASE_ST(ut_setup, ut_teardown,
11489 test_snow3g_encryption_test_case_4),
11490 TEST_CASE_ST(ut_setup, ut_teardown,
11491 test_snow3g_encryption_test_case_5),
11492 TEST_CASE_ST(ut_setup, ut_teardown,
11493 test_snow3g_auth_cipher_with_digest_test_case_1),
11495 TEST_CASE_ST(ut_setup, ut_teardown,
11496 test_snow3g_encryption_test_case_1_oop),
11497 TEST_CASE_ST(ut_setup, ut_teardown,
11498 test_snow3g_encryption_test_case_1_oop_sgl),
11499 TEST_CASE_ST(ut_setup, ut_teardown,
11500 test_snow3g_decryption_test_case_1_oop),
11502 TEST_CASE_ST(ut_setup, ut_teardown,
11503 test_snow3g_encryption_test_case_1_offset_oop),
11505 /** SNOW 3G decrypt only (UEA2) */
11506 TEST_CASE_ST(ut_setup, ut_teardown,
11507 test_snow3g_decryption_test_case_1),
11508 TEST_CASE_ST(ut_setup, ut_teardown,
11509 test_snow3g_decryption_test_case_2),
11510 TEST_CASE_ST(ut_setup, ut_teardown,
11511 test_snow3g_decryption_test_case_3),
11512 TEST_CASE_ST(ut_setup, ut_teardown,
11513 test_snow3g_decryption_test_case_4),
11514 TEST_CASE_ST(ut_setup, ut_teardown,
11515 test_snow3g_decryption_test_case_5),
11516 TEST_CASE_ST(ut_setup, ut_teardown,
11517 test_snow3g_decryption_with_digest_test_case_1),
11518 TEST_CASE_ST(ut_setup, ut_teardown,
11519 test_snow3g_hash_generate_test_case_1),
11520 TEST_CASE_ST(ut_setup, ut_teardown,
11521 test_snow3g_hash_generate_test_case_2),
11522 TEST_CASE_ST(ut_setup, ut_teardown,
11523 test_snow3g_hash_generate_test_case_3),
11524 /* Tests with buffers which length is not byte-aligned */
11525 TEST_CASE_ST(ut_setup, ut_teardown,
11526 test_snow3g_hash_generate_test_case_4),
11527 TEST_CASE_ST(ut_setup, ut_teardown,
11528 test_snow3g_hash_generate_test_case_5),
11529 TEST_CASE_ST(ut_setup, ut_teardown,
11530 test_snow3g_hash_generate_test_case_6),
11531 TEST_CASE_ST(ut_setup, ut_teardown,
11532 test_snow3g_hash_verify_test_case_1),
11533 TEST_CASE_ST(ut_setup, ut_teardown,
11534 test_snow3g_hash_verify_test_case_2),
11535 TEST_CASE_ST(ut_setup, ut_teardown,
11536 test_snow3g_hash_verify_test_case_3),
11537 /* Tests with buffers which length is not byte-aligned */
11538 TEST_CASE_ST(ut_setup, ut_teardown,
11539 test_snow3g_hash_verify_test_case_4),
11540 TEST_CASE_ST(ut_setup, ut_teardown,
11541 test_snow3g_hash_verify_test_case_5),
11542 TEST_CASE_ST(ut_setup, ut_teardown,
11543 test_snow3g_hash_verify_test_case_6),
11544 TEST_CASE_ST(ut_setup, ut_teardown,
11545 test_snow3g_cipher_auth_test_case_1),
11547 /** SNOW 3G generate auth, then encrypt (UEA2) */
11548 TEST_CASE_ST(ut_setup, ut_teardown,
11549 test_snow3g_auth_cipher_test_case_1),
11550 TEST_CASE_ST(ut_setup, ut_teardown,
11551 test_snow3g_auth_cipher_test_case_2),
11552 TEST_CASE_ST(ut_setup, ut_teardown,
11553 test_snow3g_auth_cipher_test_case_2_oop),
11554 TEST_CASE_ST(ut_setup, ut_teardown,
11555 test_snow3g_auth_cipher_part_digest_enc),
11556 TEST_CASE_ST(ut_setup, ut_teardown,
11557 test_snow3g_auth_cipher_part_digest_enc_oop),
11558 TEST_CASE_ST(ut_setup, ut_teardown,
11559 test_snow3g_auth_cipher_test_case_3_sgl),
11560 TEST_CASE_ST(ut_setup, ut_teardown,
11561 test_snow3g_auth_cipher_test_case_3_oop_sgl),
11562 TEST_CASE_ST(ut_setup, ut_teardown,
11563 test_snow3g_auth_cipher_part_digest_enc_sgl),
11564 TEST_CASE_ST(ut_setup, ut_teardown,
11565 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
11567 /** SNOW 3G decrypt (UEA2), then verify auth */
11568 TEST_CASE_ST(ut_setup, ut_teardown,
11569 test_snow3g_auth_cipher_verify_test_case_1),
11570 TEST_CASE_ST(ut_setup, ut_teardown,
11571 test_snow3g_auth_cipher_verify_test_case_2),
11572 TEST_CASE_ST(ut_setup, ut_teardown,
11573 test_snow3g_auth_cipher_verify_test_case_2_oop),
11574 TEST_CASE_ST(ut_setup, ut_teardown,
11575 test_snow3g_auth_cipher_verify_part_digest_enc),
11576 TEST_CASE_ST(ut_setup, ut_teardown,
11577 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
11578 TEST_CASE_ST(ut_setup, ut_teardown,
11579 test_snow3g_auth_cipher_verify_test_case_3_sgl),
11580 TEST_CASE_ST(ut_setup, ut_teardown,
11581 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
11582 TEST_CASE_ST(ut_setup, ut_teardown,
11583 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
11584 TEST_CASE_ST(ut_setup, ut_teardown,
11585 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
11587 TEST_CASES_END() /**< NULL terminate unit test array */
11591 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
11592 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
11593 .setup = testsuite_setup,
11594 .teardown = testsuite_teardown,
11595 .unit_test_cases = {
11596 /** ZUC encrypt only (EEA3) */
11597 TEST_CASE_ST(ut_setup, ut_teardown,
11598 test_zuc_encryption_test_case_1),
11599 TEST_CASE_ST(ut_setup, ut_teardown,
11600 test_zuc_encryption_test_case_2),
11601 TEST_CASE_ST(ut_setup, ut_teardown,
11602 test_zuc_encryption_test_case_3),
11603 TEST_CASE_ST(ut_setup, ut_teardown,
11604 test_zuc_encryption_test_case_4),
11605 TEST_CASE_ST(ut_setup, ut_teardown,
11606 test_zuc_encryption_test_case_5),
11607 TEST_CASE_ST(ut_setup, ut_teardown,
11608 test_zuc_hash_generate_test_case_1),
11609 TEST_CASE_ST(ut_setup, ut_teardown,
11610 test_zuc_hash_generate_test_case_2),
11611 TEST_CASE_ST(ut_setup, ut_teardown,
11612 test_zuc_hash_generate_test_case_3),
11613 TEST_CASE_ST(ut_setup, ut_teardown,
11614 test_zuc_hash_generate_test_case_4),
11615 TEST_CASE_ST(ut_setup, ut_teardown,
11616 test_zuc_hash_generate_test_case_5),
11617 TEST_CASE_ST(ut_setup, ut_teardown,
11618 test_zuc_encryption_test_case_6_sgl),
11619 TEST_CASES_END() /**< NULL terminate unit test array */
11623 static struct unit_test_suite cryptodev_caam_jr_testsuite = {
11624 .suite_name = "Crypto CAAM JR Unit Test Suite",
11625 .setup = testsuite_setup,
11626 .teardown = testsuite_teardown,
11627 .unit_test_cases = {
11628 TEST_CASE_ST(ut_setup, ut_teardown,
11629 test_device_configure_invalid_dev_id),
11630 TEST_CASE_ST(ut_setup, ut_teardown,
11631 test_multi_session),
11633 TEST_CASE_ST(ut_setup, ut_teardown,
11634 test_AES_chain_caam_jr_all),
11635 TEST_CASE_ST(ut_setup, ut_teardown,
11636 test_3DES_chain_caam_jr_all),
11637 TEST_CASE_ST(ut_setup, ut_teardown,
11638 test_AES_cipheronly_caam_jr_all),
11639 TEST_CASE_ST(ut_setup, ut_teardown,
11640 test_3DES_cipheronly_caam_jr_all),
11641 TEST_CASE_ST(ut_setup, ut_teardown,
11642 test_authonly_caam_jr_all),
11644 TEST_CASES_END() /**< NULL terminate unit test array */
11648 static struct unit_test_suite cryptodev_dpaa_sec_testsuite = {
11649 .suite_name = "Crypto DPAA_SEC Unit Test Suite",
11650 .setup = testsuite_setup,
11651 .teardown = testsuite_teardown,
11652 .unit_test_cases = {
11653 TEST_CASE_ST(ut_setup, ut_teardown,
11654 test_device_configure_invalid_dev_id),
11655 TEST_CASE_ST(ut_setup, ut_teardown,
11656 test_multi_session),
11658 TEST_CASE_ST(ut_setup, ut_teardown,
11659 test_AES_chain_dpaa_sec_all),
11660 TEST_CASE_ST(ut_setup, ut_teardown,
11661 test_3DES_chain_dpaa_sec_all),
11662 TEST_CASE_ST(ut_setup, ut_teardown,
11663 test_AES_cipheronly_dpaa_sec_all),
11664 TEST_CASE_ST(ut_setup, ut_teardown,
11665 test_3DES_cipheronly_dpaa_sec_all),
11666 TEST_CASE_ST(ut_setup, ut_teardown,
11667 test_authonly_dpaa_sec_all),
11669 #ifdef RTE_LIBRTE_SECURITY
11670 TEST_CASE_ST(ut_setup, ut_teardown,
11671 test_PDCP_PROTO_cplane_encap_all),
11673 TEST_CASE_ST(ut_setup, ut_teardown,
11674 test_PDCP_PROTO_cplane_decap_all),
11676 TEST_CASE_ST(ut_setup, ut_teardown,
11677 test_PDCP_PROTO_uplane_encap_all),
11679 /** AES GCM Authenticated Encryption */
11680 TEST_CASE_ST(ut_setup, ut_teardown,
11681 test_AES_GCM_authenticated_encryption_test_case_1),
11682 TEST_CASE_ST(ut_setup, ut_teardown,
11683 test_AES_GCM_authenticated_encryption_test_case_2),
11684 TEST_CASE_ST(ut_setup, ut_teardown,
11685 test_AES_GCM_authenticated_encryption_test_case_3),
11686 TEST_CASE_ST(ut_setup, ut_teardown,
11687 test_AES_GCM_authenticated_encryption_test_case_4),
11688 TEST_CASE_ST(ut_setup, ut_teardown,
11689 test_AES_GCM_authenticated_encryption_test_case_5),
11690 TEST_CASE_ST(ut_setup, ut_teardown,
11691 test_AES_GCM_authenticated_encryption_test_case_6),
11692 TEST_CASE_ST(ut_setup, ut_teardown,
11693 test_AES_GCM_authenticated_encryption_test_case_7),
11695 /** AES GCM Authenticated Decryption */
11696 TEST_CASE_ST(ut_setup, ut_teardown,
11697 test_AES_GCM_authenticated_decryption_test_case_1),
11698 TEST_CASE_ST(ut_setup, ut_teardown,
11699 test_AES_GCM_authenticated_decryption_test_case_2),
11700 TEST_CASE_ST(ut_setup, ut_teardown,
11701 test_AES_GCM_authenticated_decryption_test_case_3),
11702 TEST_CASE_ST(ut_setup, ut_teardown,
11703 test_AES_GCM_authenticated_decryption_test_case_4),
11704 TEST_CASE_ST(ut_setup, ut_teardown,
11705 test_AES_GCM_authenticated_decryption_test_case_5),
11706 TEST_CASE_ST(ut_setup, ut_teardown,
11707 test_AES_GCM_authenticated_decryption_test_case_6),
11708 TEST_CASE_ST(ut_setup, ut_teardown,
11709 test_AES_GCM_authenticated_decryption_test_case_7),
11711 /** AES GCM Authenticated Encryption 256 bits key */
11712 TEST_CASE_ST(ut_setup, ut_teardown,
11713 test_AES_GCM_auth_encryption_test_case_256_1),
11714 TEST_CASE_ST(ut_setup, ut_teardown,
11715 test_AES_GCM_auth_encryption_test_case_256_2),
11716 TEST_CASE_ST(ut_setup, ut_teardown,
11717 test_AES_GCM_auth_encryption_test_case_256_3),
11718 TEST_CASE_ST(ut_setup, ut_teardown,
11719 test_AES_GCM_auth_encryption_test_case_256_4),
11720 TEST_CASE_ST(ut_setup, ut_teardown,
11721 test_AES_GCM_auth_encryption_test_case_256_5),
11722 TEST_CASE_ST(ut_setup, ut_teardown,
11723 test_AES_GCM_auth_encryption_test_case_256_6),
11724 TEST_CASE_ST(ut_setup, ut_teardown,
11725 test_AES_GCM_auth_encryption_test_case_256_7),
11727 /** AES GCM Authenticated Decryption 256 bits key */
11728 TEST_CASE_ST(ut_setup, ut_teardown,
11729 test_AES_GCM_auth_decryption_test_case_256_1),
11730 TEST_CASE_ST(ut_setup, ut_teardown,
11731 test_AES_GCM_auth_decryption_test_case_256_2),
11732 TEST_CASE_ST(ut_setup, ut_teardown,
11733 test_AES_GCM_auth_decryption_test_case_256_3),
11734 TEST_CASE_ST(ut_setup, ut_teardown,
11735 test_AES_GCM_auth_decryption_test_case_256_4),
11736 TEST_CASE_ST(ut_setup, ut_teardown,
11737 test_AES_GCM_auth_decryption_test_case_256_5),
11738 TEST_CASE_ST(ut_setup, ut_teardown,
11739 test_AES_GCM_auth_decryption_test_case_256_6),
11740 TEST_CASE_ST(ut_setup, ut_teardown,
11741 test_AES_GCM_auth_decryption_test_case_256_7),
11743 /** Out of place tests */
11744 TEST_CASE_ST(ut_setup, ut_teardown,
11745 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11746 TEST_CASE_ST(ut_setup, ut_teardown,
11747 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11749 /** Scatter-Gather */
11750 TEST_CASE_ST(ut_setup, ut_teardown,
11751 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
11752 TEST_CASE_ST(ut_setup, ut_teardown,
11753 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
11754 TEST_CASE_ST(ut_setup, ut_teardown,
11755 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11756 TEST_CASE_ST(ut_setup, ut_teardown,
11757 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
11759 TEST_CASES_END() /**< NULL terminate unit test array */
11763 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
11764 .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
11765 .setup = testsuite_setup,
11766 .teardown = testsuite_teardown,
11767 .unit_test_cases = {
11768 TEST_CASE_ST(ut_setup, ut_teardown,
11769 test_device_configure_invalid_dev_id),
11770 TEST_CASE_ST(ut_setup, ut_teardown,
11771 test_multi_session),
11773 TEST_CASE_ST(ut_setup, ut_teardown,
11774 test_AES_chain_dpaa2_sec_all),
11775 TEST_CASE_ST(ut_setup, ut_teardown,
11776 test_3DES_chain_dpaa2_sec_all),
11777 TEST_CASE_ST(ut_setup, ut_teardown,
11778 test_AES_cipheronly_dpaa2_sec_all),
11779 TEST_CASE_ST(ut_setup, ut_teardown,
11780 test_3DES_cipheronly_dpaa2_sec_all),
11781 TEST_CASE_ST(ut_setup, ut_teardown,
11782 test_authonly_dpaa2_sec_all),
11784 #ifdef RTE_LIBRTE_SECURITY
11785 TEST_CASE_ST(ut_setup, ut_teardown,
11786 test_PDCP_PROTO_cplane_encap_all),
11788 TEST_CASE_ST(ut_setup, ut_teardown,
11789 test_PDCP_PROTO_cplane_decap_all),
11791 TEST_CASE_ST(ut_setup, ut_teardown,
11792 test_PDCP_PROTO_uplane_encap_all),
11794 /** AES GCM Authenticated Encryption */
11795 TEST_CASE_ST(ut_setup, ut_teardown,
11796 test_AES_GCM_authenticated_encryption_test_case_1),
11797 TEST_CASE_ST(ut_setup, ut_teardown,
11798 test_AES_GCM_authenticated_encryption_test_case_2),
11799 TEST_CASE_ST(ut_setup, ut_teardown,
11800 test_AES_GCM_authenticated_encryption_test_case_3),
11801 TEST_CASE_ST(ut_setup, ut_teardown,
11802 test_AES_GCM_authenticated_encryption_test_case_4),
11803 TEST_CASE_ST(ut_setup, ut_teardown,
11804 test_AES_GCM_authenticated_encryption_test_case_5),
11805 TEST_CASE_ST(ut_setup, ut_teardown,
11806 test_AES_GCM_authenticated_encryption_test_case_6),
11807 TEST_CASE_ST(ut_setup, ut_teardown,
11808 test_AES_GCM_authenticated_encryption_test_case_7),
11810 /** AES GCM Authenticated Decryption */
11811 TEST_CASE_ST(ut_setup, ut_teardown,
11812 test_AES_GCM_authenticated_decryption_test_case_1),
11813 TEST_CASE_ST(ut_setup, ut_teardown,
11814 test_AES_GCM_authenticated_decryption_test_case_2),
11815 TEST_CASE_ST(ut_setup, ut_teardown,
11816 test_AES_GCM_authenticated_decryption_test_case_3),
11817 TEST_CASE_ST(ut_setup, ut_teardown,
11818 test_AES_GCM_authenticated_decryption_test_case_4),
11819 TEST_CASE_ST(ut_setup, ut_teardown,
11820 test_AES_GCM_authenticated_decryption_test_case_5),
11821 TEST_CASE_ST(ut_setup, ut_teardown,
11822 test_AES_GCM_authenticated_decryption_test_case_6),
11823 TEST_CASE_ST(ut_setup, ut_teardown,
11824 test_AES_GCM_authenticated_decryption_test_case_7),
11826 /** AES GCM Authenticated Encryption 192 bits key */
11827 TEST_CASE_ST(ut_setup, ut_teardown,
11828 test_AES_GCM_auth_encryption_test_case_192_1),
11829 TEST_CASE_ST(ut_setup, ut_teardown,
11830 test_AES_GCM_auth_encryption_test_case_192_2),
11831 TEST_CASE_ST(ut_setup, ut_teardown,
11832 test_AES_GCM_auth_encryption_test_case_192_3),
11833 TEST_CASE_ST(ut_setup, ut_teardown,
11834 test_AES_GCM_auth_encryption_test_case_192_4),
11835 TEST_CASE_ST(ut_setup, ut_teardown,
11836 test_AES_GCM_auth_encryption_test_case_192_5),
11837 TEST_CASE_ST(ut_setup, ut_teardown,
11838 test_AES_GCM_auth_encryption_test_case_192_6),
11839 TEST_CASE_ST(ut_setup, ut_teardown,
11840 test_AES_GCM_auth_encryption_test_case_192_7),
11842 /** AES GCM Authenticated Decryption 192 bits key */
11843 TEST_CASE_ST(ut_setup, ut_teardown,
11844 test_AES_GCM_auth_decryption_test_case_192_1),
11845 TEST_CASE_ST(ut_setup, ut_teardown,
11846 test_AES_GCM_auth_decryption_test_case_192_2),
11847 TEST_CASE_ST(ut_setup, ut_teardown,
11848 test_AES_GCM_auth_decryption_test_case_192_3),
11849 TEST_CASE_ST(ut_setup, ut_teardown,
11850 test_AES_GCM_auth_decryption_test_case_192_4),
11851 TEST_CASE_ST(ut_setup, ut_teardown,
11852 test_AES_GCM_auth_decryption_test_case_192_5),
11853 TEST_CASE_ST(ut_setup, ut_teardown,
11854 test_AES_GCM_auth_decryption_test_case_192_6),
11855 TEST_CASE_ST(ut_setup, ut_teardown,
11856 test_AES_GCM_auth_decryption_test_case_192_7),
11858 /** AES GCM Authenticated Encryption 256 bits key */
11859 TEST_CASE_ST(ut_setup, ut_teardown,
11860 test_AES_GCM_auth_encryption_test_case_256_1),
11861 TEST_CASE_ST(ut_setup, ut_teardown,
11862 test_AES_GCM_auth_encryption_test_case_256_2),
11863 TEST_CASE_ST(ut_setup, ut_teardown,
11864 test_AES_GCM_auth_encryption_test_case_256_3),
11865 TEST_CASE_ST(ut_setup, ut_teardown,
11866 test_AES_GCM_auth_encryption_test_case_256_4),
11867 TEST_CASE_ST(ut_setup, ut_teardown,
11868 test_AES_GCM_auth_encryption_test_case_256_5),
11869 TEST_CASE_ST(ut_setup, ut_teardown,
11870 test_AES_GCM_auth_encryption_test_case_256_6),
11871 TEST_CASE_ST(ut_setup, ut_teardown,
11872 test_AES_GCM_auth_encryption_test_case_256_7),
11874 /** AES GCM Authenticated Decryption 256 bits key */
11875 TEST_CASE_ST(ut_setup, ut_teardown,
11876 test_AES_GCM_auth_decryption_test_case_256_1),
11877 TEST_CASE_ST(ut_setup, ut_teardown,
11878 test_AES_GCM_auth_decryption_test_case_256_2),
11879 TEST_CASE_ST(ut_setup, ut_teardown,
11880 test_AES_GCM_auth_decryption_test_case_256_3),
11881 TEST_CASE_ST(ut_setup, ut_teardown,
11882 test_AES_GCM_auth_decryption_test_case_256_4),
11883 TEST_CASE_ST(ut_setup, ut_teardown,
11884 test_AES_GCM_auth_decryption_test_case_256_5),
11885 TEST_CASE_ST(ut_setup, ut_teardown,
11886 test_AES_GCM_auth_decryption_test_case_256_6),
11887 TEST_CASE_ST(ut_setup, ut_teardown,
11888 test_AES_GCM_auth_decryption_test_case_256_7),
11890 /** Out of place tests */
11891 TEST_CASE_ST(ut_setup, ut_teardown,
11892 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11893 TEST_CASE_ST(ut_setup, ut_teardown,
11894 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11896 /** Scatter-Gather */
11897 TEST_CASE_ST(ut_setup, ut_teardown,
11898 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
11899 TEST_CASE_ST(ut_setup, ut_teardown,
11900 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
11901 TEST_CASE_ST(ut_setup, ut_teardown,
11902 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11903 TEST_CASE_ST(ut_setup, ut_teardown,
11904 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
11906 TEST_CASES_END() /**< NULL terminate unit test array */
11910 static struct unit_test_suite cryptodev_null_testsuite = {
11911 .suite_name = "Crypto Device NULL Unit Test Suite",
11912 .setup = testsuite_setup,
11913 .teardown = testsuite_teardown,
11914 .unit_test_cases = {
11915 TEST_CASE_ST(ut_setup, ut_teardown,
11916 test_null_invalid_operation),
11917 TEST_CASE_ST(ut_setup, ut_teardown,
11918 test_null_burst_operation),
11919 TEST_CASE_ST(ut_setup, ut_teardown,
11920 test_AES_chain_null_all),
11921 TEST_CASE_ST(ut_setup, ut_teardown,
11922 test_AES_cipheronly_null_all),
11923 TEST_CASE_ST(ut_setup, ut_teardown,
11924 test_authonly_null_all),
11926 TEST_CASES_END() /**< NULL terminate unit test array */
11930 static struct unit_test_suite cryptodev_armv8_testsuite = {
11931 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
11932 .setup = testsuite_setup,
11933 .teardown = testsuite_teardown,
11934 .unit_test_cases = {
11935 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
11937 /** Negative tests */
11938 TEST_CASE_ST(ut_setup, ut_teardown,
11939 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11940 TEST_CASE_ST(ut_setup, ut_teardown,
11941 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11943 TEST_CASES_END() /**< NULL terminate unit test array */
11947 static struct unit_test_suite cryptodev_mrvl_testsuite = {
11948 .suite_name = "Crypto Device Marvell Component Test Suite",
11949 .setup = testsuite_setup,
11950 .teardown = testsuite_teardown,
11951 .unit_test_cases = {
11952 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11953 TEST_CASE_ST(ut_setup, ut_teardown,
11954 test_multi_session_random_usage),
11955 TEST_CASE_ST(ut_setup, ut_teardown,
11956 test_AES_chain_mrvl_all),
11957 TEST_CASE_ST(ut_setup, ut_teardown,
11958 test_AES_cipheronly_mrvl_all),
11959 TEST_CASE_ST(ut_setup, ut_teardown,
11960 test_authonly_mrvl_all),
11961 TEST_CASE_ST(ut_setup, ut_teardown,
11962 test_3DES_chain_mrvl_all),
11963 TEST_CASE_ST(ut_setup, ut_teardown,
11964 test_3DES_cipheronly_mrvl_all),
11966 /** Negative tests */
11967 TEST_CASE_ST(ut_setup, ut_teardown,
11968 authentication_verify_HMAC_SHA1_fail_data_corrupt),
11969 TEST_CASE_ST(ut_setup, ut_teardown,
11970 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
11971 TEST_CASE_ST(ut_setup, ut_teardown,
11972 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11973 TEST_CASE_ST(ut_setup, ut_teardown,
11974 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11976 TEST_CASES_END() /**< NULL terminate unit test array */
11980 static struct unit_test_suite cryptodev_ccp_testsuite = {
11981 .suite_name = "Crypto Device CCP Unit Test Suite",
11982 .setup = testsuite_setup,
11983 .teardown = testsuite_teardown,
11984 .unit_test_cases = {
11985 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11986 TEST_CASE_ST(ut_setup, ut_teardown,
11987 test_multi_session_random_usage),
11988 TEST_CASE_ST(ut_setup, ut_teardown,
11989 test_AES_chain_ccp_all),
11990 TEST_CASE_ST(ut_setup, ut_teardown,
11991 test_AES_cipheronly_ccp_all),
11992 TEST_CASE_ST(ut_setup, ut_teardown,
11993 test_3DES_chain_ccp_all),
11994 TEST_CASE_ST(ut_setup, ut_teardown,
11995 test_3DES_cipheronly_ccp_all),
11996 TEST_CASE_ST(ut_setup, ut_teardown,
11997 test_authonly_ccp_all),
11999 /** Negative tests */
12000 TEST_CASE_ST(ut_setup, ut_teardown,
12001 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12002 TEST_CASE_ST(ut_setup, ut_teardown,
12003 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12004 TEST_CASE_ST(ut_setup, ut_teardown,
12005 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12006 TEST_CASE_ST(ut_setup, ut_teardown,
12007 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12009 TEST_CASES_END() /**< NULL terminate unit test array */
12013 static struct unit_test_suite cryptodev_octeontx_testsuite = {
12014 .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
12015 .setup = testsuite_setup,
12016 .teardown = testsuite_teardown,
12017 .unit_test_cases = {
12018 TEST_CASE_ST(ut_setup, ut_teardown,
12019 test_AES_chain_octeontx_all),
12020 TEST_CASE_ST(ut_setup, ut_teardown,
12021 test_AES_cipheronly_octeontx_all),
12022 TEST_CASE_ST(ut_setup, ut_teardown,
12023 test_3DES_chain_octeontx_all),
12024 TEST_CASE_ST(ut_setup, ut_teardown,
12025 test_3DES_cipheronly_octeontx_all),
12026 TEST_CASE_ST(ut_setup, ut_teardown,
12027 test_authonly_octeontx_all),
12029 /** AES GCM Authenticated Encryption */
12030 TEST_CASE_ST(ut_setup, ut_teardown,
12031 test_AES_GCM_authenticated_encryption_test_case_1),
12032 TEST_CASE_ST(ut_setup, ut_teardown,
12033 test_AES_GCM_authenticated_encryption_test_case_2),
12034 TEST_CASE_ST(ut_setup, ut_teardown,
12035 test_AES_GCM_authenticated_encryption_test_case_3),
12036 TEST_CASE_ST(ut_setup, ut_teardown,
12037 test_AES_GCM_authenticated_encryption_test_case_4),
12038 TEST_CASE_ST(ut_setup, ut_teardown,
12039 test_AES_GCM_authenticated_encryption_test_case_5),
12040 TEST_CASE_ST(ut_setup, ut_teardown,
12041 test_AES_GCM_authenticated_encryption_test_case_6),
12042 TEST_CASE_ST(ut_setup, ut_teardown,
12043 test_AES_GCM_authenticated_encryption_test_case_7),
12045 /** AES GCM Authenticated Decryption */
12046 TEST_CASE_ST(ut_setup, ut_teardown,
12047 test_AES_GCM_authenticated_decryption_test_case_1),
12048 TEST_CASE_ST(ut_setup, ut_teardown,
12049 test_AES_GCM_authenticated_decryption_test_case_2),
12050 TEST_CASE_ST(ut_setup, ut_teardown,
12051 test_AES_GCM_authenticated_decryption_test_case_3),
12052 TEST_CASE_ST(ut_setup, ut_teardown,
12053 test_AES_GCM_authenticated_decryption_test_case_4),
12054 TEST_CASE_ST(ut_setup, ut_teardown,
12055 test_AES_GCM_authenticated_decryption_test_case_5),
12056 TEST_CASE_ST(ut_setup, ut_teardown,
12057 test_AES_GCM_authenticated_decryption_test_case_6),
12058 TEST_CASE_ST(ut_setup, ut_teardown,
12059 test_AES_GCM_authenticated_decryption_test_case_7),
12060 /** AES GMAC Authentication */
12061 TEST_CASE_ST(ut_setup, ut_teardown,
12062 test_AES_GMAC_authentication_test_case_1),
12063 TEST_CASE_ST(ut_setup, ut_teardown,
12064 test_AES_GMAC_authentication_verify_test_case_1),
12065 TEST_CASE_ST(ut_setup, ut_teardown,
12066 test_AES_GMAC_authentication_test_case_2),
12067 TEST_CASE_ST(ut_setup, ut_teardown,
12068 test_AES_GMAC_authentication_verify_test_case_2),
12069 TEST_CASE_ST(ut_setup, ut_teardown,
12070 test_AES_GMAC_authentication_test_case_3),
12071 TEST_CASE_ST(ut_setup, ut_teardown,
12072 test_AES_GMAC_authentication_verify_test_case_3),
12074 /** SNOW 3G encrypt only (UEA2) */
12075 TEST_CASE_ST(ut_setup, ut_teardown,
12076 test_snow3g_encryption_test_case_1),
12077 TEST_CASE_ST(ut_setup, ut_teardown,
12078 test_snow3g_encryption_test_case_2),
12079 TEST_CASE_ST(ut_setup, ut_teardown,
12080 test_snow3g_encryption_test_case_3),
12081 TEST_CASE_ST(ut_setup, ut_teardown,
12082 test_snow3g_encryption_test_case_4),
12083 TEST_CASE_ST(ut_setup, ut_teardown,
12084 test_snow3g_encryption_test_case_5),
12086 TEST_CASE_ST(ut_setup, ut_teardown,
12087 test_snow3g_encryption_test_case_1_oop),
12088 TEST_CASE_ST(ut_setup, ut_teardown,
12089 test_snow3g_decryption_test_case_1_oop),
12090 TEST_CASE_ST(ut_setup, ut_teardown,
12091 test_snow3g_encryption_test_case_1_oop_sgl),
12093 /** SNOW 3G decrypt only (UEA2) */
12094 TEST_CASE_ST(ut_setup, ut_teardown,
12095 test_snow3g_decryption_test_case_1),
12096 TEST_CASE_ST(ut_setup, ut_teardown,
12097 test_snow3g_decryption_test_case_2),
12098 TEST_CASE_ST(ut_setup, ut_teardown,
12099 test_snow3g_decryption_test_case_3),
12100 TEST_CASE_ST(ut_setup, ut_teardown,
12101 test_snow3g_decryption_test_case_4),
12102 TEST_CASE_ST(ut_setup, ut_teardown,
12103 test_snow3g_decryption_test_case_5),
12105 TEST_CASE_ST(ut_setup, ut_teardown,
12106 test_snow3g_hash_generate_test_case_1),
12107 TEST_CASE_ST(ut_setup, ut_teardown,
12108 test_snow3g_hash_generate_test_case_2),
12109 TEST_CASE_ST(ut_setup, ut_teardown,
12110 test_snow3g_hash_generate_test_case_3),
12111 TEST_CASE_ST(ut_setup, ut_teardown,
12112 test_snow3g_hash_verify_test_case_1),
12113 TEST_CASE_ST(ut_setup, ut_teardown,
12114 test_snow3g_hash_verify_test_case_2),
12115 TEST_CASE_ST(ut_setup, ut_teardown,
12116 test_snow3g_hash_verify_test_case_3),
12118 /** ZUC encrypt only (EEA3) */
12119 TEST_CASE_ST(ut_setup, ut_teardown,
12120 test_zuc_encryption_test_case_1),
12121 TEST_CASE_ST(ut_setup, ut_teardown,
12122 test_zuc_encryption_test_case_2),
12123 TEST_CASE_ST(ut_setup, ut_teardown,
12124 test_zuc_encryption_test_case_3),
12125 TEST_CASE_ST(ut_setup, ut_teardown,
12126 test_zuc_encryption_test_case_4),
12127 TEST_CASE_ST(ut_setup, ut_teardown,
12128 test_zuc_encryption_test_case_5),
12129 TEST_CASE_ST(ut_setup, ut_teardown,
12130 test_zuc_hash_generate_test_case_1),
12131 TEST_CASE_ST(ut_setup, ut_teardown,
12132 test_zuc_hash_generate_test_case_2),
12133 TEST_CASE_ST(ut_setup, ut_teardown,
12134 test_zuc_hash_generate_test_case_3),
12135 TEST_CASE_ST(ut_setup, ut_teardown,
12136 test_zuc_hash_generate_test_case_4),
12137 TEST_CASE_ST(ut_setup, ut_teardown,
12138 test_zuc_hash_generate_test_case_5),
12139 TEST_CASE_ST(ut_setup, ut_teardown,
12140 test_zuc_encryption_test_case_6_sgl),
12142 /** KASUMI encrypt only (UEA1) */
12143 TEST_CASE_ST(ut_setup, ut_teardown,
12144 test_kasumi_encryption_test_case_1),
12145 TEST_CASE_ST(ut_setup, ut_teardown,
12146 test_kasumi_encryption_test_case_2),
12147 TEST_CASE_ST(ut_setup, ut_teardown,
12148 test_kasumi_encryption_test_case_3),
12149 TEST_CASE_ST(ut_setup, ut_teardown,
12150 test_kasumi_encryption_test_case_4),
12151 TEST_CASE_ST(ut_setup, ut_teardown,
12152 test_kasumi_encryption_test_case_5),
12153 TEST_CASE_ST(ut_setup, ut_teardown,
12154 test_kasumi_encryption_test_case_1_sgl),
12155 TEST_CASE_ST(ut_setup, ut_teardown,
12156 test_kasumi_encryption_test_case_1_oop_sgl),
12157 /** KASUMI decrypt only (UEA1) */
12158 TEST_CASE_ST(ut_setup, ut_teardown,
12159 test_kasumi_decryption_test_case_1),
12160 TEST_CASE_ST(ut_setup, ut_teardown,
12161 test_kasumi_decryption_test_case_2),
12162 TEST_CASE_ST(ut_setup, ut_teardown,
12163 test_kasumi_decryption_test_case_3),
12164 TEST_CASE_ST(ut_setup, ut_teardown,
12165 test_kasumi_decryption_test_case_4),
12166 TEST_CASE_ST(ut_setup, ut_teardown,
12167 test_kasumi_decryption_test_case_5),
12169 TEST_CASE_ST(ut_setup, ut_teardown,
12170 test_kasumi_encryption_test_case_1_oop),
12171 TEST_CASE_ST(ut_setup, ut_teardown,
12172 test_kasumi_decryption_test_case_1_oop),
12174 /** KASUMI hash only (UIA1) */
12175 TEST_CASE_ST(ut_setup, ut_teardown,
12176 test_kasumi_hash_generate_test_case_1),
12177 TEST_CASE_ST(ut_setup, ut_teardown,
12178 test_kasumi_hash_generate_test_case_2),
12179 TEST_CASE_ST(ut_setup, ut_teardown,
12180 test_kasumi_hash_generate_test_case_3),
12181 TEST_CASE_ST(ut_setup, ut_teardown,
12182 test_kasumi_hash_generate_test_case_4),
12183 TEST_CASE_ST(ut_setup, ut_teardown,
12184 test_kasumi_hash_generate_test_case_5),
12185 TEST_CASE_ST(ut_setup, ut_teardown,
12186 test_kasumi_hash_generate_test_case_6),
12187 TEST_CASE_ST(ut_setup, ut_teardown,
12188 test_kasumi_hash_verify_test_case_1),
12189 TEST_CASE_ST(ut_setup, ut_teardown,
12190 test_kasumi_hash_verify_test_case_2),
12191 TEST_CASE_ST(ut_setup, ut_teardown,
12192 test_kasumi_hash_verify_test_case_3),
12193 TEST_CASE_ST(ut_setup, ut_teardown,
12194 test_kasumi_hash_verify_test_case_4),
12195 TEST_CASE_ST(ut_setup, ut_teardown,
12196 test_kasumi_hash_verify_test_case_5),
12199 TEST_CASE_ST(ut_setup, ut_teardown,
12200 test_null_cipher_only_operation),
12201 TEST_CASE_ST(ut_setup, ut_teardown,
12202 test_null_auth_only_operation),
12203 TEST_CASE_ST(ut_setup, ut_teardown,
12204 test_null_cipher_auth_operation),
12205 TEST_CASE_ST(ut_setup, ut_teardown,
12206 test_null_auth_cipher_operation),
12208 /** Negative tests */
12209 TEST_CASE_ST(ut_setup, ut_teardown,
12210 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12211 TEST_CASE_ST(ut_setup, ut_teardown,
12212 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12213 TEST_CASE_ST(ut_setup, ut_teardown,
12214 authentication_verify_AES128_GMAC_fail_data_corrupt),
12215 TEST_CASE_ST(ut_setup, ut_teardown,
12216 authentication_verify_AES128_GMAC_fail_tag_corrupt),
12217 TEST_CASE_ST(ut_setup, ut_teardown,
12218 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12219 TEST_CASE_ST(ut_setup, ut_teardown,
12220 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12221 TEST_CASES_END() /**< NULL terminate unit test array */
12226 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
12228 gbl_driver_id = rte_cryptodev_driver_id_get(
12229 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
12231 if (gbl_driver_id == -1) {
12232 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
12233 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
12234 "are enabled in config file to run this testsuite.\n");
12235 return TEST_SKIPPED;
12238 return unit_test_suite_runner(&cryptodev_qat_testsuite);
12242 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
12244 gbl_driver_id = rte_cryptodev_driver_id_get(
12245 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
12247 if (gbl_driver_id == -1) {
12248 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
12249 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
12250 "in config file to run this testsuite.\n");
12251 return TEST_FAILED;
12254 return unit_test_suite_runner(&cryptodev_virtio_testsuite);
12258 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
12260 gbl_driver_id = rte_cryptodev_driver_id_get(
12261 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12263 if (gbl_driver_id == -1) {
12264 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
12265 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
12266 "in config file to run this testsuite.\n");
12267 return TEST_SKIPPED;
12270 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
12274 test_cryptodev_openssl(void)
12276 gbl_driver_id = rte_cryptodev_driver_id_get(
12277 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
12279 if (gbl_driver_id == -1) {
12280 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
12281 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
12282 "in config file to run this testsuite.\n");
12283 return TEST_SKIPPED;
12286 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
12290 test_cryptodev_aesni_gcm(void)
12292 gbl_driver_id = rte_cryptodev_driver_id_get(
12293 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
12295 if (gbl_driver_id == -1) {
12296 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
12297 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
12298 "in config file to run this testsuite.\n");
12299 return TEST_SKIPPED;
12302 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
12306 test_cryptodev_null(void)
12308 gbl_driver_id = rte_cryptodev_driver_id_get(
12309 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
12311 if (gbl_driver_id == -1) {
12312 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
12313 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
12314 "in config file to run this testsuite.\n");
12315 return TEST_SKIPPED;
12318 return unit_test_suite_runner(&cryptodev_null_testsuite);
12322 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
12324 gbl_driver_id = rte_cryptodev_driver_id_get(
12325 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
12327 if (gbl_driver_id == -1) {
12328 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
12329 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
12330 "in config file to run this testsuite.\n");
12331 return TEST_SKIPPED;
12334 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
12338 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
12340 gbl_driver_id = rte_cryptodev_driver_id_get(
12341 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
12343 if (gbl_driver_id == -1) {
12344 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
12345 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
12346 "in config file to run this testsuite.\n");
12347 return TEST_SKIPPED;
12350 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
12354 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
12356 gbl_driver_id = rte_cryptodev_driver_id_get(
12357 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
12359 if (gbl_driver_id == -1) {
12360 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
12361 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
12362 "in config file to run this testsuite.\n");
12363 return TEST_SKIPPED;
12366 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
12370 test_cryptodev_armv8(void)
12372 gbl_driver_id = rte_cryptodev_driver_id_get(
12373 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
12375 if (gbl_driver_id == -1) {
12376 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
12377 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
12378 "in config file to run this testsuite.\n");
12379 return TEST_SKIPPED;
12382 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
12386 test_cryptodev_mrvl(void)
12388 gbl_driver_id = rte_cryptodev_driver_id_get(
12389 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
12391 if (gbl_driver_id == -1) {
12392 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
12393 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
12394 "in config file to run this testsuite.\n");
12395 return TEST_SKIPPED;
12398 return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
12401 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
12404 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
12406 gbl_driver_id = rte_cryptodev_driver_id_get(
12407 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
12409 if (gbl_driver_id == -1) {
12410 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
12411 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
12412 "in config file to run this testsuite.\n");
12413 return TEST_SKIPPED;
12416 if (rte_cryptodev_driver_id_get(
12417 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
12418 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
12419 " enabled in config file to run this testsuite.\n");
12420 return TEST_SKIPPED;
12422 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
12425 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
12430 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
12432 gbl_driver_id = rte_cryptodev_driver_id_get(
12433 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
12435 if (gbl_driver_id == -1) {
12436 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
12437 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
12438 "in config file to run this testsuite.\n");
12439 return TEST_SKIPPED;
12442 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
12446 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
12448 gbl_driver_id = rte_cryptodev_driver_id_get(
12449 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
12451 if (gbl_driver_id == -1) {
12452 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
12453 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
12454 "in config file to run this testsuite.\n");
12455 return TEST_SKIPPED;
12458 return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
12462 test_cryptodev_ccp(void)
12464 gbl_driver_id = rte_cryptodev_driver_id_get(
12465 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
12467 if (gbl_driver_id == -1) {
12468 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
12469 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
12470 "in config file to run this testsuite.\n");
12471 return TEST_FAILED;
12474 return unit_test_suite_runner(&cryptodev_ccp_testsuite);
12478 test_cryptodev_octeontx(void)
12480 gbl_driver_id = rte_cryptodev_driver_id_get(
12481 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
12482 if (gbl_driver_id == -1) {
12483 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
12484 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
12485 "enabled in config file to run this "
12487 return TEST_FAILED;
12489 return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
12493 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
12495 gbl_driver_id = rte_cryptodev_driver_id_get(
12496 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
12498 if (gbl_driver_id == -1) {
12499 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
12500 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
12501 "in config file to run this testsuite.\n");
12502 return TEST_FAILED;
12505 return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
12508 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
12509 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
12510 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
12511 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
12512 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
12513 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
12514 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
12515 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
12516 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
12517 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
12518 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
12519 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
12520 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
12521 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
12522 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
12523 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);