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_cplane_decap(int i)
7221 return test_pdcp_proto(i, 0,
7222 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7223 RTE_CRYPTO_AUTH_OP_VERIFY,
7224 pdcp_test_data_out[i],
7225 pdcp_test_data_in_len[i] + 4,
7226 pdcp_test_data_in[i],
7227 pdcp_test_data_in_len[i]);
7233 test_AES_GCM_authenticated_encryption_test_case_1(void)
7235 return test_authenticated_encryption(&gcm_test_case_1);
7239 test_AES_GCM_authenticated_encryption_test_case_2(void)
7241 return test_authenticated_encryption(&gcm_test_case_2);
7245 test_AES_GCM_authenticated_encryption_test_case_3(void)
7247 return test_authenticated_encryption(&gcm_test_case_3);
7251 test_AES_GCM_authenticated_encryption_test_case_4(void)
7253 return test_authenticated_encryption(&gcm_test_case_4);
7257 test_AES_GCM_authenticated_encryption_test_case_5(void)
7259 return test_authenticated_encryption(&gcm_test_case_5);
7263 test_AES_GCM_authenticated_encryption_test_case_6(void)
7265 return test_authenticated_encryption(&gcm_test_case_6);
7269 test_AES_GCM_authenticated_encryption_test_case_7(void)
7271 return test_authenticated_encryption(&gcm_test_case_7);
7275 test_AES_GCM_auth_encryption_test_case_192_1(void)
7277 return test_authenticated_encryption(&gcm_test_case_192_1);
7281 test_AES_GCM_auth_encryption_test_case_192_2(void)
7283 return test_authenticated_encryption(&gcm_test_case_192_2);
7287 test_AES_GCM_auth_encryption_test_case_192_3(void)
7289 return test_authenticated_encryption(&gcm_test_case_192_3);
7293 test_AES_GCM_auth_encryption_test_case_192_4(void)
7295 return test_authenticated_encryption(&gcm_test_case_192_4);
7299 test_AES_GCM_auth_encryption_test_case_192_5(void)
7301 return test_authenticated_encryption(&gcm_test_case_192_5);
7305 test_AES_GCM_auth_encryption_test_case_192_6(void)
7307 return test_authenticated_encryption(&gcm_test_case_192_6);
7311 test_AES_GCM_auth_encryption_test_case_192_7(void)
7313 return test_authenticated_encryption(&gcm_test_case_192_7);
7317 test_AES_GCM_auth_encryption_test_case_256_1(void)
7319 return test_authenticated_encryption(&gcm_test_case_256_1);
7323 test_AES_GCM_auth_encryption_test_case_256_2(void)
7325 return test_authenticated_encryption(&gcm_test_case_256_2);
7329 test_AES_GCM_auth_encryption_test_case_256_3(void)
7331 return test_authenticated_encryption(&gcm_test_case_256_3);
7335 test_AES_GCM_auth_encryption_test_case_256_4(void)
7337 return test_authenticated_encryption(&gcm_test_case_256_4);
7341 test_AES_GCM_auth_encryption_test_case_256_5(void)
7343 return test_authenticated_encryption(&gcm_test_case_256_5);
7347 test_AES_GCM_auth_encryption_test_case_256_6(void)
7349 return test_authenticated_encryption(&gcm_test_case_256_6);
7353 test_AES_GCM_auth_encryption_test_case_256_7(void)
7355 return test_authenticated_encryption(&gcm_test_case_256_7);
7359 test_AES_GCM_auth_encryption_test_case_aad_1(void)
7361 return test_authenticated_encryption(&gcm_test_case_aad_1);
7365 test_AES_GCM_auth_encryption_test_case_aad_2(void)
7367 return test_authenticated_encryption(&gcm_test_case_aad_2);
7371 test_authenticated_decryption(const struct aead_test_data *tdata)
7373 struct crypto_testsuite_params *ts_params = &testsuite_params;
7374 struct crypto_unittest_params *ut_params = &unittest_params;
7380 /* Create AEAD session */
7381 retval = create_aead_session(ts_params->valid_devs[0],
7383 RTE_CRYPTO_AEAD_OP_DECRYPT,
7384 tdata->key.data, tdata->key.len,
7385 tdata->aad.len, tdata->auth_tag.len,
7390 /* alloc mbuf and set payload */
7391 if (tdata->aad.len > MBUF_SIZE) {
7392 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7393 /* Populate full size of add data */
7394 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7395 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7397 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7399 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7400 rte_pktmbuf_tailroom(ut_params->ibuf));
7402 /* Create AEAD operation */
7403 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7407 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7409 ut_params->op->sym->m_src = ut_params->ibuf;
7411 /* Process crypto operation */
7412 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7413 ut_params->op), "failed to process sym crypto op");
7415 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7416 "crypto op processing failed");
7418 if (ut_params->op->sym->m_dst)
7419 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7422 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7424 ut_params->op->sym->cipher.data.offset);
7426 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7429 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7431 tdata->plaintext.data,
7432 tdata->plaintext.len,
7433 "Plaintext data not as expected");
7435 TEST_ASSERT_EQUAL(ut_params->op->status,
7436 RTE_CRYPTO_OP_STATUS_SUCCESS,
7437 "Authentication failed");
7442 test_AES_GCM_authenticated_decryption_test_case_1(void)
7444 return test_authenticated_decryption(&gcm_test_case_1);
7448 test_AES_GCM_authenticated_decryption_test_case_2(void)
7450 return test_authenticated_decryption(&gcm_test_case_2);
7454 test_AES_GCM_authenticated_decryption_test_case_3(void)
7456 return test_authenticated_decryption(&gcm_test_case_3);
7460 test_AES_GCM_authenticated_decryption_test_case_4(void)
7462 return test_authenticated_decryption(&gcm_test_case_4);
7466 test_AES_GCM_authenticated_decryption_test_case_5(void)
7468 return test_authenticated_decryption(&gcm_test_case_5);
7472 test_AES_GCM_authenticated_decryption_test_case_6(void)
7474 return test_authenticated_decryption(&gcm_test_case_6);
7478 test_AES_GCM_authenticated_decryption_test_case_7(void)
7480 return test_authenticated_decryption(&gcm_test_case_7);
7484 test_AES_GCM_auth_decryption_test_case_192_1(void)
7486 return test_authenticated_decryption(&gcm_test_case_192_1);
7490 test_AES_GCM_auth_decryption_test_case_192_2(void)
7492 return test_authenticated_decryption(&gcm_test_case_192_2);
7496 test_AES_GCM_auth_decryption_test_case_192_3(void)
7498 return test_authenticated_decryption(&gcm_test_case_192_3);
7502 test_AES_GCM_auth_decryption_test_case_192_4(void)
7504 return test_authenticated_decryption(&gcm_test_case_192_4);
7508 test_AES_GCM_auth_decryption_test_case_192_5(void)
7510 return test_authenticated_decryption(&gcm_test_case_192_5);
7514 test_AES_GCM_auth_decryption_test_case_192_6(void)
7516 return test_authenticated_decryption(&gcm_test_case_192_6);
7520 test_AES_GCM_auth_decryption_test_case_192_7(void)
7522 return test_authenticated_decryption(&gcm_test_case_192_7);
7526 test_AES_GCM_auth_decryption_test_case_256_1(void)
7528 return test_authenticated_decryption(&gcm_test_case_256_1);
7532 test_AES_GCM_auth_decryption_test_case_256_2(void)
7534 return test_authenticated_decryption(&gcm_test_case_256_2);
7538 test_AES_GCM_auth_decryption_test_case_256_3(void)
7540 return test_authenticated_decryption(&gcm_test_case_256_3);
7544 test_AES_GCM_auth_decryption_test_case_256_4(void)
7546 return test_authenticated_decryption(&gcm_test_case_256_4);
7550 test_AES_GCM_auth_decryption_test_case_256_5(void)
7552 return test_authenticated_decryption(&gcm_test_case_256_5);
7556 test_AES_GCM_auth_decryption_test_case_256_6(void)
7558 return test_authenticated_decryption(&gcm_test_case_256_6);
7562 test_AES_GCM_auth_decryption_test_case_256_7(void)
7564 return test_authenticated_decryption(&gcm_test_case_256_7);
7568 test_AES_GCM_auth_decryption_test_case_aad_1(void)
7570 return test_authenticated_decryption(&gcm_test_case_aad_1);
7574 test_AES_GCM_auth_decryption_test_case_aad_2(void)
7576 return test_authenticated_decryption(&gcm_test_case_aad_2);
7580 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
7582 struct crypto_testsuite_params *ts_params = &testsuite_params;
7583 struct crypto_unittest_params *ut_params = &unittest_params;
7586 uint8_t *ciphertext, *auth_tag;
7587 uint16_t plaintext_pad_len;
7589 /* Create AEAD session */
7590 retval = create_aead_session(ts_params->valid_devs[0],
7592 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7593 tdata->key.data, tdata->key.len,
7594 tdata->aad.len, tdata->auth_tag.len,
7599 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7600 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7602 /* clear mbuf payload */
7603 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7604 rte_pktmbuf_tailroom(ut_params->ibuf));
7605 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7606 rte_pktmbuf_tailroom(ut_params->obuf));
7608 /* Create AEAD operation */
7609 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7613 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7615 ut_params->op->sym->m_src = ut_params->ibuf;
7616 ut_params->op->sym->m_dst = ut_params->obuf;
7618 /* Process crypto operation */
7619 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7620 ut_params->op), "failed to process sym crypto op");
7622 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7623 "crypto op processing failed");
7625 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7627 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
7628 ut_params->op->sym->cipher.data.offset);
7629 auth_tag = ciphertext + plaintext_pad_len;
7631 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7632 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7635 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7637 tdata->ciphertext.data,
7638 tdata->ciphertext.len,
7639 "Ciphertext data not as expected");
7641 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7643 tdata->auth_tag.data,
7644 tdata->auth_tag.len,
7645 "Generated auth tag not as expected");
7652 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
7654 return test_authenticated_encryption_oop(&gcm_test_case_5);
7658 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
7660 struct crypto_testsuite_params *ts_params = &testsuite_params;
7661 struct crypto_unittest_params *ut_params = &unittest_params;
7666 /* Create AEAD session */
7667 retval = create_aead_session(ts_params->valid_devs[0],
7669 RTE_CRYPTO_AEAD_OP_DECRYPT,
7670 tdata->key.data, tdata->key.len,
7671 tdata->aad.len, tdata->auth_tag.len,
7676 /* alloc mbuf and set payload */
7677 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7678 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7680 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7681 rte_pktmbuf_tailroom(ut_params->ibuf));
7682 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7683 rte_pktmbuf_tailroom(ut_params->obuf));
7685 /* Create AEAD operation */
7686 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7690 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7692 ut_params->op->sym->m_src = ut_params->ibuf;
7693 ut_params->op->sym->m_dst = ut_params->obuf;
7695 /* Process crypto operation */
7696 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7697 ut_params->op), "failed to process sym crypto op");
7699 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7700 "crypto op processing failed");
7702 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
7703 ut_params->op->sym->cipher.data.offset);
7705 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7708 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7710 tdata->plaintext.data,
7711 tdata->plaintext.len,
7712 "Plaintext data not as expected");
7714 TEST_ASSERT_EQUAL(ut_params->op->status,
7715 RTE_CRYPTO_OP_STATUS_SUCCESS,
7716 "Authentication failed");
7721 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
7723 return test_authenticated_decryption_oop(&gcm_test_case_5);
7727 test_authenticated_encryption_sessionless(
7728 const struct aead_test_data *tdata)
7730 struct crypto_testsuite_params *ts_params = &testsuite_params;
7731 struct crypto_unittest_params *ut_params = &unittest_params;
7734 uint8_t *ciphertext, *auth_tag;
7735 uint16_t plaintext_pad_len;
7736 uint8_t key[tdata->key.len + 1];
7738 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7740 /* clear mbuf payload */
7741 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7742 rte_pktmbuf_tailroom(ut_params->ibuf));
7744 /* Create AEAD operation */
7745 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7749 /* Create GCM xform */
7750 memcpy(key, tdata->key.data, tdata->key.len);
7751 retval = create_aead_xform(ut_params->op,
7753 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7754 key, tdata->key.len,
7755 tdata->aad.len, tdata->auth_tag.len,
7760 ut_params->op->sym->m_src = ut_params->ibuf;
7762 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
7763 RTE_CRYPTO_OP_SESSIONLESS,
7764 "crypto op session type not sessionless");
7766 /* Process crypto operation */
7767 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7768 ut_params->op), "failed to process sym crypto op");
7770 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7772 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7773 "crypto op status not success");
7775 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7777 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7778 ut_params->op->sym->cipher.data.offset);
7779 auth_tag = ciphertext + plaintext_pad_len;
7781 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7782 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7785 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7787 tdata->ciphertext.data,
7788 tdata->ciphertext.len,
7789 "Ciphertext data not as expected");
7791 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7793 tdata->auth_tag.data,
7794 tdata->auth_tag.len,
7795 "Generated auth tag not as expected");
7802 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
7804 return test_authenticated_encryption_sessionless(
7809 test_authenticated_decryption_sessionless(
7810 const struct aead_test_data *tdata)
7812 struct crypto_testsuite_params *ts_params = &testsuite_params;
7813 struct crypto_unittest_params *ut_params = &unittest_params;
7817 uint8_t key[tdata->key.len + 1];
7819 /* alloc mbuf and set payload */
7820 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7822 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7823 rte_pktmbuf_tailroom(ut_params->ibuf));
7825 /* Create AEAD operation */
7826 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
7830 /* Create AEAD xform */
7831 memcpy(key, tdata->key.data, tdata->key.len);
7832 retval = create_aead_xform(ut_params->op,
7834 RTE_CRYPTO_AEAD_OP_DECRYPT,
7835 key, tdata->key.len,
7836 tdata->aad.len, tdata->auth_tag.len,
7841 ut_params->op->sym->m_src = ut_params->ibuf;
7843 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
7844 RTE_CRYPTO_OP_SESSIONLESS,
7845 "crypto op session type not sessionless");
7847 /* Process crypto operation */
7848 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7849 ut_params->op), "failed to process sym crypto op");
7851 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7853 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7854 "crypto op status not success");
7856 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7857 ut_params->op->sym->cipher.data.offset);
7859 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
7862 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7864 tdata->plaintext.data,
7865 tdata->plaintext.len,
7866 "Plaintext data not as expected");
7868 TEST_ASSERT_EQUAL(ut_params->op->status,
7869 RTE_CRYPTO_OP_STATUS_SUCCESS,
7870 "Authentication failed");
7875 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
7877 return test_authenticated_decryption_sessionless(
7882 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
7884 return test_authenticated_encryption(&ccm_test_case_128_1);
7888 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
7890 return test_authenticated_encryption(&ccm_test_case_128_2);
7894 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
7896 return test_authenticated_encryption(&ccm_test_case_128_3);
7900 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
7902 return test_authenticated_decryption(&ccm_test_case_128_1);
7906 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
7908 return test_authenticated_decryption(&ccm_test_case_128_2);
7912 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
7914 return test_authenticated_decryption(&ccm_test_case_128_3);
7918 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
7920 return test_authenticated_encryption(&ccm_test_case_192_1);
7924 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
7926 return test_authenticated_encryption(&ccm_test_case_192_2);
7930 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
7932 return test_authenticated_encryption(&ccm_test_case_192_3);
7936 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
7938 return test_authenticated_decryption(&ccm_test_case_192_1);
7942 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
7944 return test_authenticated_decryption(&ccm_test_case_192_2);
7948 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
7950 return test_authenticated_decryption(&ccm_test_case_192_3);
7954 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
7956 return test_authenticated_encryption(&ccm_test_case_256_1);
7960 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
7962 return test_authenticated_encryption(&ccm_test_case_256_2);
7966 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
7968 return test_authenticated_encryption(&ccm_test_case_256_3);
7972 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
7974 return test_authenticated_decryption(&ccm_test_case_256_1);
7978 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
7980 return test_authenticated_decryption(&ccm_test_case_256_2);
7984 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
7986 return test_authenticated_decryption(&ccm_test_case_256_3);
7992 struct crypto_testsuite_params *ts_params = &testsuite_params;
7993 struct rte_cryptodev_stats stats;
7994 struct rte_cryptodev *dev;
7995 cryptodev_stats_get_t temp_pfn;
7997 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
7998 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
7999 &stats) == -ENODEV),
8000 "rte_cryptodev_stats_get invalid dev failed");
8001 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
8002 "rte_cryptodev_stats_get invalid Param failed");
8003 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
8004 temp_pfn = dev->dev_ops->stats_get;
8005 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
8006 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
8008 "rte_cryptodev_stats_get invalid Param failed");
8009 dev->dev_ops->stats_get = temp_pfn;
8011 /* Test expected values */
8013 test_AES_CBC_HMAC_SHA1_encrypt_digest();
8015 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8017 "rte_cryptodev_stats_get failed");
8018 TEST_ASSERT((stats.enqueued_count == 1),
8019 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8020 TEST_ASSERT((stats.dequeued_count == 1),
8021 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8022 TEST_ASSERT((stats.enqueue_err_count == 0),
8023 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8024 TEST_ASSERT((stats.dequeue_err_count == 0),
8025 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8027 /* invalid device but should ignore and not reset device stats*/
8028 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
8029 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8031 "rte_cryptodev_stats_get failed");
8032 TEST_ASSERT((stats.enqueued_count == 1),
8033 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8035 /* check that a valid reset clears stats */
8036 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
8037 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8039 "rte_cryptodev_stats_get failed");
8040 TEST_ASSERT((stats.enqueued_count == 0),
8041 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8042 TEST_ASSERT((stats.dequeued_count == 0),
8043 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8045 return TEST_SUCCESS;
8048 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
8049 struct crypto_unittest_params *ut_params,
8050 enum rte_crypto_auth_operation op,
8051 const struct HMAC_MD5_vector *test_case)
8055 memcpy(key, test_case->key.data, test_case->key.len);
8057 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8058 ut_params->auth_xform.next = NULL;
8059 ut_params->auth_xform.auth.op = op;
8061 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
8063 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
8064 ut_params->auth_xform.auth.key.length = test_case->key.len;
8065 ut_params->auth_xform.auth.key.data = key;
8067 ut_params->sess = rte_cryptodev_sym_session_create(
8068 ts_params->session_mpool);
8070 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8071 ut_params->sess, &ut_params->auth_xform,
8072 ts_params->session_priv_mpool);
8074 if (ut_params->sess == NULL)
8077 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8079 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8080 rte_pktmbuf_tailroom(ut_params->ibuf));
8085 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
8086 const struct HMAC_MD5_vector *test_case,
8087 uint8_t **plaintext)
8089 uint16_t plaintext_pad_len;
8091 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8093 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8096 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8098 memcpy(*plaintext, test_case->plaintext.data,
8099 test_case->plaintext.len);
8101 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8102 ut_params->ibuf, MD5_DIGEST_LEN);
8103 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8104 "no room to append digest");
8105 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8106 ut_params->ibuf, plaintext_pad_len);
8108 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
8109 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
8110 test_case->auth_tag.len);
8113 sym_op->auth.data.offset = 0;
8114 sym_op->auth.data.length = test_case->plaintext.len;
8116 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8117 ut_params->op->sym->m_src = ut_params->ibuf;
8123 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
8125 uint16_t plaintext_pad_len;
8126 uint8_t *plaintext, *auth_tag;
8128 struct crypto_testsuite_params *ts_params = &testsuite_params;
8129 struct crypto_unittest_params *ut_params = &unittest_params;
8131 if (MD5_HMAC_create_session(ts_params, ut_params,
8132 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
8135 /* Generate Crypto op data structure */
8136 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8137 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8138 TEST_ASSERT_NOT_NULL(ut_params->op,
8139 "Failed to allocate symmetric crypto operation struct");
8141 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8144 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
8147 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8148 ut_params->op), "failed to process sym crypto op");
8150 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8151 "crypto op processing failed");
8153 if (ut_params->op->sym->m_dst) {
8154 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8155 uint8_t *, plaintext_pad_len);
8157 auth_tag = plaintext + plaintext_pad_len;
8160 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8162 test_case->auth_tag.data,
8163 test_case->auth_tag.len,
8164 "HMAC_MD5 generated tag not as expected");
8166 return TEST_SUCCESS;
8170 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
8174 struct crypto_testsuite_params *ts_params = &testsuite_params;
8175 struct crypto_unittest_params *ut_params = &unittest_params;
8177 if (MD5_HMAC_create_session(ts_params, ut_params,
8178 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
8182 /* Generate Crypto op data structure */
8183 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8184 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8185 TEST_ASSERT_NOT_NULL(ut_params->op,
8186 "Failed to allocate symmetric crypto operation struct");
8188 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
8191 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8192 ut_params->op), "failed to process sym crypto op");
8194 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8195 "HMAC_MD5 crypto op processing failed");
8197 return TEST_SUCCESS;
8201 test_MD5_HMAC_generate_case_1(void)
8203 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
8207 test_MD5_HMAC_verify_case_1(void)
8209 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
8213 test_MD5_HMAC_generate_case_2(void)
8215 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
8219 test_MD5_HMAC_verify_case_2(void)
8221 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
8225 test_multi_session(void)
8227 struct crypto_testsuite_params *ts_params = &testsuite_params;
8228 struct crypto_unittest_params *ut_params = &unittest_params;
8230 struct rte_cryptodev_info dev_info;
8231 struct rte_cryptodev_sym_session **sessions;
8235 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
8236 aes_cbc_key, hmac_sha512_key);
8239 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8241 sessions = rte_malloc(NULL,
8242 (sizeof(struct rte_cryptodev_sym_session *) *
8243 MAX_NB_SESSIONS) + 1, 0);
8245 /* Create multiple crypto sessions*/
8246 for (i = 0; i < MAX_NB_SESSIONS; i++) {
8248 sessions[i] = rte_cryptodev_sym_session_create(
8249 ts_params->session_mpool);
8251 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8252 sessions[i], &ut_params->auth_xform,
8253 ts_params->session_priv_mpool);
8254 TEST_ASSERT_NOT_NULL(sessions[i],
8255 "Session creation failed at session number %u",
8258 /* Attempt to send a request on each session */
8259 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
8263 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
8264 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
8266 "Failed to perform decrypt on request number %u.", i);
8267 /* free crypto operation structure */
8269 rte_crypto_op_free(ut_params->op);
8272 * free mbuf - both obuf and ibuf are usually the same,
8273 * so check if they point at the same address is necessary,
8274 * to avoid freeing the mbuf twice.
8276 if (ut_params->obuf) {
8277 rte_pktmbuf_free(ut_params->obuf);
8278 if (ut_params->ibuf == ut_params->obuf)
8279 ut_params->ibuf = 0;
8280 ut_params->obuf = 0;
8282 if (ut_params->ibuf) {
8283 rte_pktmbuf_free(ut_params->ibuf);
8284 ut_params->ibuf = 0;
8288 /* Next session create should fail */
8289 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8290 sessions[i], &ut_params->auth_xform,
8291 ts_params->session_priv_mpool);
8292 TEST_ASSERT_NULL(sessions[i],
8293 "Session creation succeeded unexpectedly!");
8295 for (i = 0; i < MAX_NB_SESSIONS; i++) {
8296 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
8298 rte_cryptodev_sym_session_free(sessions[i]);
8303 return TEST_SUCCESS;
8306 struct multi_session_params {
8307 struct crypto_unittest_params ut_params;
8308 uint8_t *cipher_key;
8310 const uint8_t *cipher;
8311 const uint8_t *digest;
8315 #define MB_SESSION_NUMBER 3
8318 test_multi_session_random_usage(void)
8320 struct crypto_testsuite_params *ts_params = &testsuite_params;
8321 struct rte_cryptodev_info dev_info;
8322 struct rte_cryptodev_sym_session **sessions;
8324 struct multi_session_params ut_paramz[] = {
8327 .cipher_key = ms_aes_cbc_key0,
8328 .hmac_key = ms_hmac_key0,
8329 .cipher = ms_aes_cbc_cipher0,
8330 .digest = ms_hmac_digest0,
8331 .iv = ms_aes_cbc_iv0
8334 .cipher_key = ms_aes_cbc_key1,
8335 .hmac_key = ms_hmac_key1,
8336 .cipher = ms_aes_cbc_cipher1,
8337 .digest = ms_hmac_digest1,
8338 .iv = ms_aes_cbc_iv1
8341 .cipher_key = ms_aes_cbc_key2,
8342 .hmac_key = ms_hmac_key2,
8343 .cipher = ms_aes_cbc_cipher2,
8344 .digest = ms_hmac_digest2,
8345 .iv = ms_aes_cbc_iv2
8350 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8352 sessions = rte_malloc(NULL,
8353 (sizeof(struct rte_cryptodev_sym_session *)
8354 * MAX_NB_SESSIONS) + 1, 0);
8356 for (i = 0; i < MB_SESSION_NUMBER; i++) {
8357 sessions[i] = rte_cryptodev_sym_session_create(
8358 ts_params->session_mpool);
8360 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
8361 sizeof(struct crypto_unittest_params));
8363 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
8364 &ut_paramz[i].ut_params,
8365 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
8367 /* Create multiple crypto sessions*/
8368 rte_cryptodev_sym_session_init(
8369 ts_params->valid_devs[0],
8371 &ut_paramz[i].ut_params.auth_xform,
8372 ts_params->session_priv_mpool);
8374 TEST_ASSERT_NOT_NULL(sessions[i],
8375 "Session creation failed at session number %u",
8381 for (i = 0; i < 40000; i++) {
8383 j = rand() % MB_SESSION_NUMBER;
8385 TEST_ASSERT_SUCCESS(
8386 test_AES_CBC_HMAC_SHA512_decrypt_perform(
8388 &ut_paramz[j].ut_params,
8389 ts_params, ut_paramz[j].cipher,
8390 ut_paramz[j].digest,
8392 "Failed to perform decrypt on request number %u.", i);
8394 if (ut_paramz[j].ut_params.op)
8395 rte_crypto_op_free(ut_paramz[j].ut_params.op);
8398 * free mbuf - both obuf and ibuf are usually the same,
8399 * so check if they point at the same address is necessary,
8400 * to avoid freeing the mbuf twice.
8402 if (ut_paramz[j].ut_params.obuf) {
8403 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
8404 if (ut_paramz[j].ut_params.ibuf
8405 == ut_paramz[j].ut_params.obuf)
8406 ut_paramz[j].ut_params.ibuf = 0;
8407 ut_paramz[j].ut_params.obuf = 0;
8409 if (ut_paramz[j].ut_params.ibuf) {
8410 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
8411 ut_paramz[j].ut_params.ibuf = 0;
8415 for (i = 0; i < MB_SESSION_NUMBER; i++) {
8416 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
8418 rte_cryptodev_sym_session_free(sessions[i]);
8423 return TEST_SUCCESS;
8427 test_null_cipher_only_operation(void)
8429 struct crypto_testsuite_params *ts_params = &testsuite_params;
8430 struct crypto_unittest_params *ut_params = &unittest_params;
8432 /* Generate test mbuf data and space for digest */
8433 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8434 catch_22_quote, QUOTE_512_BYTES, 0);
8436 /* Setup Cipher Parameters */
8437 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8438 ut_params->cipher_xform.next = NULL;
8440 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8441 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8443 ut_params->sess = rte_cryptodev_sym_session_create(
8444 ts_params->session_mpool);
8446 /* Create Crypto session*/
8447 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8449 &ut_params->cipher_xform,
8450 ts_params->session_priv_mpool);
8451 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8453 /* Generate Crypto op data structure */
8454 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8455 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8456 TEST_ASSERT_NOT_NULL(ut_params->op,
8457 "Failed to allocate symmetric crypto operation struct");
8459 /* Set crypto operation data parameters */
8460 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8462 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8464 /* set crypto operation source mbuf */
8465 sym_op->m_src = ut_params->ibuf;
8467 sym_op->cipher.data.offset = 0;
8468 sym_op->cipher.data.length = QUOTE_512_BYTES;
8470 /* Process crypto operation */
8471 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8473 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8475 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8476 "crypto operation processing failed");
8479 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8480 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8483 "Ciphertext data not as expected");
8485 return TEST_SUCCESS;
8487 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
8488 0xab, 0xab, 0xab, 0xab,
8489 0xab, 0xab, 0xab, 0xab,
8490 0xab, 0xab, 0xab, 0xab};
8492 test_null_auth_only_operation(void)
8494 struct crypto_testsuite_params *ts_params = &testsuite_params;
8495 struct crypto_unittest_params *ut_params = &unittest_params;
8498 /* Generate test mbuf data and space for digest */
8499 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8500 catch_22_quote, QUOTE_512_BYTES, 0);
8502 /* create a pointer for digest, but don't expect anything to be written
8503 * here in a NULL auth algo so no mbuf append done.
8505 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8507 /* prefill the memory pointed to by digest */
8508 memcpy(digest, orig_data, sizeof(orig_data));
8510 /* Setup HMAC Parameters */
8511 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8512 ut_params->auth_xform.next = NULL;
8514 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8515 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8517 ut_params->sess = rte_cryptodev_sym_session_create(
8518 ts_params->session_mpool);
8520 /* Create Crypto session*/
8521 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8522 ut_params->sess, &ut_params->auth_xform,
8523 ts_params->session_priv_mpool);
8524 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8526 /* Generate Crypto op data structure */
8527 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8528 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8529 TEST_ASSERT_NOT_NULL(ut_params->op,
8530 "Failed to allocate symmetric crypto operation struct");
8532 /* Set crypto operation data parameters */
8533 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8535 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8537 sym_op->m_src = ut_params->ibuf;
8539 sym_op->auth.data.offset = 0;
8540 sym_op->auth.data.length = QUOTE_512_BYTES;
8541 sym_op->auth.digest.data = digest;
8542 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8545 /* Process crypto operation */
8546 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8548 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8550 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8551 "crypto operation processing failed");
8552 /* Make sure memory pointed to by digest hasn't been overwritten */
8553 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8557 "Memory at digest ptr overwritten unexpectedly");
8559 return TEST_SUCCESS;
8564 test_null_cipher_auth_operation(void)
8566 struct crypto_testsuite_params *ts_params = &testsuite_params;
8567 struct crypto_unittest_params *ut_params = &unittest_params;
8570 /* Generate test mbuf data and space for digest */
8571 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8572 catch_22_quote, QUOTE_512_BYTES, 0);
8574 /* create a pointer for digest, but don't expect anything to be written
8575 * here in a NULL auth algo so no mbuf append done.
8577 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8579 /* prefill the memory pointed to by digest */
8580 memcpy(digest, orig_data, sizeof(orig_data));
8582 /* Setup Cipher Parameters */
8583 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8584 ut_params->cipher_xform.next = &ut_params->auth_xform;
8586 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8587 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8589 /* Setup HMAC Parameters */
8590 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8591 ut_params->auth_xform.next = NULL;
8593 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8594 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8596 ut_params->sess = rte_cryptodev_sym_session_create(
8597 ts_params->session_mpool);
8599 /* Create Crypto session*/
8600 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8601 ut_params->sess, &ut_params->cipher_xform,
8602 ts_params->session_priv_mpool);
8603 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8605 /* Generate Crypto op data structure */
8606 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8607 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8608 TEST_ASSERT_NOT_NULL(ut_params->op,
8609 "Failed to allocate symmetric crypto operation struct");
8611 /* Set crypto operation data parameters */
8612 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8614 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8616 sym_op->m_src = ut_params->ibuf;
8618 sym_op->cipher.data.offset = 0;
8619 sym_op->cipher.data.length = QUOTE_512_BYTES;
8621 sym_op->auth.data.offset = 0;
8622 sym_op->auth.data.length = QUOTE_512_BYTES;
8623 sym_op->auth.digest.data = digest;
8624 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8627 /* Process crypto operation */
8628 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8630 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8632 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8633 "crypto operation processing failed");
8636 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8637 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8640 "Ciphertext data not as expected");
8641 /* Make sure memory pointed to by digest hasn't been overwritten */
8642 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8646 "Memory at digest ptr overwritten unexpectedly");
8648 return TEST_SUCCESS;
8652 test_null_auth_cipher_operation(void)
8654 struct crypto_testsuite_params *ts_params = &testsuite_params;
8655 struct crypto_unittest_params *ut_params = &unittest_params;
8658 /* Generate test mbuf data */
8659 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
8660 catch_22_quote, QUOTE_512_BYTES, 0);
8662 /* create a pointer for digest, but don't expect anything to be written
8663 * here in a NULL auth algo so no mbuf append done.
8665 digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8667 /* prefill the memory pointed to by digest */
8668 memcpy(digest, orig_data, sizeof(orig_data));
8670 /* Setup Cipher Parameters */
8671 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8672 ut_params->cipher_xform.next = NULL;
8674 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8675 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8677 /* Setup HMAC Parameters */
8678 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8679 ut_params->auth_xform.next = &ut_params->cipher_xform;
8681 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8682 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8684 ut_params->sess = rte_cryptodev_sym_session_create(
8685 ts_params->session_mpool);
8687 /* Create Crypto session*/
8688 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8689 ut_params->sess, &ut_params->cipher_xform,
8690 ts_params->session_priv_mpool);
8691 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8693 /* Generate Crypto op data structure */
8694 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8695 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8696 TEST_ASSERT_NOT_NULL(ut_params->op,
8697 "Failed to allocate symmetric crypto operation struct");
8699 /* Set crypto operation data parameters */
8700 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8702 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8704 sym_op->m_src = ut_params->ibuf;
8706 sym_op->cipher.data.offset = 0;
8707 sym_op->cipher.data.length = QUOTE_512_BYTES;
8709 sym_op->auth.data.offset = 0;
8710 sym_op->auth.data.length = QUOTE_512_BYTES;
8711 sym_op->auth.digest.data = digest;
8712 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
8715 /* Process crypto operation */
8716 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8718 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
8720 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8721 "crypto operation processing failed");
8724 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8725 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
8728 "Ciphertext data not as expected");
8729 /* Make sure memory pointed to by digest hasn't been overwritten */
8730 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8734 "Memory at digest ptr overwritten unexpectedly");
8736 return TEST_SUCCESS;
8741 test_null_invalid_operation(void)
8743 struct crypto_testsuite_params *ts_params = &testsuite_params;
8744 struct crypto_unittest_params *ut_params = &unittest_params;
8747 /* Setup Cipher Parameters */
8748 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8749 ut_params->cipher_xform.next = NULL;
8751 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
8752 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8754 ut_params->sess = rte_cryptodev_sym_session_create(
8755 ts_params->session_mpool);
8757 /* Create Crypto session*/
8758 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8759 ut_params->sess, &ut_params->cipher_xform,
8760 ts_params->session_priv_mpool);
8761 TEST_ASSERT(ret < 0,
8762 "Session creation succeeded unexpectedly");
8765 /* Setup HMAC Parameters */
8766 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8767 ut_params->auth_xform.next = NULL;
8769 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
8770 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8772 ut_params->sess = rte_cryptodev_sym_session_create(
8773 ts_params->session_mpool);
8775 /* Create Crypto session*/
8776 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8777 ut_params->sess, &ut_params->auth_xform,
8778 ts_params->session_priv_mpool);
8779 TEST_ASSERT(ret < 0,
8780 "Session creation succeeded unexpectedly");
8782 return TEST_SUCCESS;
8786 #define NULL_BURST_LENGTH (32)
8789 test_null_burst_operation(void)
8791 struct crypto_testsuite_params *ts_params = &testsuite_params;
8792 struct crypto_unittest_params *ut_params = &unittest_params;
8794 unsigned i, burst_len = NULL_BURST_LENGTH;
8796 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
8797 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
8799 /* Setup Cipher Parameters */
8800 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8801 ut_params->cipher_xform.next = &ut_params->auth_xform;
8803 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
8804 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8806 /* Setup HMAC Parameters */
8807 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8808 ut_params->auth_xform.next = NULL;
8810 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
8811 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
8813 ut_params->sess = rte_cryptodev_sym_session_create(
8814 ts_params->session_mpool);
8816 /* Create Crypto session*/
8817 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8818 ut_params->sess, &ut_params->cipher_xform,
8819 ts_params->session_priv_mpool);
8820 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8822 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
8823 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
8824 burst_len, "failed to generate burst of crypto ops");
8826 /* Generate an operation for each mbuf in burst */
8827 for (i = 0; i < burst_len; i++) {
8828 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8830 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
8832 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
8836 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
8838 burst[i]->sym->m_src = m;
8841 /* Process crypto operation */
8842 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
8843 0, burst, burst_len),
8845 "Error enqueuing burst");
8847 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
8848 0, burst_dequeued, burst_len),
8850 "Error dequeuing burst");
8853 for (i = 0; i < burst_len; i++) {
8855 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
8856 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
8858 "data not as expected");
8860 rte_pktmbuf_free(burst[i]->sym->m_src);
8861 rte_crypto_op_free(burst[i]);
8864 return TEST_SUCCESS;
8868 generate_gmac_large_plaintext(uint8_t *data)
8872 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
8873 memcpy(&data[i], &data[0], 32);
8877 create_gmac_operation(enum rte_crypto_auth_operation op,
8878 const struct gmac_test_data *tdata)
8880 struct crypto_testsuite_params *ts_params = &testsuite_params;
8881 struct crypto_unittest_params *ut_params = &unittest_params;
8882 struct rte_crypto_sym_op *sym_op;
8884 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8886 /* Generate Crypto op data structure */
8887 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8888 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8889 TEST_ASSERT_NOT_NULL(ut_params->op,
8890 "Failed to allocate symmetric crypto operation struct");
8892 sym_op = ut_params->op->sym;
8894 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8895 ut_params->ibuf, tdata->gmac_tag.len);
8896 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8897 "no room to append digest");
8899 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8900 ut_params->ibuf, plaintext_pad_len);
8902 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
8903 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
8904 tdata->gmac_tag.len);
8905 debug_hexdump(stdout, "digest:",
8906 sym_op->auth.digest.data,
8907 tdata->gmac_tag.len);
8910 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8911 uint8_t *, IV_OFFSET);
8913 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8915 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
8917 sym_op->cipher.data.length = 0;
8918 sym_op->cipher.data.offset = 0;
8920 sym_op->auth.data.offset = 0;
8921 sym_op->auth.data.length = tdata->plaintext.len;
8926 static int create_gmac_session(uint8_t dev_id,
8927 const struct gmac_test_data *tdata,
8928 enum rte_crypto_auth_operation auth_op)
8930 uint8_t auth_key[tdata->key.len];
8932 struct crypto_testsuite_params *ts_params = &testsuite_params;
8933 struct crypto_unittest_params *ut_params = &unittest_params;
8935 memcpy(auth_key, tdata->key.data, tdata->key.len);
8937 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8938 ut_params->auth_xform.next = NULL;
8940 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
8941 ut_params->auth_xform.auth.op = auth_op;
8942 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
8943 ut_params->auth_xform.auth.key.length = tdata->key.len;
8944 ut_params->auth_xform.auth.key.data = auth_key;
8945 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
8946 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
8949 ut_params->sess = rte_cryptodev_sym_session_create(
8950 ts_params->session_mpool);
8952 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8953 &ut_params->auth_xform,
8954 ts_params->session_priv_mpool);
8956 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8962 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
8964 struct crypto_testsuite_params *ts_params = &testsuite_params;
8965 struct crypto_unittest_params *ut_params = &unittest_params;
8969 uint8_t *auth_tag, *plaintext;
8970 uint16_t plaintext_pad_len;
8972 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
8973 "No GMAC length in the source data");
8975 retval = create_gmac_session(ts_params->valid_devs[0],
8976 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
8981 if (tdata->plaintext.len > MBUF_SIZE)
8982 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8984 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8985 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
8986 "Failed to allocate input buffer in mempool");
8988 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8989 rte_pktmbuf_tailroom(ut_params->ibuf));
8991 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8993 * Runtime generate the large plain text instead of use hard code
8994 * plain text vector. It is done to avoid create huge source file
8995 * with the test vector.
8997 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
8998 generate_gmac_large_plaintext(tdata->plaintext.data);
9000 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9002 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9004 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
9005 debug_hexdump(stdout, "plaintext:", plaintext,
9006 tdata->plaintext.len);
9008 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
9014 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9016 ut_params->op->sym->m_src = ut_params->ibuf;
9018 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9019 ut_params->op), "failed to process sym crypto op");
9021 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9022 "crypto op processing failed");
9024 if (ut_params->op->sym->m_dst) {
9025 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
9026 uint8_t *, plaintext_pad_len);
9028 auth_tag = plaintext + plaintext_pad_len;
9031 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
9033 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9035 tdata->gmac_tag.data,
9036 tdata->gmac_tag.len,
9037 "GMAC Generated auth tag not as expected");
9043 test_AES_GMAC_authentication_test_case_1(void)
9045 return test_AES_GMAC_authentication(&gmac_test_case_1);
9049 test_AES_GMAC_authentication_test_case_2(void)
9051 return test_AES_GMAC_authentication(&gmac_test_case_2);
9055 test_AES_GMAC_authentication_test_case_3(void)
9057 return test_AES_GMAC_authentication(&gmac_test_case_3);
9061 test_AES_GMAC_authentication_test_case_4(void)
9063 return test_AES_GMAC_authentication(&gmac_test_case_4);
9067 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
9069 struct crypto_testsuite_params *ts_params = &testsuite_params;
9070 struct crypto_unittest_params *ut_params = &unittest_params;
9072 uint32_t plaintext_pad_len;
9075 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
9076 "No GMAC length in the source data");
9078 retval = create_gmac_session(ts_params->valid_devs[0],
9079 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
9084 if (tdata->plaintext.len > MBUF_SIZE)
9085 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9087 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9088 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9089 "Failed to allocate input buffer in mempool");
9091 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9092 rte_pktmbuf_tailroom(ut_params->ibuf));
9094 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9097 * Runtime generate the large plain text instead of use hard code
9098 * plain text vector. It is done to avoid create huge source file
9099 * with the test vector.
9101 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
9102 generate_gmac_large_plaintext(tdata->plaintext.data);
9104 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9106 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9108 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
9109 debug_hexdump(stdout, "plaintext:", plaintext,
9110 tdata->plaintext.len);
9112 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
9118 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9120 ut_params->op->sym->m_src = ut_params->ibuf;
9122 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9123 ut_params->op), "failed to process sym crypto op");
9125 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9126 "crypto op processing failed");
9133 test_AES_GMAC_authentication_verify_test_case_1(void)
9135 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
9139 test_AES_GMAC_authentication_verify_test_case_2(void)
9141 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
9145 test_AES_GMAC_authentication_verify_test_case_3(void)
9147 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
9151 test_AES_GMAC_authentication_verify_test_case_4(void)
9153 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
9156 struct test_crypto_vector {
9157 enum rte_crypto_cipher_algorithm crypto_algo;
9170 const uint8_t *data;
9175 const uint8_t *data;
9179 enum rte_crypto_auth_algorithm auth_algo;
9187 const uint8_t *data;
9197 static const struct test_crypto_vector
9198 hmac_sha1_test_crypto_vector = {
9199 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
9201 .data = plaintext_hash,
9206 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
9207 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
9208 0xDE, 0xF4, 0xDE, 0xAD
9214 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
9215 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
9216 0x3F, 0x91, 0x64, 0x59
9222 static const struct test_crypto_vector
9223 aes128_gmac_test_vector = {
9224 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
9226 .data = plaintext_hash,
9231 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
9232 0x08, 0x09, 0x0A, 0x0B
9238 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
9239 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
9245 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
9246 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
9252 static const struct test_crypto_vector
9253 aes128cbc_hmac_sha1_test_vector = {
9254 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
9257 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
9258 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
9264 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
9265 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
9270 .data = plaintext_hash,
9274 .data = ciphertext512_aes128cbc,
9277 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
9280 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
9281 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
9282 0xDE, 0xF4, 0xDE, 0xAD
9288 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
9289 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
9290 0x18, 0x8C, 0x1D, 0x32
9297 data_corruption(uint8_t *data)
9303 tag_corruption(uint8_t *data, unsigned int tag_offset)
9305 data[tag_offset] += 1;
9309 create_auth_session(struct crypto_unittest_params *ut_params,
9311 const struct test_crypto_vector *reference,
9312 enum rte_crypto_auth_operation auth_op)
9314 struct crypto_testsuite_params *ts_params = &testsuite_params;
9315 uint8_t auth_key[reference->auth_key.len + 1];
9317 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
9319 /* Setup Authentication Parameters */
9320 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9321 ut_params->auth_xform.auth.op = auth_op;
9322 ut_params->auth_xform.next = NULL;
9323 ut_params->auth_xform.auth.algo = reference->auth_algo;
9324 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
9325 ut_params->auth_xform.auth.key.data = auth_key;
9326 ut_params->auth_xform.auth.digest_length = reference->digest.len;
9328 /* Create Crypto session*/
9329 ut_params->sess = rte_cryptodev_sym_session_create(
9330 ts_params->session_mpool);
9332 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
9333 &ut_params->auth_xform,
9334 ts_params->session_priv_mpool);
9336 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9342 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
9344 const struct test_crypto_vector *reference,
9345 enum rte_crypto_auth_operation auth_op,
9346 enum rte_crypto_cipher_operation cipher_op)
9348 struct crypto_testsuite_params *ts_params = &testsuite_params;
9349 uint8_t cipher_key[reference->cipher_key.len + 1];
9350 uint8_t auth_key[reference->auth_key.len + 1];
9352 memcpy(cipher_key, reference->cipher_key.data,
9353 reference->cipher_key.len);
9354 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
9356 /* Setup Authentication Parameters */
9357 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9358 ut_params->auth_xform.auth.op = auth_op;
9359 ut_params->auth_xform.auth.algo = reference->auth_algo;
9360 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
9361 ut_params->auth_xform.auth.key.data = auth_key;
9362 ut_params->auth_xform.auth.digest_length = reference->digest.len;
9364 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
9365 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
9366 ut_params->auth_xform.auth.iv.length = reference->iv.len;
9368 ut_params->auth_xform.next = &ut_params->cipher_xform;
9370 /* Setup Cipher Parameters */
9371 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9372 ut_params->cipher_xform.next = NULL;
9373 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
9374 ut_params->cipher_xform.cipher.op = cipher_op;
9375 ut_params->cipher_xform.cipher.key.data = cipher_key;
9376 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
9377 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9378 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
9381 /* Create Crypto session*/
9382 ut_params->sess = rte_cryptodev_sym_session_create(
9383 ts_params->session_mpool);
9385 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
9386 &ut_params->auth_xform,
9387 ts_params->session_priv_mpool);
9389 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9395 create_auth_operation(struct crypto_testsuite_params *ts_params,
9396 struct crypto_unittest_params *ut_params,
9397 const struct test_crypto_vector *reference,
9398 unsigned int auth_generate)
9400 /* Generate Crypto op data structure */
9401 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9402 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9403 TEST_ASSERT_NOT_NULL(ut_params->op,
9404 "Failed to allocate pktmbuf offload");
9406 /* Set crypto operation data parameters */
9407 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9409 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9411 /* set crypto operation source mbuf */
9412 sym_op->m_src = ut_params->ibuf;
9415 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9416 ut_params->ibuf, reference->digest.len);
9418 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9419 "no room to append auth tag");
9421 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9422 ut_params->ibuf, reference->plaintext.len);
9425 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9427 memcpy(sym_op->auth.digest.data,
9428 reference->digest.data,
9429 reference->digest.len);
9431 debug_hexdump(stdout, "digest:",
9432 sym_op->auth.digest.data,
9433 reference->digest.len);
9435 sym_op->auth.data.length = reference->plaintext.len;
9436 sym_op->auth.data.offset = 0;
9442 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
9443 struct crypto_unittest_params *ut_params,
9444 const struct test_crypto_vector *reference,
9445 unsigned int auth_generate)
9447 /* Generate Crypto op data structure */
9448 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9449 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9450 TEST_ASSERT_NOT_NULL(ut_params->op,
9451 "Failed to allocate pktmbuf offload");
9453 /* Set crypto operation data parameters */
9454 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9456 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9458 /* set crypto operation source mbuf */
9459 sym_op->m_src = ut_params->ibuf;
9462 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9463 ut_params->ibuf, reference->digest.len);
9465 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9466 "no room to append auth tag");
9468 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9469 ut_params->ibuf, reference->ciphertext.len);
9472 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9474 memcpy(sym_op->auth.digest.data,
9475 reference->digest.data,
9476 reference->digest.len);
9478 debug_hexdump(stdout, "digest:",
9479 sym_op->auth.digest.data,
9480 reference->digest.len);
9482 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
9483 reference->iv.data, reference->iv.len);
9485 sym_op->cipher.data.length = 0;
9486 sym_op->cipher.data.offset = 0;
9488 sym_op->auth.data.length = reference->plaintext.len;
9489 sym_op->auth.data.offset = 0;
9495 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
9496 struct crypto_unittest_params *ut_params,
9497 const struct test_crypto_vector *reference,
9498 unsigned int auth_generate)
9500 /* Generate Crypto op data structure */
9501 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9502 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9503 TEST_ASSERT_NOT_NULL(ut_params->op,
9504 "Failed to allocate pktmbuf offload");
9506 /* Set crypto operation data parameters */
9507 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9509 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9511 /* set crypto operation source mbuf */
9512 sym_op->m_src = ut_params->ibuf;
9515 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9516 ut_params->ibuf, reference->digest.len);
9518 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9519 "no room to append auth tag");
9521 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9522 ut_params->ibuf, reference->ciphertext.len);
9525 memset(sym_op->auth.digest.data, 0, reference->digest.len);
9527 memcpy(sym_op->auth.digest.data,
9528 reference->digest.data,
9529 reference->digest.len);
9531 debug_hexdump(stdout, "digest:",
9532 sym_op->auth.digest.data,
9533 reference->digest.len);
9535 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
9536 reference->iv.data, reference->iv.len);
9538 sym_op->cipher.data.length = reference->ciphertext.len;
9539 sym_op->cipher.data.offset = 0;
9541 sym_op->auth.data.length = reference->ciphertext.len;
9542 sym_op->auth.data.offset = 0;
9548 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
9549 struct crypto_unittest_params *ut_params,
9550 const struct test_crypto_vector *reference)
9552 return create_auth_operation(ts_params, ut_params, reference, 0);
9556 create_auth_verify_GMAC_operation(
9557 struct crypto_testsuite_params *ts_params,
9558 struct crypto_unittest_params *ut_params,
9559 const struct test_crypto_vector *reference)
9561 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
9565 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
9566 struct crypto_unittest_params *ut_params,
9567 const struct test_crypto_vector *reference)
9569 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
9573 test_authentication_verify_fail_when_data_corruption(
9574 struct crypto_testsuite_params *ts_params,
9575 struct crypto_unittest_params *ut_params,
9576 const struct test_crypto_vector *reference,
9577 unsigned int data_corrupted)
9583 /* Create session */
9584 retval = create_auth_session(ut_params,
9585 ts_params->valid_devs[0],
9587 RTE_CRYPTO_AUTH_OP_VERIFY);
9591 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9592 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9593 "Failed to allocate input buffer in mempool");
9595 /* clear mbuf payload */
9596 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9597 rte_pktmbuf_tailroom(ut_params->ibuf));
9599 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9600 reference->plaintext.len);
9601 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9602 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
9604 debug_hexdump(stdout, "plaintext:", plaintext,
9605 reference->plaintext.len);
9607 /* Create operation */
9608 retval = create_auth_verify_operation(ts_params, ut_params, reference);
9614 data_corruption(plaintext);
9616 tag_corruption(plaintext, reference->plaintext.len);
9618 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9620 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9621 TEST_ASSERT_EQUAL(ut_params->op->status,
9622 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9623 "authentication not failed");
9625 ut_params->obuf = ut_params->op->sym->m_src;
9626 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9632 test_authentication_verify_GMAC_fail_when_corruption(
9633 struct crypto_testsuite_params *ts_params,
9634 struct crypto_unittest_params *ut_params,
9635 const struct test_crypto_vector *reference,
9636 unsigned int data_corrupted)
9641 /* Create session */
9642 retval = create_auth_cipher_session(ut_params,
9643 ts_params->valid_devs[0],
9645 RTE_CRYPTO_AUTH_OP_VERIFY,
9646 RTE_CRYPTO_CIPHER_OP_DECRYPT);
9650 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9651 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9652 "Failed to allocate input buffer in mempool");
9654 /* clear mbuf payload */
9655 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9656 rte_pktmbuf_tailroom(ut_params->ibuf));
9658 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9659 reference->plaintext.len);
9660 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9661 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
9663 debug_hexdump(stdout, "plaintext:", plaintext,
9664 reference->plaintext.len);
9666 /* Create operation */
9667 retval = create_auth_verify_GMAC_operation(ts_params,
9675 data_corruption(plaintext);
9677 tag_corruption(plaintext, reference->aad.len);
9679 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9681 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9682 TEST_ASSERT_EQUAL(ut_params->op->status,
9683 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9684 "authentication not failed");
9686 ut_params->obuf = ut_params->op->sym->m_src;
9687 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9693 test_authenticated_decryption_fail_when_corruption(
9694 struct crypto_testsuite_params *ts_params,
9695 struct crypto_unittest_params *ut_params,
9696 const struct test_crypto_vector *reference,
9697 unsigned int data_corrupted)
9701 uint8_t *ciphertext;
9703 /* Create session */
9704 retval = create_auth_cipher_session(ut_params,
9705 ts_params->valid_devs[0],
9707 RTE_CRYPTO_AUTH_OP_VERIFY,
9708 RTE_CRYPTO_CIPHER_OP_DECRYPT);
9712 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9713 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9714 "Failed to allocate input buffer in mempool");
9716 /* clear mbuf payload */
9717 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9718 rte_pktmbuf_tailroom(ut_params->ibuf));
9720 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9721 reference->ciphertext.len);
9722 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
9723 memcpy(ciphertext, reference->ciphertext.data,
9724 reference->ciphertext.len);
9726 /* Create operation */
9727 retval = create_cipher_auth_verify_operation(ts_params,
9735 data_corruption(ciphertext);
9737 tag_corruption(ciphertext, reference->ciphertext.len);
9739 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9742 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9743 TEST_ASSERT_EQUAL(ut_params->op->status,
9744 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
9745 "authentication not failed");
9747 ut_params->obuf = ut_params->op->sym->m_src;
9748 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
9754 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
9755 const struct aead_test_data *tdata,
9756 void *digest_mem, uint64_t digest_phys)
9758 struct crypto_testsuite_params *ts_params = &testsuite_params;
9759 struct crypto_unittest_params *ut_params = &unittest_params;
9761 const unsigned int auth_tag_len = tdata->auth_tag.len;
9762 const unsigned int iv_len = tdata->iv.len;
9763 unsigned int aad_len = tdata->aad.len;
9765 /* Generate Crypto op data structure */
9766 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9767 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9768 TEST_ASSERT_NOT_NULL(ut_params->op,
9769 "Failed to allocate symmetric crypto operation struct");
9771 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9773 sym_op->aead.digest.data = digest_mem;
9775 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
9776 "no room to append digest");
9778 sym_op->aead.digest.phys_addr = digest_phys;
9780 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
9781 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
9783 debug_hexdump(stdout, "digest:",
9784 sym_op->aead.digest.data,
9788 /* Append aad data */
9789 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
9790 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
9791 uint8_t *, IV_OFFSET);
9793 /* Copy IV 1 byte after the IV pointer, according to the API */
9794 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
9796 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
9798 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
9799 ut_params->ibuf, aad_len);
9800 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
9801 "no room to prepend aad");
9802 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
9805 memset(sym_op->aead.aad.data, 0, aad_len);
9806 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
9807 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
9809 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
9810 debug_hexdump(stdout, "aad:",
9811 sym_op->aead.aad.data, aad_len);
9813 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
9814 uint8_t *, IV_OFFSET);
9816 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
9818 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
9819 ut_params->ibuf, aad_len);
9820 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
9821 "no room to prepend aad");
9822 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
9825 memset(sym_op->aead.aad.data, 0, aad_len);
9826 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
9828 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
9829 debug_hexdump(stdout, "aad:",
9830 sym_op->aead.aad.data, aad_len);
9833 sym_op->aead.data.length = tdata->plaintext.len;
9834 sym_op->aead.data.offset = aad_len;
9839 #define SGL_MAX_NO 16
9842 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
9843 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
9845 struct crypto_testsuite_params *ts_params = &testsuite_params;
9846 struct crypto_unittest_params *ut_params = &unittest_params;
9847 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
9850 int to_trn_tbl[SGL_MAX_NO];
9852 unsigned int trn_data = 0;
9853 uint8_t *plaintext, *ciphertext, *auth_tag;
9855 if (fragsz > tdata->plaintext.len)
9856 fragsz = tdata->plaintext.len;
9858 uint16_t plaintext_len = fragsz;
9859 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
9861 if (fragsz_oop > tdata->plaintext.len)
9862 frag_size_oop = tdata->plaintext.len;
9865 void *digest_mem = NULL;
9867 uint32_t prepend_len = tdata->aad.len;
9869 if (tdata->plaintext.len % fragsz != 0) {
9870 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
9873 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
9878 * For out-op-place we need to alloc another mbuf
9881 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9882 rte_pktmbuf_append(ut_params->obuf,
9883 frag_size_oop + prepend_len);
9884 buf_oop = ut_params->obuf;
9887 /* Create AEAD session */
9888 retval = create_aead_session(ts_params->valid_devs[0],
9890 RTE_CRYPTO_AEAD_OP_ENCRYPT,
9891 tdata->key.data, tdata->key.len,
9892 tdata->aad.len, tdata->auth_tag.len,
9897 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9899 /* clear mbuf payload */
9900 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9901 rte_pktmbuf_tailroom(ut_params->ibuf));
9903 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9906 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
9908 trn_data += plaintext_len;
9910 buf = ut_params->ibuf;
9913 * Loop until no more fragments
9916 while (trn_data < tdata->plaintext.len) {
9918 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
9919 (tdata->plaintext.len - trn_data) : fragsz;
9921 to_trn_tbl[ecx++] = to_trn;
9923 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9926 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
9927 rte_pktmbuf_tailroom(buf));
9930 if (oop && !fragsz_oop) {
9931 buf_last_oop = buf_oop->next =
9932 rte_pktmbuf_alloc(ts_params->mbuf_pool);
9933 buf_oop = buf_oop->next;
9934 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
9935 0, rte_pktmbuf_tailroom(buf_oop));
9936 rte_pktmbuf_append(buf_oop, to_trn);
9939 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
9942 memcpy(plaintext, tdata->plaintext.data + trn_data,
9945 if (trn_data == tdata->plaintext.len) {
9948 digest_mem = rte_pktmbuf_append(buf_oop,
9949 tdata->auth_tag.len);
9951 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
9952 tdata->auth_tag.len);
9956 uint64_t digest_phys = 0;
9958 ut_params->ibuf->nb_segs = segs;
9961 if (fragsz_oop && oop) {
9965 if (frag_size_oop == tdata->plaintext.len) {
9966 digest_mem = rte_pktmbuf_append(ut_params->obuf,
9967 tdata->auth_tag.len);
9969 digest_phys = rte_pktmbuf_iova_offset(
9971 tdata->plaintext.len + prepend_len);
9974 trn_data = frag_size_oop;
9975 while (trn_data < tdata->plaintext.len) {
9978 (tdata->plaintext.len - trn_data <
9980 (tdata->plaintext.len - trn_data) :
9983 to_trn_tbl[ecx++] = to_trn;
9985 buf_last_oop = buf_oop->next =
9986 rte_pktmbuf_alloc(ts_params->mbuf_pool);
9987 buf_oop = buf_oop->next;
9988 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
9989 0, rte_pktmbuf_tailroom(buf_oop));
9990 rte_pktmbuf_append(buf_oop, to_trn);
9994 if (trn_data == tdata->plaintext.len) {
9995 digest_mem = rte_pktmbuf_append(buf_oop,
9996 tdata->auth_tag.len);
10000 ut_params->obuf->nb_segs = segs;
10004 * Place digest at the end of the last buffer
10007 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
10008 if (oop && buf_last_oop)
10009 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
10011 if (!digest_mem && !oop) {
10012 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10013 + tdata->auth_tag.len);
10014 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
10015 tdata->plaintext.len);
10018 /* Create AEAD operation */
10019 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
10020 tdata, digest_mem, digest_phys);
10025 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10027 ut_params->op->sym->m_src = ut_params->ibuf;
10029 ut_params->op->sym->m_dst = ut_params->obuf;
10031 /* Process crypto operation */
10032 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10033 ut_params->op), "failed to process sym crypto op");
10035 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10036 "crypto op processing failed");
10039 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10040 uint8_t *, prepend_len);
10042 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10043 uint8_t *, prepend_len);
10047 fragsz = fragsz_oop;
10049 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10051 tdata->ciphertext.data,
10053 "Ciphertext data not as expected");
10055 buf = ut_params->op->sym->m_src->next;
10057 buf = ut_params->op->sym->m_dst->next;
10059 unsigned int off = fragsz;
10063 ciphertext = rte_pktmbuf_mtod(buf,
10066 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10068 tdata->ciphertext.data + off,
10070 "Ciphertext data not as expected");
10072 off += to_trn_tbl[ecx++];
10076 auth_tag = digest_mem;
10077 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10079 tdata->auth_tag.data,
10080 tdata->auth_tag.len,
10081 "Generated auth tag not as expected");
10087 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
10089 return test_authenticated_encryption_SGL(
10090 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
10094 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
10096 return test_authenticated_encryption_SGL(
10097 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
10101 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
10103 return test_authenticated_encryption_SGL(
10104 &gcm_test_case_8, OUT_OF_PLACE, 400,
10105 gcm_test_case_8.plaintext.len);
10109 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
10112 return test_authenticated_encryption_SGL(
10113 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
10117 test_authentication_verify_fail_when_data_corrupted(
10118 struct crypto_testsuite_params *ts_params,
10119 struct crypto_unittest_params *ut_params,
10120 const struct test_crypto_vector *reference)
10122 return test_authentication_verify_fail_when_data_corruption(
10123 ts_params, ut_params, reference, 1);
10127 test_authentication_verify_fail_when_tag_corrupted(
10128 struct crypto_testsuite_params *ts_params,
10129 struct crypto_unittest_params *ut_params,
10130 const struct test_crypto_vector *reference)
10132 return test_authentication_verify_fail_when_data_corruption(
10133 ts_params, ut_params, reference, 0);
10137 test_authentication_verify_GMAC_fail_when_data_corrupted(
10138 struct crypto_testsuite_params *ts_params,
10139 struct crypto_unittest_params *ut_params,
10140 const struct test_crypto_vector *reference)
10142 return test_authentication_verify_GMAC_fail_when_corruption(
10143 ts_params, ut_params, reference, 1);
10147 test_authentication_verify_GMAC_fail_when_tag_corrupted(
10148 struct crypto_testsuite_params *ts_params,
10149 struct crypto_unittest_params *ut_params,
10150 const struct test_crypto_vector *reference)
10152 return test_authentication_verify_GMAC_fail_when_corruption(
10153 ts_params, ut_params, reference, 0);
10157 test_authenticated_decryption_fail_when_data_corrupted(
10158 struct crypto_testsuite_params *ts_params,
10159 struct crypto_unittest_params *ut_params,
10160 const struct test_crypto_vector *reference)
10162 return test_authenticated_decryption_fail_when_corruption(
10163 ts_params, ut_params, reference, 1);
10167 test_authenticated_decryption_fail_when_tag_corrupted(
10168 struct crypto_testsuite_params *ts_params,
10169 struct crypto_unittest_params *ut_params,
10170 const struct test_crypto_vector *reference)
10172 return test_authenticated_decryption_fail_when_corruption(
10173 ts_params, ut_params, reference, 0);
10177 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
10179 return test_authentication_verify_fail_when_data_corrupted(
10180 &testsuite_params, &unittest_params,
10181 &hmac_sha1_test_crypto_vector);
10185 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
10187 return test_authentication_verify_fail_when_tag_corrupted(
10188 &testsuite_params, &unittest_params,
10189 &hmac_sha1_test_crypto_vector);
10193 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
10195 return test_authentication_verify_GMAC_fail_when_data_corrupted(
10196 &testsuite_params, &unittest_params,
10197 &aes128_gmac_test_vector);
10201 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
10203 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
10204 &testsuite_params, &unittest_params,
10205 &aes128_gmac_test_vector);
10209 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
10211 return test_authenticated_decryption_fail_when_data_corrupted(
10214 &aes128cbc_hmac_sha1_test_vector);
10218 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
10220 return test_authenticated_decryption_fail_when_tag_corrupted(
10223 &aes128cbc_hmac_sha1_test_vector);
10226 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
10228 /* global AESNI slave IDs for the scheduler test */
10229 uint8_t aesni_ids[2];
10232 test_scheduler_attach_slave_op(void)
10234 struct crypto_testsuite_params *ts_params = &testsuite_params;
10235 uint8_t sched_id = ts_params->valid_devs[0];
10236 uint32_t nb_devs, i, nb_devs_attached = 0;
10238 char vdev_name[32];
10240 /* create 2 AESNI_MB if necessary */
10241 nb_devs = rte_cryptodev_device_count_by_driver(
10242 rte_cryptodev_driver_id_get(
10243 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
10245 for (i = nb_devs; i < 2; i++) {
10246 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
10247 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
10249 ret = rte_vdev_init(vdev_name, NULL);
10251 TEST_ASSERT(ret == 0,
10252 "Failed to create instance %u of"
10254 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
10258 /* attach 2 AESNI_MB cdevs */
10259 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
10261 struct rte_cryptodev_info info;
10262 unsigned int session_size;
10264 rte_cryptodev_info_get(i, &info);
10265 if (info.driver_id != rte_cryptodev_driver_id_get(
10266 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
10269 session_size = rte_cryptodev_sym_get_private_session_size(i);
10271 * Create the session mempool again, since now there are new devices
10272 * to use the mempool.
10274 if (ts_params->session_mpool) {
10275 rte_mempool_free(ts_params->session_mpool);
10276 ts_params->session_mpool = NULL;
10278 if (ts_params->session_priv_mpool) {
10279 rte_mempool_free(ts_params->session_priv_mpool);
10280 ts_params->session_priv_mpool = NULL;
10283 if (info.sym.max_nb_sessions != 0 &&
10284 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
10285 RTE_LOG(ERR, USER1,
10286 "Device does not support "
10287 "at least %u sessions\n",
10289 return TEST_FAILED;
10292 * Create mempool with maximum number of sessions,
10293 * to include the session headers
10295 if (ts_params->session_mpool == NULL) {
10296 ts_params->session_mpool =
10297 rte_cryptodev_sym_session_pool_create(
10299 MAX_NB_SESSIONS, 0, 0, 0,
10301 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
10302 "session mempool allocation failed");
10306 * Create mempool with maximum number of sessions,
10307 * to include device specific session private data
10309 if (ts_params->session_priv_mpool == NULL) {
10310 ts_params->session_priv_mpool = rte_mempool_create(
10311 "test_sess_mp_priv",
10314 0, 0, NULL, NULL, NULL,
10315 NULL, SOCKET_ID_ANY,
10318 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
10319 "session mempool allocation failed");
10322 ts_params->qp_conf.mp_session = ts_params->session_mpool;
10323 ts_params->qp_conf.mp_session_private =
10324 ts_params->session_priv_mpool;
10326 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
10329 TEST_ASSERT(ret == 0,
10330 "Failed to attach device %u of pmd : %s", i,
10331 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
10333 aesni_ids[nb_devs_attached] = (uint8_t)i;
10335 nb_devs_attached++;
10342 test_scheduler_detach_slave_op(void)
10344 struct crypto_testsuite_params *ts_params = &testsuite_params;
10345 uint8_t sched_id = ts_params->valid_devs[0];
10349 for (i = 0; i < 2; i++) {
10350 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
10352 TEST_ASSERT(ret == 0,
10353 "Failed to detach device %u", aesni_ids[i]);
10360 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
10362 struct crypto_testsuite_params *ts_params = &testsuite_params;
10363 uint8_t sched_id = ts_params->valid_devs[0];
10365 return rte_cryptodev_scheduler_mode_set(sched_id,
10370 test_scheduler_mode_roundrobin_op(void)
10372 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
10373 0, "Failed to set roundrobin mode");
10379 test_scheduler_mode_multicore_op(void)
10381 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
10382 0, "Failed to set multicore mode");
10388 test_scheduler_mode_failover_op(void)
10390 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
10391 0, "Failed to set failover mode");
10397 test_scheduler_mode_pkt_size_distr_op(void)
10399 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
10400 0, "Failed to set pktsize mode");
10405 static struct unit_test_suite cryptodev_scheduler_testsuite = {
10406 .suite_name = "Crypto Device Scheduler Unit Test Suite",
10407 .setup = testsuite_setup,
10408 .teardown = testsuite_teardown,
10409 .unit_test_cases = {
10411 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10412 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
10413 TEST_CASE_ST(ut_setup, ut_teardown,
10414 test_AES_chain_scheduler_all),
10415 TEST_CASE_ST(ut_setup, ut_teardown,
10416 test_AES_cipheronly_scheduler_all),
10417 TEST_CASE_ST(ut_setup, ut_teardown,
10418 test_authonly_scheduler_all),
10419 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10422 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10423 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
10424 TEST_CASE_ST(ut_setup, ut_teardown,
10425 test_AES_chain_scheduler_all),
10426 TEST_CASE_ST(ut_setup, ut_teardown,
10427 test_AES_cipheronly_scheduler_all),
10428 TEST_CASE_ST(ut_setup, ut_teardown,
10429 test_authonly_scheduler_all),
10430 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10433 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10434 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
10435 TEST_CASE_ST(ut_setup, ut_teardown,
10436 test_AES_chain_scheduler_all),
10437 TEST_CASE_ST(ut_setup, ut_teardown,
10438 test_AES_cipheronly_scheduler_all),
10439 TEST_CASE_ST(ut_setup, ut_teardown,
10440 test_authonly_scheduler_all),
10441 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10444 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
10445 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
10446 TEST_CASE_ST(ut_setup, ut_teardown,
10447 test_AES_chain_scheduler_all),
10448 TEST_CASE_ST(ut_setup, ut_teardown,
10449 test_AES_cipheronly_scheduler_all),
10450 TEST_CASE_ST(ut_setup, ut_teardown,
10451 test_authonly_scheduler_all),
10452 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
10454 TEST_CASES_END() /**< NULL terminate unit test array */
10458 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
10460 static struct unit_test_suite cryptodev_qat_testsuite = {
10461 .suite_name = "Crypto QAT Unit Test Suite",
10462 .setup = testsuite_setup,
10463 .teardown = testsuite_teardown,
10464 .unit_test_cases = {
10465 TEST_CASE_ST(ut_setup, ut_teardown,
10466 test_device_configure_invalid_dev_id),
10467 TEST_CASE_ST(ut_setup, ut_teardown,
10468 test_device_configure_invalid_queue_pair_ids),
10469 TEST_CASE_ST(ut_setup, ut_teardown,
10470 test_queue_pair_descriptor_setup),
10471 TEST_CASE_ST(ut_setup, ut_teardown,
10472 test_multi_session),
10474 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
10475 TEST_CASE_ST(ut_setup, ut_teardown,
10476 test_AES_cipheronly_qat_all),
10477 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
10478 TEST_CASE_ST(ut_setup, ut_teardown,
10479 test_3DES_cipheronly_qat_all),
10480 TEST_CASE_ST(ut_setup, ut_teardown,
10481 test_DES_cipheronly_qat_all),
10482 TEST_CASE_ST(ut_setup, ut_teardown,
10483 test_AES_docsis_qat_all),
10484 TEST_CASE_ST(ut_setup, ut_teardown,
10485 test_DES_docsis_qat_all),
10486 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
10487 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
10489 /** AES CCM Authenticated Encryption 128 bits key */
10490 TEST_CASE_ST(ut_setup, ut_teardown,
10491 test_AES_CCM_authenticated_encryption_test_case_128_1),
10492 TEST_CASE_ST(ut_setup, ut_teardown,
10493 test_AES_CCM_authenticated_encryption_test_case_128_2),
10494 TEST_CASE_ST(ut_setup, ut_teardown,
10495 test_AES_CCM_authenticated_encryption_test_case_128_3),
10497 /** AES CCM Authenticated Decryption 128 bits key*/
10498 TEST_CASE_ST(ut_setup, ut_teardown,
10499 test_AES_CCM_authenticated_decryption_test_case_128_1),
10500 TEST_CASE_ST(ut_setup, ut_teardown,
10501 test_AES_CCM_authenticated_decryption_test_case_128_2),
10502 TEST_CASE_ST(ut_setup, ut_teardown,
10503 test_AES_CCM_authenticated_decryption_test_case_128_3),
10505 /** AES GCM Authenticated Encryption */
10506 TEST_CASE_ST(ut_setup, ut_teardown,
10507 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
10508 TEST_CASE_ST(ut_setup, ut_teardown,
10509 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
10510 TEST_CASE_ST(ut_setup, ut_teardown,
10511 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
10512 TEST_CASE_ST(ut_setup, ut_teardown,
10513 test_AES_GCM_authenticated_encryption_test_case_1),
10514 TEST_CASE_ST(ut_setup, ut_teardown,
10515 test_AES_GCM_authenticated_encryption_test_case_2),
10516 TEST_CASE_ST(ut_setup, ut_teardown,
10517 test_AES_GCM_authenticated_encryption_test_case_3),
10518 TEST_CASE_ST(ut_setup, ut_teardown,
10519 test_AES_GCM_authenticated_encryption_test_case_4),
10520 TEST_CASE_ST(ut_setup, ut_teardown,
10521 test_AES_GCM_authenticated_encryption_test_case_5),
10522 TEST_CASE_ST(ut_setup, ut_teardown,
10523 test_AES_GCM_authenticated_encryption_test_case_6),
10524 TEST_CASE_ST(ut_setup, ut_teardown,
10525 test_AES_GCM_authenticated_encryption_test_case_7),
10527 /** AES GCM Authenticated Decryption */
10528 TEST_CASE_ST(ut_setup, ut_teardown,
10529 test_AES_GCM_authenticated_decryption_test_case_1),
10530 TEST_CASE_ST(ut_setup, ut_teardown,
10531 test_AES_GCM_authenticated_decryption_test_case_2),
10532 TEST_CASE_ST(ut_setup, ut_teardown,
10533 test_AES_GCM_authenticated_decryption_test_case_3),
10534 TEST_CASE_ST(ut_setup, ut_teardown,
10535 test_AES_GCM_authenticated_decryption_test_case_4),
10536 TEST_CASE_ST(ut_setup, ut_teardown,
10537 test_AES_GCM_authenticated_decryption_test_case_5),
10538 TEST_CASE_ST(ut_setup, ut_teardown,
10539 test_AES_GCM_authenticated_decryption_test_case_6),
10540 TEST_CASE_ST(ut_setup, ut_teardown,
10541 test_AES_GCM_authenticated_decryption_test_case_7),
10543 /** AES GCM Authenticated Encryption 192 bits key */
10544 TEST_CASE_ST(ut_setup, ut_teardown,
10545 test_AES_GCM_auth_encryption_test_case_192_1),
10546 TEST_CASE_ST(ut_setup, ut_teardown,
10547 test_AES_GCM_auth_encryption_test_case_192_2),
10548 TEST_CASE_ST(ut_setup, ut_teardown,
10549 test_AES_GCM_auth_encryption_test_case_192_3),
10550 TEST_CASE_ST(ut_setup, ut_teardown,
10551 test_AES_GCM_auth_encryption_test_case_192_4),
10552 TEST_CASE_ST(ut_setup, ut_teardown,
10553 test_AES_GCM_auth_encryption_test_case_192_5),
10554 TEST_CASE_ST(ut_setup, ut_teardown,
10555 test_AES_GCM_auth_encryption_test_case_192_6),
10556 TEST_CASE_ST(ut_setup, ut_teardown,
10557 test_AES_GCM_auth_encryption_test_case_192_7),
10559 /** AES GCM Authenticated Decryption 192 bits key */
10560 TEST_CASE_ST(ut_setup, ut_teardown,
10561 test_AES_GCM_auth_decryption_test_case_192_1),
10562 TEST_CASE_ST(ut_setup, ut_teardown,
10563 test_AES_GCM_auth_decryption_test_case_192_2),
10564 TEST_CASE_ST(ut_setup, ut_teardown,
10565 test_AES_GCM_auth_decryption_test_case_192_3),
10566 TEST_CASE_ST(ut_setup, ut_teardown,
10567 test_AES_GCM_auth_decryption_test_case_192_4),
10568 TEST_CASE_ST(ut_setup, ut_teardown,
10569 test_AES_GCM_auth_decryption_test_case_192_5),
10570 TEST_CASE_ST(ut_setup, ut_teardown,
10571 test_AES_GCM_auth_decryption_test_case_192_6),
10572 TEST_CASE_ST(ut_setup, ut_teardown,
10573 test_AES_GCM_auth_decryption_test_case_192_7),
10575 /** AES GCM Authenticated Encryption 256 bits key */
10576 TEST_CASE_ST(ut_setup, ut_teardown,
10577 test_AES_GCM_auth_encryption_test_case_256_1),
10578 TEST_CASE_ST(ut_setup, ut_teardown,
10579 test_AES_GCM_auth_encryption_test_case_256_2),
10580 TEST_CASE_ST(ut_setup, ut_teardown,
10581 test_AES_GCM_auth_encryption_test_case_256_3),
10582 TEST_CASE_ST(ut_setup, ut_teardown,
10583 test_AES_GCM_auth_encryption_test_case_256_4),
10584 TEST_CASE_ST(ut_setup, ut_teardown,
10585 test_AES_GCM_auth_encryption_test_case_256_5),
10586 TEST_CASE_ST(ut_setup, ut_teardown,
10587 test_AES_GCM_auth_encryption_test_case_256_6),
10588 TEST_CASE_ST(ut_setup, ut_teardown,
10589 test_AES_GCM_auth_encryption_test_case_256_7),
10591 /** AES GMAC Authentication */
10592 TEST_CASE_ST(ut_setup, ut_teardown,
10593 test_AES_GMAC_authentication_test_case_1),
10594 TEST_CASE_ST(ut_setup, ut_teardown,
10595 test_AES_GMAC_authentication_verify_test_case_1),
10596 TEST_CASE_ST(ut_setup, ut_teardown,
10597 test_AES_GMAC_authentication_test_case_2),
10598 TEST_CASE_ST(ut_setup, ut_teardown,
10599 test_AES_GMAC_authentication_verify_test_case_2),
10600 TEST_CASE_ST(ut_setup, ut_teardown,
10601 test_AES_GMAC_authentication_test_case_3),
10602 TEST_CASE_ST(ut_setup, ut_teardown,
10603 test_AES_GMAC_authentication_verify_test_case_3),
10605 /** SNOW 3G encrypt only (UEA2) */
10606 TEST_CASE_ST(ut_setup, ut_teardown,
10607 test_snow3g_encryption_test_case_1),
10608 TEST_CASE_ST(ut_setup, ut_teardown,
10609 test_snow3g_encryption_test_case_2),
10610 TEST_CASE_ST(ut_setup, ut_teardown,
10611 test_snow3g_encryption_test_case_3),
10612 TEST_CASE_ST(ut_setup, ut_teardown,
10613 test_snow3g_encryption_test_case_4),
10614 TEST_CASE_ST(ut_setup, ut_teardown,
10615 test_snow3g_encryption_test_case_5),
10617 TEST_CASE_ST(ut_setup, ut_teardown,
10618 test_snow3g_encryption_test_case_1_oop),
10619 TEST_CASE_ST(ut_setup, ut_teardown,
10620 test_snow3g_decryption_test_case_1_oop),
10622 /** SNOW 3G generate auth, then encrypt (UEA2) */
10623 TEST_CASE_ST(ut_setup, ut_teardown,
10624 test_snow3g_auth_cipher_test_case_1),
10625 TEST_CASE_ST(ut_setup, ut_teardown,
10626 test_snow3g_auth_cipher_test_case_2),
10627 TEST_CASE_ST(ut_setup, ut_teardown,
10628 test_snow3g_auth_cipher_test_case_2_oop),
10629 TEST_CASE_ST(ut_setup, ut_teardown,
10630 test_snow3g_auth_cipher_part_digest_enc),
10631 TEST_CASE_ST(ut_setup, ut_teardown,
10632 test_snow3g_auth_cipher_part_digest_enc_oop),
10633 TEST_CASE_ST(ut_setup, ut_teardown,
10634 test_snow3g_auth_cipher_test_case_3_sgl),
10635 TEST_CASE_ST(ut_setup, ut_teardown,
10636 test_snow3g_auth_cipher_test_case_3_oop_sgl),
10637 TEST_CASE_ST(ut_setup, ut_teardown,
10638 test_snow3g_auth_cipher_part_digest_enc_sgl),
10639 TEST_CASE_ST(ut_setup, ut_teardown,
10640 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
10642 /** SNOW 3G decrypt (UEA2), then verify auth */
10643 TEST_CASE_ST(ut_setup, ut_teardown,
10644 test_snow3g_auth_cipher_verify_test_case_1),
10645 TEST_CASE_ST(ut_setup, ut_teardown,
10646 test_snow3g_auth_cipher_verify_test_case_2),
10647 TEST_CASE_ST(ut_setup, ut_teardown,
10648 test_snow3g_auth_cipher_verify_test_case_2_oop),
10649 TEST_CASE_ST(ut_setup, ut_teardown,
10650 test_snow3g_auth_cipher_verify_part_digest_enc),
10651 TEST_CASE_ST(ut_setup, ut_teardown,
10652 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
10653 TEST_CASE_ST(ut_setup, ut_teardown,
10654 test_snow3g_auth_cipher_verify_test_case_3_sgl),
10655 TEST_CASE_ST(ut_setup, ut_teardown,
10656 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
10657 TEST_CASE_ST(ut_setup, ut_teardown,
10658 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
10659 TEST_CASE_ST(ut_setup, ut_teardown,
10660 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
10662 /** SNOW 3G decrypt only (UEA2) */
10663 TEST_CASE_ST(ut_setup, ut_teardown,
10664 test_snow3g_decryption_test_case_1),
10665 TEST_CASE_ST(ut_setup, ut_teardown,
10666 test_snow3g_decryption_test_case_2),
10667 TEST_CASE_ST(ut_setup, ut_teardown,
10668 test_snow3g_decryption_test_case_3),
10669 TEST_CASE_ST(ut_setup, ut_teardown,
10670 test_snow3g_decryption_test_case_4),
10671 TEST_CASE_ST(ut_setup, ut_teardown,
10672 test_snow3g_decryption_test_case_5),
10673 TEST_CASE_ST(ut_setup, ut_teardown,
10674 test_snow3g_decryption_with_digest_test_case_1),
10675 TEST_CASE_ST(ut_setup, ut_teardown,
10676 test_snow3g_hash_generate_test_case_1),
10677 TEST_CASE_ST(ut_setup, ut_teardown,
10678 test_snow3g_hash_generate_test_case_2),
10679 TEST_CASE_ST(ut_setup, ut_teardown,
10680 test_snow3g_hash_generate_test_case_3),
10681 TEST_CASE_ST(ut_setup, ut_teardown,
10682 test_snow3g_hash_verify_test_case_1),
10683 TEST_CASE_ST(ut_setup, ut_teardown,
10684 test_snow3g_hash_verify_test_case_2),
10685 TEST_CASE_ST(ut_setup, ut_teardown,
10686 test_snow3g_hash_verify_test_case_3),
10687 TEST_CASE_ST(ut_setup, ut_teardown,
10688 test_snow3g_cipher_auth_test_case_1),
10689 TEST_CASE_ST(ut_setup, ut_teardown,
10690 test_snow3g_auth_cipher_with_digest_test_case_1),
10692 /** ZUC encrypt only (EEA3) */
10693 TEST_CASE_ST(ut_setup, ut_teardown,
10694 test_zuc_encryption_test_case_1),
10695 TEST_CASE_ST(ut_setup, ut_teardown,
10696 test_zuc_encryption_test_case_2),
10697 TEST_CASE_ST(ut_setup, ut_teardown,
10698 test_zuc_encryption_test_case_3),
10699 TEST_CASE_ST(ut_setup, ut_teardown,
10700 test_zuc_encryption_test_case_4),
10701 TEST_CASE_ST(ut_setup, ut_teardown,
10702 test_zuc_encryption_test_case_5),
10704 /** ZUC authenticate (EIA3) */
10705 TEST_CASE_ST(ut_setup, ut_teardown,
10706 test_zuc_hash_generate_test_case_6),
10707 TEST_CASE_ST(ut_setup, ut_teardown,
10708 test_zuc_hash_generate_test_case_7),
10709 TEST_CASE_ST(ut_setup, ut_teardown,
10710 test_zuc_hash_generate_test_case_8),
10712 /** ZUC alg-chain (EEA3/EIA3) */
10713 TEST_CASE_ST(ut_setup, ut_teardown,
10714 test_zuc_cipher_auth_test_case_1),
10715 TEST_CASE_ST(ut_setup, ut_teardown,
10716 test_zuc_cipher_auth_test_case_2),
10718 /** ZUC generate auth, then encrypt (EEA3) */
10719 TEST_CASE_ST(ut_setup, ut_teardown,
10720 test_zuc_auth_cipher_test_case_1),
10721 TEST_CASE_ST(ut_setup, ut_teardown,
10722 test_zuc_auth_cipher_test_case_1_oop),
10723 TEST_CASE_ST(ut_setup, ut_teardown,
10724 test_zuc_auth_cipher_test_case_1_sgl),
10725 TEST_CASE_ST(ut_setup, ut_teardown,
10726 test_zuc_auth_cipher_test_case_1_oop_sgl),
10728 /** ZUC decrypt (EEA3), then verify auth */
10729 TEST_CASE_ST(ut_setup, ut_teardown,
10730 test_zuc_auth_cipher_verify_test_case_1),
10731 TEST_CASE_ST(ut_setup, ut_teardown,
10732 test_zuc_auth_cipher_verify_test_case_1_oop),
10733 TEST_CASE_ST(ut_setup, ut_teardown,
10734 test_zuc_auth_cipher_verify_test_case_1_sgl),
10735 TEST_CASE_ST(ut_setup, ut_teardown,
10736 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
10738 /** HMAC_MD5 Authentication */
10739 TEST_CASE_ST(ut_setup, ut_teardown,
10740 test_MD5_HMAC_generate_case_1),
10741 TEST_CASE_ST(ut_setup, ut_teardown,
10742 test_MD5_HMAC_verify_case_1),
10743 TEST_CASE_ST(ut_setup, ut_teardown,
10744 test_MD5_HMAC_generate_case_2),
10745 TEST_CASE_ST(ut_setup, ut_teardown,
10746 test_MD5_HMAC_verify_case_2),
10748 /** NULL algo tests done in chain_all,
10749 * cipheronly and authonly suites
10752 /** KASUMI tests */
10753 TEST_CASE_ST(ut_setup, ut_teardown,
10754 test_kasumi_hash_generate_test_case_1),
10755 TEST_CASE_ST(ut_setup, ut_teardown,
10756 test_kasumi_hash_generate_test_case_2),
10757 TEST_CASE_ST(ut_setup, ut_teardown,
10758 test_kasumi_hash_generate_test_case_3),
10759 TEST_CASE_ST(ut_setup, ut_teardown,
10760 test_kasumi_hash_generate_test_case_4),
10761 TEST_CASE_ST(ut_setup, ut_teardown,
10762 test_kasumi_hash_generate_test_case_5),
10763 TEST_CASE_ST(ut_setup, ut_teardown,
10764 test_kasumi_hash_generate_test_case_6),
10766 TEST_CASE_ST(ut_setup, ut_teardown,
10767 test_kasumi_hash_verify_test_case_1),
10768 TEST_CASE_ST(ut_setup, ut_teardown,
10769 test_kasumi_hash_verify_test_case_2),
10770 TEST_CASE_ST(ut_setup, ut_teardown,
10771 test_kasumi_hash_verify_test_case_3),
10772 TEST_CASE_ST(ut_setup, ut_teardown,
10773 test_kasumi_hash_verify_test_case_4),
10774 TEST_CASE_ST(ut_setup, ut_teardown,
10775 test_kasumi_hash_verify_test_case_5),
10777 TEST_CASE_ST(ut_setup, ut_teardown,
10778 test_kasumi_encryption_test_case_1),
10779 TEST_CASE_ST(ut_setup, ut_teardown,
10780 test_kasumi_encryption_test_case_3),
10781 TEST_CASE_ST(ut_setup, ut_teardown,
10782 test_kasumi_cipher_auth_test_case_1),
10784 /** KASUMI generate auth, then encrypt (F8) */
10785 TEST_CASE_ST(ut_setup, ut_teardown,
10786 test_kasumi_auth_cipher_test_case_1),
10787 TEST_CASE_ST(ut_setup, ut_teardown,
10788 test_kasumi_auth_cipher_test_case_2),
10789 TEST_CASE_ST(ut_setup, ut_teardown,
10790 test_kasumi_auth_cipher_test_case_2_oop),
10791 TEST_CASE_ST(ut_setup, ut_teardown,
10792 test_kasumi_auth_cipher_test_case_2_sgl),
10793 TEST_CASE_ST(ut_setup, ut_teardown,
10794 test_kasumi_auth_cipher_test_case_2_oop_sgl),
10796 /** KASUMI decrypt (F8), then verify auth */
10797 TEST_CASE_ST(ut_setup, ut_teardown,
10798 test_kasumi_auth_cipher_verify_test_case_1),
10799 TEST_CASE_ST(ut_setup, ut_teardown,
10800 test_kasumi_auth_cipher_verify_test_case_2),
10801 TEST_CASE_ST(ut_setup, ut_teardown,
10802 test_kasumi_auth_cipher_verify_test_case_2_oop),
10803 TEST_CASE_ST(ut_setup, ut_teardown,
10804 test_kasumi_auth_cipher_verify_test_case_2_sgl),
10805 TEST_CASE_ST(ut_setup, ut_teardown,
10806 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
10808 /** Negative tests */
10809 TEST_CASE_ST(ut_setup, ut_teardown,
10810 authentication_verify_HMAC_SHA1_fail_data_corrupt),
10811 TEST_CASE_ST(ut_setup, ut_teardown,
10812 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
10813 TEST_CASE_ST(ut_setup, ut_teardown,
10814 authentication_verify_AES128_GMAC_fail_data_corrupt),
10815 TEST_CASE_ST(ut_setup, ut_teardown,
10816 authentication_verify_AES128_GMAC_fail_tag_corrupt),
10817 TEST_CASE_ST(ut_setup, ut_teardown,
10818 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10819 TEST_CASE_ST(ut_setup, ut_teardown,
10820 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10822 TEST_CASES_END() /**< NULL terminate unit test array */
10826 static struct unit_test_suite cryptodev_virtio_testsuite = {
10827 .suite_name = "Crypto VIRTIO Unit Test Suite",
10828 .setup = testsuite_setup,
10829 .teardown = testsuite_teardown,
10830 .unit_test_cases = {
10831 TEST_CASE_ST(ut_setup, ut_teardown,
10832 test_AES_cipheronly_virtio_all),
10834 TEST_CASES_END() /**< NULL terminate unit test array */
10838 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
10839 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
10840 .setup = testsuite_setup,
10841 .teardown = testsuite_teardown,
10842 .unit_test_cases = {
10843 #if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0)
10844 TEST_CASE_ST(ut_setup, ut_teardown,
10845 test_AES_GCM_authenticated_encryption_test_case_1),
10846 TEST_CASE_ST(ut_setup, ut_teardown,
10847 test_AES_GCM_authenticated_encryption_test_case_2),
10848 TEST_CASE_ST(ut_setup, ut_teardown,
10849 test_AES_GCM_authenticated_encryption_test_case_3),
10850 TEST_CASE_ST(ut_setup, ut_teardown,
10851 test_AES_GCM_authenticated_encryption_test_case_4),
10852 TEST_CASE_ST(ut_setup, ut_teardown,
10853 test_AES_GCM_authenticated_encryption_test_case_5),
10854 TEST_CASE_ST(ut_setup, ut_teardown,
10855 test_AES_GCM_authenticated_encryption_test_case_6),
10856 TEST_CASE_ST(ut_setup, ut_teardown,
10857 test_AES_GCM_authenticated_encryption_test_case_7),
10859 /** AES GCM Authenticated Decryption */
10860 TEST_CASE_ST(ut_setup, ut_teardown,
10861 test_AES_GCM_authenticated_decryption_test_case_1),
10862 TEST_CASE_ST(ut_setup, ut_teardown,
10863 test_AES_GCM_authenticated_decryption_test_case_2),
10864 TEST_CASE_ST(ut_setup, ut_teardown,
10865 test_AES_GCM_authenticated_decryption_test_case_3),
10866 TEST_CASE_ST(ut_setup, ut_teardown,
10867 test_AES_GCM_authenticated_decryption_test_case_4),
10868 TEST_CASE_ST(ut_setup, ut_teardown,
10869 test_AES_GCM_authenticated_decryption_test_case_5),
10870 TEST_CASE_ST(ut_setup, ut_teardown,
10871 test_AES_GCM_authenticated_decryption_test_case_6),
10872 TEST_CASE_ST(ut_setup, ut_teardown,
10873 test_AES_GCM_authenticated_decryption_test_case_7),
10875 /** AES GCM Authenticated Encryption 192 bits key */
10876 TEST_CASE_ST(ut_setup, ut_teardown,
10877 test_AES_GCM_auth_encryption_test_case_192_1),
10878 TEST_CASE_ST(ut_setup, ut_teardown,
10879 test_AES_GCM_auth_encryption_test_case_192_2),
10880 TEST_CASE_ST(ut_setup, ut_teardown,
10881 test_AES_GCM_auth_encryption_test_case_192_3),
10882 TEST_CASE_ST(ut_setup, ut_teardown,
10883 test_AES_GCM_auth_encryption_test_case_192_4),
10884 TEST_CASE_ST(ut_setup, ut_teardown,
10885 test_AES_GCM_auth_encryption_test_case_192_5),
10886 TEST_CASE_ST(ut_setup, ut_teardown,
10887 test_AES_GCM_auth_encryption_test_case_192_6),
10888 TEST_CASE_ST(ut_setup, ut_teardown,
10889 test_AES_GCM_auth_encryption_test_case_192_7),
10891 /** AES GCM Authenticated Decryption 192 bits key */
10892 TEST_CASE_ST(ut_setup, ut_teardown,
10893 test_AES_GCM_auth_decryption_test_case_192_1),
10894 TEST_CASE_ST(ut_setup, ut_teardown,
10895 test_AES_GCM_auth_decryption_test_case_192_2),
10896 TEST_CASE_ST(ut_setup, ut_teardown,
10897 test_AES_GCM_auth_decryption_test_case_192_3),
10898 TEST_CASE_ST(ut_setup, ut_teardown,
10899 test_AES_GCM_auth_decryption_test_case_192_4),
10900 TEST_CASE_ST(ut_setup, ut_teardown,
10901 test_AES_GCM_auth_decryption_test_case_192_5),
10902 TEST_CASE_ST(ut_setup, ut_teardown,
10903 test_AES_GCM_auth_decryption_test_case_192_6),
10904 TEST_CASE_ST(ut_setup, ut_teardown,
10905 test_AES_GCM_auth_decryption_test_case_192_7),
10907 /** AES GCM Authenticated Encryption 256 bits key */
10908 TEST_CASE_ST(ut_setup, ut_teardown,
10909 test_AES_GCM_auth_encryption_test_case_256_1),
10910 TEST_CASE_ST(ut_setup, ut_teardown,
10911 test_AES_GCM_auth_encryption_test_case_256_2),
10912 TEST_CASE_ST(ut_setup, ut_teardown,
10913 test_AES_GCM_auth_encryption_test_case_256_3),
10914 TEST_CASE_ST(ut_setup, ut_teardown,
10915 test_AES_GCM_auth_encryption_test_case_256_4),
10916 TEST_CASE_ST(ut_setup, ut_teardown,
10917 test_AES_GCM_auth_encryption_test_case_256_5),
10918 TEST_CASE_ST(ut_setup, ut_teardown,
10919 test_AES_GCM_auth_encryption_test_case_256_6),
10920 TEST_CASE_ST(ut_setup, ut_teardown,
10921 test_AES_GCM_auth_encryption_test_case_256_7),
10923 /** AES GCM Authenticated Decryption 256 bits key */
10924 TEST_CASE_ST(ut_setup, ut_teardown,
10925 test_AES_GCM_auth_decryption_test_case_256_1),
10926 TEST_CASE_ST(ut_setup, ut_teardown,
10927 test_AES_GCM_auth_decryption_test_case_256_2),
10928 TEST_CASE_ST(ut_setup, ut_teardown,
10929 test_AES_GCM_auth_decryption_test_case_256_3),
10930 TEST_CASE_ST(ut_setup, ut_teardown,
10931 test_AES_GCM_auth_decryption_test_case_256_4),
10932 TEST_CASE_ST(ut_setup, ut_teardown,
10933 test_AES_GCM_auth_decryption_test_case_256_5),
10934 TEST_CASE_ST(ut_setup, ut_teardown,
10935 test_AES_GCM_auth_decryption_test_case_256_6),
10936 TEST_CASE_ST(ut_setup, ut_teardown,
10937 test_AES_GCM_auth_decryption_test_case_256_7),
10939 /** AES GCM Authenticated Encryption big aad size */
10940 TEST_CASE_ST(ut_setup, ut_teardown,
10941 test_AES_GCM_auth_encryption_test_case_aad_1),
10942 TEST_CASE_ST(ut_setup, ut_teardown,
10943 test_AES_GCM_auth_encryption_test_case_aad_2),
10945 /** AES GCM Authenticated Decryption big aad size */
10946 TEST_CASE_ST(ut_setup, ut_teardown,
10947 test_AES_GCM_auth_decryption_test_case_aad_1),
10948 TEST_CASE_ST(ut_setup, ut_teardown,
10949 test_AES_GCM_auth_decryption_test_case_aad_2),
10951 /** Session-less tests */
10952 TEST_CASE_ST(ut_setup, ut_teardown,
10953 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
10954 TEST_CASE_ST(ut_setup, ut_teardown,
10955 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
10957 /** AES GMAC Authentication */
10958 TEST_CASE_ST(ut_setup, ut_teardown,
10959 test_AES_GMAC_authentication_test_case_1),
10960 TEST_CASE_ST(ut_setup, ut_teardown,
10961 test_AES_GMAC_authentication_verify_test_case_1),
10962 TEST_CASE_ST(ut_setup, ut_teardown,
10963 test_AES_GMAC_authentication_test_case_2),
10964 TEST_CASE_ST(ut_setup, ut_teardown,
10965 test_AES_GMAC_authentication_verify_test_case_2),
10966 TEST_CASE_ST(ut_setup, ut_teardown,
10967 test_AES_GMAC_authentication_test_case_3),
10968 TEST_CASE_ST(ut_setup, ut_teardown,
10969 test_AES_GMAC_authentication_verify_test_case_3),
10970 #endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */
10972 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
10973 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
10974 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
10975 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
10976 TEST_CASE_ST(ut_setup, ut_teardown,
10977 test_DES_cipheronly_mb_all),
10978 TEST_CASE_ST(ut_setup, ut_teardown,
10979 test_DES_docsis_mb_all),
10980 TEST_CASE_ST(ut_setup, ut_teardown,
10981 test_3DES_cipheronly_mb_all),
10982 TEST_CASE_ST(ut_setup, ut_teardown,
10983 test_AES_CCM_authenticated_encryption_test_case_128_1),
10984 TEST_CASE_ST(ut_setup, ut_teardown,
10985 test_AES_CCM_authenticated_decryption_test_case_128_1),
10986 TEST_CASE_ST(ut_setup, ut_teardown,
10987 test_AES_CCM_authenticated_encryption_test_case_128_2),
10988 TEST_CASE_ST(ut_setup, ut_teardown,
10989 test_AES_CCM_authenticated_decryption_test_case_128_2),
10990 TEST_CASE_ST(ut_setup, ut_teardown,
10991 test_AES_CCM_authenticated_encryption_test_case_128_3),
10992 TEST_CASE_ST(ut_setup, ut_teardown,
10993 test_AES_CCM_authenticated_decryption_test_case_128_3),
10995 TEST_CASES_END() /**< NULL terminate unit test array */
10999 static struct unit_test_suite cryptodev_openssl_testsuite = {
11000 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
11001 .setup = testsuite_setup,
11002 .teardown = testsuite_teardown,
11003 .unit_test_cases = {
11004 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11005 TEST_CASE_ST(ut_setup, ut_teardown,
11006 test_multi_session_random_usage),
11007 TEST_CASE_ST(ut_setup, ut_teardown,
11008 test_AES_chain_openssl_all),
11009 TEST_CASE_ST(ut_setup, ut_teardown,
11010 test_AES_cipheronly_openssl_all),
11011 TEST_CASE_ST(ut_setup, ut_teardown,
11012 test_3DES_chain_openssl_all),
11013 TEST_CASE_ST(ut_setup, ut_teardown,
11014 test_3DES_cipheronly_openssl_all),
11015 TEST_CASE_ST(ut_setup, ut_teardown,
11016 test_DES_cipheronly_openssl_all),
11017 TEST_CASE_ST(ut_setup, ut_teardown,
11018 test_DES_docsis_openssl_all),
11019 TEST_CASE_ST(ut_setup, ut_teardown,
11020 test_authonly_openssl_all),
11022 /** AES GCM Authenticated Encryption */
11023 TEST_CASE_ST(ut_setup, ut_teardown,
11024 test_AES_GCM_authenticated_encryption_test_case_1),
11025 TEST_CASE_ST(ut_setup, ut_teardown,
11026 test_AES_GCM_authenticated_encryption_test_case_2),
11027 TEST_CASE_ST(ut_setup, ut_teardown,
11028 test_AES_GCM_authenticated_encryption_test_case_3),
11029 TEST_CASE_ST(ut_setup, ut_teardown,
11030 test_AES_GCM_authenticated_encryption_test_case_4),
11031 TEST_CASE_ST(ut_setup, ut_teardown,
11032 test_AES_GCM_authenticated_encryption_test_case_5),
11033 TEST_CASE_ST(ut_setup, ut_teardown,
11034 test_AES_GCM_authenticated_encryption_test_case_6),
11035 TEST_CASE_ST(ut_setup, ut_teardown,
11036 test_AES_GCM_authenticated_encryption_test_case_7),
11038 /** AES GCM Authenticated Decryption */
11039 TEST_CASE_ST(ut_setup, ut_teardown,
11040 test_AES_GCM_authenticated_decryption_test_case_1),
11041 TEST_CASE_ST(ut_setup, ut_teardown,
11042 test_AES_GCM_authenticated_decryption_test_case_2),
11043 TEST_CASE_ST(ut_setup, ut_teardown,
11044 test_AES_GCM_authenticated_decryption_test_case_3),
11045 TEST_CASE_ST(ut_setup, ut_teardown,
11046 test_AES_GCM_authenticated_decryption_test_case_4),
11047 TEST_CASE_ST(ut_setup, ut_teardown,
11048 test_AES_GCM_authenticated_decryption_test_case_5),
11049 TEST_CASE_ST(ut_setup, ut_teardown,
11050 test_AES_GCM_authenticated_decryption_test_case_6),
11051 TEST_CASE_ST(ut_setup, ut_teardown,
11052 test_AES_GCM_authenticated_decryption_test_case_7),
11055 /** AES GCM Authenticated Encryption 192 bits key */
11056 TEST_CASE_ST(ut_setup, ut_teardown,
11057 test_AES_GCM_auth_encryption_test_case_192_1),
11058 TEST_CASE_ST(ut_setup, ut_teardown,
11059 test_AES_GCM_auth_encryption_test_case_192_2),
11060 TEST_CASE_ST(ut_setup, ut_teardown,
11061 test_AES_GCM_auth_encryption_test_case_192_3),
11062 TEST_CASE_ST(ut_setup, ut_teardown,
11063 test_AES_GCM_auth_encryption_test_case_192_4),
11064 TEST_CASE_ST(ut_setup, ut_teardown,
11065 test_AES_GCM_auth_encryption_test_case_192_5),
11066 TEST_CASE_ST(ut_setup, ut_teardown,
11067 test_AES_GCM_auth_encryption_test_case_192_6),
11068 TEST_CASE_ST(ut_setup, ut_teardown,
11069 test_AES_GCM_auth_encryption_test_case_192_7),
11071 /** AES GCM Authenticated Decryption 192 bits key */
11072 TEST_CASE_ST(ut_setup, ut_teardown,
11073 test_AES_GCM_auth_decryption_test_case_192_1),
11074 TEST_CASE_ST(ut_setup, ut_teardown,
11075 test_AES_GCM_auth_decryption_test_case_192_2),
11076 TEST_CASE_ST(ut_setup, ut_teardown,
11077 test_AES_GCM_auth_decryption_test_case_192_3),
11078 TEST_CASE_ST(ut_setup, ut_teardown,
11079 test_AES_GCM_auth_decryption_test_case_192_4),
11080 TEST_CASE_ST(ut_setup, ut_teardown,
11081 test_AES_GCM_auth_decryption_test_case_192_5),
11082 TEST_CASE_ST(ut_setup, ut_teardown,
11083 test_AES_GCM_auth_decryption_test_case_192_6),
11084 TEST_CASE_ST(ut_setup, ut_teardown,
11085 test_AES_GCM_auth_decryption_test_case_192_7),
11087 /** AES GCM Authenticated Encryption 256 bits key */
11088 TEST_CASE_ST(ut_setup, ut_teardown,
11089 test_AES_GCM_auth_encryption_test_case_256_1),
11090 TEST_CASE_ST(ut_setup, ut_teardown,
11091 test_AES_GCM_auth_encryption_test_case_256_2),
11092 TEST_CASE_ST(ut_setup, ut_teardown,
11093 test_AES_GCM_auth_encryption_test_case_256_3),
11094 TEST_CASE_ST(ut_setup, ut_teardown,
11095 test_AES_GCM_auth_encryption_test_case_256_4),
11096 TEST_CASE_ST(ut_setup, ut_teardown,
11097 test_AES_GCM_auth_encryption_test_case_256_5),
11098 TEST_CASE_ST(ut_setup, ut_teardown,
11099 test_AES_GCM_auth_encryption_test_case_256_6),
11100 TEST_CASE_ST(ut_setup, ut_teardown,
11101 test_AES_GCM_auth_encryption_test_case_256_7),
11103 /** AES GCM Authenticated Decryption 256 bits key */
11104 TEST_CASE_ST(ut_setup, ut_teardown,
11105 test_AES_GCM_auth_decryption_test_case_256_1),
11106 TEST_CASE_ST(ut_setup, ut_teardown,
11107 test_AES_GCM_auth_decryption_test_case_256_2),
11108 TEST_CASE_ST(ut_setup, ut_teardown,
11109 test_AES_GCM_auth_decryption_test_case_256_3),
11110 TEST_CASE_ST(ut_setup, ut_teardown,
11111 test_AES_GCM_auth_decryption_test_case_256_4),
11112 TEST_CASE_ST(ut_setup, ut_teardown,
11113 test_AES_GCM_auth_decryption_test_case_256_5),
11114 TEST_CASE_ST(ut_setup, ut_teardown,
11115 test_AES_GCM_auth_decryption_test_case_256_6),
11116 TEST_CASE_ST(ut_setup, ut_teardown,
11117 test_AES_GCM_auth_decryption_test_case_256_7),
11119 /** AES GMAC Authentication */
11120 TEST_CASE_ST(ut_setup, ut_teardown,
11121 test_AES_GMAC_authentication_test_case_1),
11122 TEST_CASE_ST(ut_setup, ut_teardown,
11123 test_AES_GMAC_authentication_verify_test_case_1),
11124 TEST_CASE_ST(ut_setup, ut_teardown,
11125 test_AES_GMAC_authentication_test_case_2),
11126 TEST_CASE_ST(ut_setup, ut_teardown,
11127 test_AES_GMAC_authentication_verify_test_case_2),
11128 TEST_CASE_ST(ut_setup, ut_teardown,
11129 test_AES_GMAC_authentication_test_case_3),
11130 TEST_CASE_ST(ut_setup, ut_teardown,
11131 test_AES_GMAC_authentication_verify_test_case_3),
11132 TEST_CASE_ST(ut_setup, ut_teardown,
11133 test_AES_GMAC_authentication_test_case_4),
11134 TEST_CASE_ST(ut_setup, ut_teardown,
11135 test_AES_GMAC_authentication_verify_test_case_4),
11137 /** AES CCM Authenticated Encryption 128 bits key */
11138 TEST_CASE_ST(ut_setup, ut_teardown,
11139 test_AES_CCM_authenticated_encryption_test_case_128_1),
11140 TEST_CASE_ST(ut_setup, ut_teardown,
11141 test_AES_CCM_authenticated_encryption_test_case_128_2),
11142 TEST_CASE_ST(ut_setup, ut_teardown,
11143 test_AES_CCM_authenticated_encryption_test_case_128_3),
11145 /** AES CCM Authenticated Decryption 128 bits key*/
11146 TEST_CASE_ST(ut_setup, ut_teardown,
11147 test_AES_CCM_authenticated_decryption_test_case_128_1),
11148 TEST_CASE_ST(ut_setup, ut_teardown,
11149 test_AES_CCM_authenticated_decryption_test_case_128_2),
11150 TEST_CASE_ST(ut_setup, ut_teardown,
11151 test_AES_CCM_authenticated_decryption_test_case_128_3),
11153 /** AES CCM Authenticated Encryption 192 bits key */
11154 TEST_CASE_ST(ut_setup, ut_teardown,
11155 test_AES_CCM_authenticated_encryption_test_case_192_1),
11156 TEST_CASE_ST(ut_setup, ut_teardown,
11157 test_AES_CCM_authenticated_encryption_test_case_192_2),
11158 TEST_CASE_ST(ut_setup, ut_teardown,
11159 test_AES_CCM_authenticated_encryption_test_case_192_3),
11161 /** AES CCM Authenticated Decryption 192 bits key*/
11162 TEST_CASE_ST(ut_setup, ut_teardown,
11163 test_AES_CCM_authenticated_decryption_test_case_192_1),
11164 TEST_CASE_ST(ut_setup, ut_teardown,
11165 test_AES_CCM_authenticated_decryption_test_case_192_2),
11166 TEST_CASE_ST(ut_setup, ut_teardown,
11167 test_AES_CCM_authenticated_decryption_test_case_192_3),
11169 /** AES CCM Authenticated Encryption 256 bits key */
11170 TEST_CASE_ST(ut_setup, ut_teardown,
11171 test_AES_CCM_authenticated_encryption_test_case_256_1),
11172 TEST_CASE_ST(ut_setup, ut_teardown,
11173 test_AES_CCM_authenticated_encryption_test_case_256_2),
11174 TEST_CASE_ST(ut_setup, ut_teardown,
11175 test_AES_CCM_authenticated_encryption_test_case_256_3),
11177 /** AES CCM Authenticated Decryption 256 bits key*/
11178 TEST_CASE_ST(ut_setup, ut_teardown,
11179 test_AES_CCM_authenticated_decryption_test_case_256_1),
11180 TEST_CASE_ST(ut_setup, ut_teardown,
11181 test_AES_CCM_authenticated_decryption_test_case_256_2),
11182 TEST_CASE_ST(ut_setup, ut_teardown,
11183 test_AES_CCM_authenticated_decryption_test_case_256_3),
11185 /** Scatter-Gather */
11186 TEST_CASE_ST(ut_setup, ut_teardown,
11187 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11189 /** Negative tests */
11190 TEST_CASE_ST(ut_setup, ut_teardown,
11191 authentication_verify_HMAC_SHA1_fail_data_corrupt),
11192 TEST_CASE_ST(ut_setup, ut_teardown,
11193 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
11194 TEST_CASE_ST(ut_setup, ut_teardown,
11195 authentication_verify_AES128_GMAC_fail_data_corrupt),
11196 TEST_CASE_ST(ut_setup, ut_teardown,
11197 authentication_verify_AES128_GMAC_fail_tag_corrupt),
11198 TEST_CASE_ST(ut_setup, ut_teardown,
11199 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11200 TEST_CASE_ST(ut_setup, ut_teardown,
11201 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11203 TEST_CASES_END() /**< NULL terminate unit test array */
11207 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
11208 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
11209 .setup = testsuite_setup,
11210 .teardown = testsuite_teardown,
11211 .unit_test_cases = {
11212 /** AES GCM Authenticated Encryption */
11213 TEST_CASE_ST(ut_setup, ut_teardown,
11214 test_AES_GCM_authenticated_encryption_test_case_1),
11215 TEST_CASE_ST(ut_setup, ut_teardown,
11216 test_AES_GCM_authenticated_encryption_test_case_2),
11217 TEST_CASE_ST(ut_setup, ut_teardown,
11218 test_AES_GCM_authenticated_encryption_test_case_3),
11219 TEST_CASE_ST(ut_setup, ut_teardown,
11220 test_AES_GCM_authenticated_encryption_test_case_4),
11221 TEST_CASE_ST(ut_setup, ut_teardown,
11222 test_AES_GCM_authenticated_encryption_test_case_5),
11223 TEST_CASE_ST(ut_setup, ut_teardown,
11224 test_AES_GCM_authenticated_encryption_test_case_6),
11225 TEST_CASE_ST(ut_setup, ut_teardown,
11226 test_AES_GCM_authenticated_encryption_test_case_7),
11228 /** AES GCM Authenticated Decryption */
11229 TEST_CASE_ST(ut_setup, ut_teardown,
11230 test_AES_GCM_authenticated_decryption_test_case_1),
11231 TEST_CASE_ST(ut_setup, ut_teardown,
11232 test_AES_GCM_authenticated_decryption_test_case_2),
11233 TEST_CASE_ST(ut_setup, ut_teardown,
11234 test_AES_GCM_authenticated_decryption_test_case_3),
11235 TEST_CASE_ST(ut_setup, ut_teardown,
11236 test_AES_GCM_authenticated_decryption_test_case_4),
11237 TEST_CASE_ST(ut_setup, ut_teardown,
11238 test_AES_GCM_authenticated_decryption_test_case_5),
11239 TEST_CASE_ST(ut_setup, ut_teardown,
11240 test_AES_GCM_authenticated_decryption_test_case_6),
11241 TEST_CASE_ST(ut_setup, ut_teardown,
11242 test_AES_GCM_authenticated_decryption_test_case_7),
11244 /** AES GCM Authenticated Encryption 192 bits key */
11245 TEST_CASE_ST(ut_setup, ut_teardown,
11246 test_AES_GCM_auth_encryption_test_case_192_1),
11247 TEST_CASE_ST(ut_setup, ut_teardown,
11248 test_AES_GCM_auth_encryption_test_case_192_2),
11249 TEST_CASE_ST(ut_setup, ut_teardown,
11250 test_AES_GCM_auth_encryption_test_case_192_3),
11251 TEST_CASE_ST(ut_setup, ut_teardown,
11252 test_AES_GCM_auth_encryption_test_case_192_4),
11253 TEST_CASE_ST(ut_setup, ut_teardown,
11254 test_AES_GCM_auth_encryption_test_case_192_5),
11255 TEST_CASE_ST(ut_setup, ut_teardown,
11256 test_AES_GCM_auth_encryption_test_case_192_6),
11257 TEST_CASE_ST(ut_setup, ut_teardown,
11258 test_AES_GCM_auth_encryption_test_case_192_7),
11260 /** AES GCM Authenticated Decryption 192 bits key */
11261 TEST_CASE_ST(ut_setup, ut_teardown,
11262 test_AES_GCM_auth_decryption_test_case_192_1),
11263 TEST_CASE_ST(ut_setup, ut_teardown,
11264 test_AES_GCM_auth_decryption_test_case_192_2),
11265 TEST_CASE_ST(ut_setup, ut_teardown,
11266 test_AES_GCM_auth_decryption_test_case_192_3),
11267 TEST_CASE_ST(ut_setup, ut_teardown,
11268 test_AES_GCM_auth_decryption_test_case_192_4),
11269 TEST_CASE_ST(ut_setup, ut_teardown,
11270 test_AES_GCM_auth_decryption_test_case_192_5),
11271 TEST_CASE_ST(ut_setup, ut_teardown,
11272 test_AES_GCM_auth_decryption_test_case_192_6),
11273 TEST_CASE_ST(ut_setup, ut_teardown,
11274 test_AES_GCM_auth_decryption_test_case_192_7),
11276 /** AES GCM Authenticated Encryption 256 bits key */
11277 TEST_CASE_ST(ut_setup, ut_teardown,
11278 test_AES_GCM_auth_encryption_test_case_256_1),
11279 TEST_CASE_ST(ut_setup, ut_teardown,
11280 test_AES_GCM_auth_encryption_test_case_256_2),
11281 TEST_CASE_ST(ut_setup, ut_teardown,
11282 test_AES_GCM_auth_encryption_test_case_256_3),
11283 TEST_CASE_ST(ut_setup, ut_teardown,
11284 test_AES_GCM_auth_encryption_test_case_256_4),
11285 TEST_CASE_ST(ut_setup, ut_teardown,
11286 test_AES_GCM_auth_encryption_test_case_256_5),
11287 TEST_CASE_ST(ut_setup, ut_teardown,
11288 test_AES_GCM_auth_encryption_test_case_256_6),
11289 TEST_CASE_ST(ut_setup, ut_teardown,
11290 test_AES_GCM_auth_encryption_test_case_256_7),
11292 /** AES GCM Authenticated Decryption 256 bits key */
11293 TEST_CASE_ST(ut_setup, ut_teardown,
11294 test_AES_GCM_auth_decryption_test_case_256_1),
11295 TEST_CASE_ST(ut_setup, ut_teardown,
11296 test_AES_GCM_auth_decryption_test_case_256_2),
11297 TEST_CASE_ST(ut_setup, ut_teardown,
11298 test_AES_GCM_auth_decryption_test_case_256_3),
11299 TEST_CASE_ST(ut_setup, ut_teardown,
11300 test_AES_GCM_auth_decryption_test_case_256_4),
11301 TEST_CASE_ST(ut_setup, ut_teardown,
11302 test_AES_GCM_auth_decryption_test_case_256_5),
11303 TEST_CASE_ST(ut_setup, ut_teardown,
11304 test_AES_GCM_auth_decryption_test_case_256_6),
11305 TEST_CASE_ST(ut_setup, ut_teardown,
11306 test_AES_GCM_auth_decryption_test_case_256_7),
11308 /** AES GCM Authenticated Encryption big aad size */
11309 TEST_CASE_ST(ut_setup, ut_teardown,
11310 test_AES_GCM_auth_encryption_test_case_aad_1),
11311 TEST_CASE_ST(ut_setup, ut_teardown,
11312 test_AES_GCM_auth_encryption_test_case_aad_2),
11314 /** AES GCM Authenticated Decryption big aad size */
11315 TEST_CASE_ST(ut_setup, ut_teardown,
11316 test_AES_GCM_auth_decryption_test_case_aad_1),
11317 TEST_CASE_ST(ut_setup, ut_teardown,
11318 test_AES_GCM_auth_decryption_test_case_aad_2),
11320 /** AES GMAC Authentication */
11321 TEST_CASE_ST(ut_setup, ut_teardown,
11322 test_AES_GMAC_authentication_test_case_1),
11323 TEST_CASE_ST(ut_setup, ut_teardown,
11324 test_AES_GMAC_authentication_verify_test_case_1),
11325 TEST_CASE_ST(ut_setup, ut_teardown,
11326 test_AES_GMAC_authentication_test_case_3),
11327 TEST_CASE_ST(ut_setup, ut_teardown,
11328 test_AES_GMAC_authentication_verify_test_case_3),
11329 TEST_CASE_ST(ut_setup, ut_teardown,
11330 test_AES_GMAC_authentication_test_case_4),
11331 TEST_CASE_ST(ut_setup, ut_teardown,
11332 test_AES_GMAC_authentication_verify_test_case_4),
11334 /** Negative tests */
11335 TEST_CASE_ST(ut_setup, ut_teardown,
11336 authentication_verify_AES128_GMAC_fail_data_corrupt),
11337 TEST_CASE_ST(ut_setup, ut_teardown,
11338 authentication_verify_AES128_GMAC_fail_tag_corrupt),
11340 /** Out of place tests */
11341 TEST_CASE_ST(ut_setup, ut_teardown,
11342 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11343 TEST_CASE_ST(ut_setup, ut_teardown,
11344 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11346 /** Session-less tests */
11347 TEST_CASE_ST(ut_setup, ut_teardown,
11348 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
11349 TEST_CASE_ST(ut_setup, ut_teardown,
11350 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
11352 /** Scatter-Gather */
11353 TEST_CASE_ST(ut_setup, ut_teardown,
11354 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11356 TEST_CASES_END() /**< NULL terminate unit test array */
11360 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
11361 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
11362 .setup = testsuite_setup,
11363 .teardown = testsuite_teardown,
11364 .unit_test_cases = {
11365 /** KASUMI encrypt only (UEA1) */
11366 TEST_CASE_ST(ut_setup, ut_teardown,
11367 test_kasumi_encryption_test_case_1),
11368 TEST_CASE_ST(ut_setup, ut_teardown,
11369 test_kasumi_encryption_test_case_1_sgl),
11370 TEST_CASE_ST(ut_setup, ut_teardown,
11371 test_kasumi_encryption_test_case_2),
11372 TEST_CASE_ST(ut_setup, ut_teardown,
11373 test_kasumi_encryption_test_case_3),
11374 TEST_CASE_ST(ut_setup, ut_teardown,
11375 test_kasumi_encryption_test_case_4),
11376 TEST_CASE_ST(ut_setup, ut_teardown,
11377 test_kasumi_encryption_test_case_5),
11378 /** KASUMI decrypt only (UEA1) */
11379 TEST_CASE_ST(ut_setup, ut_teardown,
11380 test_kasumi_decryption_test_case_1),
11381 TEST_CASE_ST(ut_setup, ut_teardown,
11382 test_kasumi_decryption_test_case_2),
11383 TEST_CASE_ST(ut_setup, ut_teardown,
11384 test_kasumi_decryption_test_case_3),
11385 TEST_CASE_ST(ut_setup, ut_teardown,
11386 test_kasumi_decryption_test_case_4),
11387 TEST_CASE_ST(ut_setup, ut_teardown,
11388 test_kasumi_decryption_test_case_5),
11390 TEST_CASE_ST(ut_setup, ut_teardown,
11391 test_kasumi_encryption_test_case_1_oop),
11392 TEST_CASE_ST(ut_setup, ut_teardown,
11393 test_kasumi_encryption_test_case_1_oop_sgl),
11396 TEST_CASE_ST(ut_setup, ut_teardown,
11397 test_kasumi_decryption_test_case_1_oop),
11399 /** KASUMI hash only (UIA1) */
11400 TEST_CASE_ST(ut_setup, ut_teardown,
11401 test_kasumi_hash_generate_test_case_1),
11402 TEST_CASE_ST(ut_setup, ut_teardown,
11403 test_kasumi_hash_generate_test_case_2),
11404 TEST_CASE_ST(ut_setup, ut_teardown,
11405 test_kasumi_hash_generate_test_case_3),
11406 TEST_CASE_ST(ut_setup, ut_teardown,
11407 test_kasumi_hash_generate_test_case_4),
11408 TEST_CASE_ST(ut_setup, ut_teardown,
11409 test_kasumi_hash_generate_test_case_5),
11410 TEST_CASE_ST(ut_setup, ut_teardown,
11411 test_kasumi_hash_generate_test_case_6),
11412 TEST_CASE_ST(ut_setup, ut_teardown,
11413 test_kasumi_hash_verify_test_case_1),
11414 TEST_CASE_ST(ut_setup, ut_teardown,
11415 test_kasumi_hash_verify_test_case_2),
11416 TEST_CASE_ST(ut_setup, ut_teardown,
11417 test_kasumi_hash_verify_test_case_3),
11418 TEST_CASE_ST(ut_setup, ut_teardown,
11419 test_kasumi_hash_verify_test_case_4),
11420 TEST_CASE_ST(ut_setup, ut_teardown,
11421 test_kasumi_hash_verify_test_case_5),
11422 TEST_CASE_ST(ut_setup, ut_teardown,
11423 test_kasumi_cipher_auth_test_case_1),
11425 /** KASUMI generate auth, then encrypt (F8) */
11426 TEST_CASE_ST(ut_setup, ut_teardown,
11427 test_kasumi_auth_cipher_test_case_1),
11428 TEST_CASE_ST(ut_setup, ut_teardown,
11429 test_kasumi_auth_cipher_test_case_2),
11430 TEST_CASE_ST(ut_setup, ut_teardown,
11431 test_kasumi_auth_cipher_test_case_2_oop),
11432 TEST_CASE_ST(ut_setup, ut_teardown,
11433 test_kasumi_auth_cipher_test_case_2_sgl),
11434 TEST_CASE_ST(ut_setup, ut_teardown,
11435 test_kasumi_auth_cipher_test_case_2_oop_sgl),
11437 /** KASUMI decrypt (F8), then verify auth */
11438 TEST_CASE_ST(ut_setup, ut_teardown,
11439 test_kasumi_auth_cipher_verify_test_case_1),
11440 TEST_CASE_ST(ut_setup, ut_teardown,
11441 test_kasumi_auth_cipher_verify_test_case_2),
11442 TEST_CASE_ST(ut_setup, ut_teardown,
11443 test_kasumi_auth_cipher_verify_test_case_2_oop),
11444 TEST_CASE_ST(ut_setup, ut_teardown,
11445 test_kasumi_auth_cipher_verify_test_case_2_sgl),
11446 TEST_CASE_ST(ut_setup, ut_teardown,
11447 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
11448 TEST_CASES_END() /**< NULL terminate unit test array */
11451 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
11452 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
11453 .setup = testsuite_setup,
11454 .teardown = testsuite_teardown,
11455 .unit_test_cases = {
11456 /** SNOW 3G encrypt only (UEA2) */
11457 TEST_CASE_ST(ut_setup, ut_teardown,
11458 test_snow3g_encryption_test_case_1),
11459 TEST_CASE_ST(ut_setup, ut_teardown,
11460 test_snow3g_encryption_test_case_2),
11461 TEST_CASE_ST(ut_setup, ut_teardown,
11462 test_snow3g_encryption_test_case_3),
11463 TEST_CASE_ST(ut_setup, ut_teardown,
11464 test_snow3g_encryption_test_case_4),
11465 TEST_CASE_ST(ut_setup, ut_teardown,
11466 test_snow3g_encryption_test_case_5),
11467 TEST_CASE_ST(ut_setup, ut_teardown,
11468 test_snow3g_auth_cipher_with_digest_test_case_1),
11470 TEST_CASE_ST(ut_setup, ut_teardown,
11471 test_snow3g_encryption_test_case_1_oop),
11472 TEST_CASE_ST(ut_setup, ut_teardown,
11473 test_snow3g_encryption_test_case_1_oop_sgl),
11474 TEST_CASE_ST(ut_setup, ut_teardown,
11475 test_snow3g_decryption_test_case_1_oop),
11477 TEST_CASE_ST(ut_setup, ut_teardown,
11478 test_snow3g_encryption_test_case_1_offset_oop),
11480 /** SNOW 3G decrypt only (UEA2) */
11481 TEST_CASE_ST(ut_setup, ut_teardown,
11482 test_snow3g_decryption_test_case_1),
11483 TEST_CASE_ST(ut_setup, ut_teardown,
11484 test_snow3g_decryption_test_case_2),
11485 TEST_CASE_ST(ut_setup, ut_teardown,
11486 test_snow3g_decryption_test_case_3),
11487 TEST_CASE_ST(ut_setup, ut_teardown,
11488 test_snow3g_decryption_test_case_4),
11489 TEST_CASE_ST(ut_setup, ut_teardown,
11490 test_snow3g_decryption_test_case_5),
11491 TEST_CASE_ST(ut_setup, ut_teardown,
11492 test_snow3g_decryption_with_digest_test_case_1),
11493 TEST_CASE_ST(ut_setup, ut_teardown,
11494 test_snow3g_hash_generate_test_case_1),
11495 TEST_CASE_ST(ut_setup, ut_teardown,
11496 test_snow3g_hash_generate_test_case_2),
11497 TEST_CASE_ST(ut_setup, ut_teardown,
11498 test_snow3g_hash_generate_test_case_3),
11499 /* Tests with buffers which length is not byte-aligned */
11500 TEST_CASE_ST(ut_setup, ut_teardown,
11501 test_snow3g_hash_generate_test_case_4),
11502 TEST_CASE_ST(ut_setup, ut_teardown,
11503 test_snow3g_hash_generate_test_case_5),
11504 TEST_CASE_ST(ut_setup, ut_teardown,
11505 test_snow3g_hash_generate_test_case_6),
11506 TEST_CASE_ST(ut_setup, ut_teardown,
11507 test_snow3g_hash_verify_test_case_1),
11508 TEST_CASE_ST(ut_setup, ut_teardown,
11509 test_snow3g_hash_verify_test_case_2),
11510 TEST_CASE_ST(ut_setup, ut_teardown,
11511 test_snow3g_hash_verify_test_case_3),
11512 /* Tests with buffers which length is not byte-aligned */
11513 TEST_CASE_ST(ut_setup, ut_teardown,
11514 test_snow3g_hash_verify_test_case_4),
11515 TEST_CASE_ST(ut_setup, ut_teardown,
11516 test_snow3g_hash_verify_test_case_5),
11517 TEST_CASE_ST(ut_setup, ut_teardown,
11518 test_snow3g_hash_verify_test_case_6),
11519 TEST_CASE_ST(ut_setup, ut_teardown,
11520 test_snow3g_cipher_auth_test_case_1),
11522 /** SNOW 3G generate auth, then encrypt (UEA2) */
11523 TEST_CASE_ST(ut_setup, ut_teardown,
11524 test_snow3g_auth_cipher_test_case_1),
11525 TEST_CASE_ST(ut_setup, ut_teardown,
11526 test_snow3g_auth_cipher_test_case_2),
11527 TEST_CASE_ST(ut_setup, ut_teardown,
11528 test_snow3g_auth_cipher_test_case_2_oop),
11529 TEST_CASE_ST(ut_setup, ut_teardown,
11530 test_snow3g_auth_cipher_part_digest_enc),
11531 TEST_CASE_ST(ut_setup, ut_teardown,
11532 test_snow3g_auth_cipher_part_digest_enc_oop),
11533 TEST_CASE_ST(ut_setup, ut_teardown,
11534 test_snow3g_auth_cipher_test_case_3_sgl),
11535 TEST_CASE_ST(ut_setup, ut_teardown,
11536 test_snow3g_auth_cipher_test_case_3_oop_sgl),
11537 TEST_CASE_ST(ut_setup, ut_teardown,
11538 test_snow3g_auth_cipher_part_digest_enc_sgl),
11539 TEST_CASE_ST(ut_setup, ut_teardown,
11540 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
11542 /** SNOW 3G decrypt (UEA2), then verify auth */
11543 TEST_CASE_ST(ut_setup, ut_teardown,
11544 test_snow3g_auth_cipher_verify_test_case_1),
11545 TEST_CASE_ST(ut_setup, ut_teardown,
11546 test_snow3g_auth_cipher_verify_test_case_2),
11547 TEST_CASE_ST(ut_setup, ut_teardown,
11548 test_snow3g_auth_cipher_verify_test_case_2_oop),
11549 TEST_CASE_ST(ut_setup, ut_teardown,
11550 test_snow3g_auth_cipher_verify_part_digest_enc),
11551 TEST_CASE_ST(ut_setup, ut_teardown,
11552 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
11553 TEST_CASE_ST(ut_setup, ut_teardown,
11554 test_snow3g_auth_cipher_verify_test_case_3_sgl),
11555 TEST_CASE_ST(ut_setup, ut_teardown,
11556 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
11557 TEST_CASE_ST(ut_setup, ut_teardown,
11558 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
11559 TEST_CASE_ST(ut_setup, ut_teardown,
11560 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
11562 TEST_CASES_END() /**< NULL terminate unit test array */
11566 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
11567 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
11568 .setup = testsuite_setup,
11569 .teardown = testsuite_teardown,
11570 .unit_test_cases = {
11571 /** ZUC encrypt only (EEA3) */
11572 TEST_CASE_ST(ut_setup, ut_teardown,
11573 test_zuc_encryption_test_case_1),
11574 TEST_CASE_ST(ut_setup, ut_teardown,
11575 test_zuc_encryption_test_case_2),
11576 TEST_CASE_ST(ut_setup, ut_teardown,
11577 test_zuc_encryption_test_case_3),
11578 TEST_CASE_ST(ut_setup, ut_teardown,
11579 test_zuc_encryption_test_case_4),
11580 TEST_CASE_ST(ut_setup, ut_teardown,
11581 test_zuc_encryption_test_case_5),
11582 TEST_CASE_ST(ut_setup, ut_teardown,
11583 test_zuc_hash_generate_test_case_1),
11584 TEST_CASE_ST(ut_setup, ut_teardown,
11585 test_zuc_hash_generate_test_case_2),
11586 TEST_CASE_ST(ut_setup, ut_teardown,
11587 test_zuc_hash_generate_test_case_3),
11588 TEST_CASE_ST(ut_setup, ut_teardown,
11589 test_zuc_hash_generate_test_case_4),
11590 TEST_CASE_ST(ut_setup, ut_teardown,
11591 test_zuc_hash_generate_test_case_5),
11592 TEST_CASE_ST(ut_setup, ut_teardown,
11593 test_zuc_encryption_test_case_6_sgl),
11594 TEST_CASES_END() /**< NULL terminate unit test array */
11598 static struct unit_test_suite cryptodev_caam_jr_testsuite = {
11599 .suite_name = "Crypto CAAM JR Unit Test Suite",
11600 .setup = testsuite_setup,
11601 .teardown = testsuite_teardown,
11602 .unit_test_cases = {
11603 TEST_CASE_ST(ut_setup, ut_teardown,
11604 test_device_configure_invalid_dev_id),
11605 TEST_CASE_ST(ut_setup, ut_teardown,
11606 test_multi_session),
11608 TEST_CASE_ST(ut_setup, ut_teardown,
11609 test_AES_chain_caam_jr_all),
11610 TEST_CASE_ST(ut_setup, ut_teardown,
11611 test_3DES_chain_caam_jr_all),
11612 TEST_CASE_ST(ut_setup, ut_teardown,
11613 test_AES_cipheronly_caam_jr_all),
11614 TEST_CASE_ST(ut_setup, ut_teardown,
11615 test_3DES_cipheronly_caam_jr_all),
11616 TEST_CASE_ST(ut_setup, ut_teardown,
11617 test_authonly_caam_jr_all),
11619 TEST_CASES_END() /**< NULL terminate unit test array */
11623 static struct unit_test_suite cryptodev_dpaa_sec_testsuite = {
11624 .suite_name = "Crypto DPAA_SEC 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_dpaa_sec_all),
11635 TEST_CASE_ST(ut_setup, ut_teardown,
11636 test_3DES_chain_dpaa_sec_all),
11637 TEST_CASE_ST(ut_setup, ut_teardown,
11638 test_AES_cipheronly_dpaa_sec_all),
11639 TEST_CASE_ST(ut_setup, ut_teardown,
11640 test_3DES_cipheronly_dpaa_sec_all),
11641 TEST_CASE_ST(ut_setup, ut_teardown,
11642 test_authonly_dpaa_sec_all),
11644 #ifdef RTE_LIBRTE_SECURITY
11645 TEST_CASE_ST(ut_setup, ut_teardown,
11646 test_PDCP_PROTO_cplane_encap_all),
11648 TEST_CASE_ST(ut_setup, ut_teardown,
11649 test_PDCP_PROTO_cplane_decap_all),
11651 /** AES GCM Authenticated Encryption */
11652 TEST_CASE_ST(ut_setup, ut_teardown,
11653 test_AES_GCM_authenticated_encryption_test_case_1),
11654 TEST_CASE_ST(ut_setup, ut_teardown,
11655 test_AES_GCM_authenticated_encryption_test_case_2),
11656 TEST_CASE_ST(ut_setup, ut_teardown,
11657 test_AES_GCM_authenticated_encryption_test_case_3),
11658 TEST_CASE_ST(ut_setup, ut_teardown,
11659 test_AES_GCM_authenticated_encryption_test_case_4),
11660 TEST_CASE_ST(ut_setup, ut_teardown,
11661 test_AES_GCM_authenticated_encryption_test_case_5),
11662 TEST_CASE_ST(ut_setup, ut_teardown,
11663 test_AES_GCM_authenticated_encryption_test_case_6),
11664 TEST_CASE_ST(ut_setup, ut_teardown,
11665 test_AES_GCM_authenticated_encryption_test_case_7),
11667 /** AES GCM Authenticated Decryption */
11668 TEST_CASE_ST(ut_setup, ut_teardown,
11669 test_AES_GCM_authenticated_decryption_test_case_1),
11670 TEST_CASE_ST(ut_setup, ut_teardown,
11671 test_AES_GCM_authenticated_decryption_test_case_2),
11672 TEST_CASE_ST(ut_setup, ut_teardown,
11673 test_AES_GCM_authenticated_decryption_test_case_3),
11674 TEST_CASE_ST(ut_setup, ut_teardown,
11675 test_AES_GCM_authenticated_decryption_test_case_4),
11676 TEST_CASE_ST(ut_setup, ut_teardown,
11677 test_AES_GCM_authenticated_decryption_test_case_5),
11678 TEST_CASE_ST(ut_setup, ut_teardown,
11679 test_AES_GCM_authenticated_decryption_test_case_6),
11680 TEST_CASE_ST(ut_setup, ut_teardown,
11681 test_AES_GCM_authenticated_decryption_test_case_7),
11683 /** AES GCM Authenticated Encryption 256 bits key */
11684 TEST_CASE_ST(ut_setup, ut_teardown,
11685 test_AES_GCM_auth_encryption_test_case_256_1),
11686 TEST_CASE_ST(ut_setup, ut_teardown,
11687 test_AES_GCM_auth_encryption_test_case_256_2),
11688 TEST_CASE_ST(ut_setup, ut_teardown,
11689 test_AES_GCM_auth_encryption_test_case_256_3),
11690 TEST_CASE_ST(ut_setup, ut_teardown,
11691 test_AES_GCM_auth_encryption_test_case_256_4),
11692 TEST_CASE_ST(ut_setup, ut_teardown,
11693 test_AES_GCM_auth_encryption_test_case_256_5),
11694 TEST_CASE_ST(ut_setup, ut_teardown,
11695 test_AES_GCM_auth_encryption_test_case_256_6),
11696 TEST_CASE_ST(ut_setup, ut_teardown,
11697 test_AES_GCM_auth_encryption_test_case_256_7),
11699 /** AES GCM Authenticated Decryption 256 bits key */
11700 TEST_CASE_ST(ut_setup, ut_teardown,
11701 test_AES_GCM_auth_decryption_test_case_256_1),
11702 TEST_CASE_ST(ut_setup, ut_teardown,
11703 test_AES_GCM_auth_decryption_test_case_256_2),
11704 TEST_CASE_ST(ut_setup, ut_teardown,
11705 test_AES_GCM_auth_decryption_test_case_256_3),
11706 TEST_CASE_ST(ut_setup, ut_teardown,
11707 test_AES_GCM_auth_decryption_test_case_256_4),
11708 TEST_CASE_ST(ut_setup, ut_teardown,
11709 test_AES_GCM_auth_decryption_test_case_256_5),
11710 TEST_CASE_ST(ut_setup, ut_teardown,
11711 test_AES_GCM_auth_decryption_test_case_256_6),
11712 TEST_CASE_ST(ut_setup, ut_teardown,
11713 test_AES_GCM_auth_decryption_test_case_256_7),
11715 /** Out of place tests */
11716 TEST_CASE_ST(ut_setup, ut_teardown,
11717 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11718 TEST_CASE_ST(ut_setup, ut_teardown,
11719 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11721 /** Scatter-Gather */
11722 TEST_CASE_ST(ut_setup, ut_teardown,
11723 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
11724 TEST_CASE_ST(ut_setup, ut_teardown,
11725 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
11726 TEST_CASE_ST(ut_setup, ut_teardown,
11727 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11728 TEST_CASE_ST(ut_setup, ut_teardown,
11729 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
11731 TEST_CASES_END() /**< NULL terminate unit test array */
11735 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
11736 .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
11737 .setup = testsuite_setup,
11738 .teardown = testsuite_teardown,
11739 .unit_test_cases = {
11740 TEST_CASE_ST(ut_setup, ut_teardown,
11741 test_device_configure_invalid_dev_id),
11742 TEST_CASE_ST(ut_setup, ut_teardown,
11743 test_multi_session),
11745 TEST_CASE_ST(ut_setup, ut_teardown,
11746 test_AES_chain_dpaa2_sec_all),
11747 TEST_CASE_ST(ut_setup, ut_teardown,
11748 test_3DES_chain_dpaa2_sec_all),
11749 TEST_CASE_ST(ut_setup, ut_teardown,
11750 test_AES_cipheronly_dpaa2_sec_all),
11751 TEST_CASE_ST(ut_setup, ut_teardown,
11752 test_3DES_cipheronly_dpaa2_sec_all),
11753 TEST_CASE_ST(ut_setup, ut_teardown,
11754 test_authonly_dpaa2_sec_all),
11756 #ifdef RTE_LIBRTE_SECURITY
11757 TEST_CASE_ST(ut_setup, ut_teardown,
11758 test_PDCP_PROTO_cplane_encap_all),
11760 TEST_CASE_ST(ut_setup, ut_teardown,
11761 test_PDCP_PROTO_cplane_decap_all),
11763 /** AES GCM Authenticated Encryption */
11764 TEST_CASE_ST(ut_setup, ut_teardown,
11765 test_AES_GCM_authenticated_encryption_test_case_1),
11766 TEST_CASE_ST(ut_setup, ut_teardown,
11767 test_AES_GCM_authenticated_encryption_test_case_2),
11768 TEST_CASE_ST(ut_setup, ut_teardown,
11769 test_AES_GCM_authenticated_encryption_test_case_3),
11770 TEST_CASE_ST(ut_setup, ut_teardown,
11771 test_AES_GCM_authenticated_encryption_test_case_4),
11772 TEST_CASE_ST(ut_setup, ut_teardown,
11773 test_AES_GCM_authenticated_encryption_test_case_5),
11774 TEST_CASE_ST(ut_setup, ut_teardown,
11775 test_AES_GCM_authenticated_encryption_test_case_6),
11776 TEST_CASE_ST(ut_setup, ut_teardown,
11777 test_AES_GCM_authenticated_encryption_test_case_7),
11779 /** AES GCM Authenticated Decryption */
11780 TEST_CASE_ST(ut_setup, ut_teardown,
11781 test_AES_GCM_authenticated_decryption_test_case_1),
11782 TEST_CASE_ST(ut_setup, ut_teardown,
11783 test_AES_GCM_authenticated_decryption_test_case_2),
11784 TEST_CASE_ST(ut_setup, ut_teardown,
11785 test_AES_GCM_authenticated_decryption_test_case_3),
11786 TEST_CASE_ST(ut_setup, ut_teardown,
11787 test_AES_GCM_authenticated_decryption_test_case_4),
11788 TEST_CASE_ST(ut_setup, ut_teardown,
11789 test_AES_GCM_authenticated_decryption_test_case_5),
11790 TEST_CASE_ST(ut_setup, ut_teardown,
11791 test_AES_GCM_authenticated_decryption_test_case_6),
11792 TEST_CASE_ST(ut_setup, ut_teardown,
11793 test_AES_GCM_authenticated_decryption_test_case_7),
11795 /** AES GCM Authenticated Encryption 192 bits key */
11796 TEST_CASE_ST(ut_setup, ut_teardown,
11797 test_AES_GCM_auth_encryption_test_case_192_1),
11798 TEST_CASE_ST(ut_setup, ut_teardown,
11799 test_AES_GCM_auth_encryption_test_case_192_2),
11800 TEST_CASE_ST(ut_setup, ut_teardown,
11801 test_AES_GCM_auth_encryption_test_case_192_3),
11802 TEST_CASE_ST(ut_setup, ut_teardown,
11803 test_AES_GCM_auth_encryption_test_case_192_4),
11804 TEST_CASE_ST(ut_setup, ut_teardown,
11805 test_AES_GCM_auth_encryption_test_case_192_5),
11806 TEST_CASE_ST(ut_setup, ut_teardown,
11807 test_AES_GCM_auth_encryption_test_case_192_6),
11808 TEST_CASE_ST(ut_setup, ut_teardown,
11809 test_AES_GCM_auth_encryption_test_case_192_7),
11811 /** AES GCM Authenticated Decryption 192 bits key */
11812 TEST_CASE_ST(ut_setup, ut_teardown,
11813 test_AES_GCM_auth_decryption_test_case_192_1),
11814 TEST_CASE_ST(ut_setup, ut_teardown,
11815 test_AES_GCM_auth_decryption_test_case_192_2),
11816 TEST_CASE_ST(ut_setup, ut_teardown,
11817 test_AES_GCM_auth_decryption_test_case_192_3),
11818 TEST_CASE_ST(ut_setup, ut_teardown,
11819 test_AES_GCM_auth_decryption_test_case_192_4),
11820 TEST_CASE_ST(ut_setup, ut_teardown,
11821 test_AES_GCM_auth_decryption_test_case_192_5),
11822 TEST_CASE_ST(ut_setup, ut_teardown,
11823 test_AES_GCM_auth_decryption_test_case_192_6),
11824 TEST_CASE_ST(ut_setup, ut_teardown,
11825 test_AES_GCM_auth_decryption_test_case_192_7),
11827 /** AES GCM Authenticated Encryption 256 bits key */
11828 TEST_CASE_ST(ut_setup, ut_teardown,
11829 test_AES_GCM_auth_encryption_test_case_256_1),
11830 TEST_CASE_ST(ut_setup, ut_teardown,
11831 test_AES_GCM_auth_encryption_test_case_256_2),
11832 TEST_CASE_ST(ut_setup, ut_teardown,
11833 test_AES_GCM_auth_encryption_test_case_256_3),
11834 TEST_CASE_ST(ut_setup, ut_teardown,
11835 test_AES_GCM_auth_encryption_test_case_256_4),
11836 TEST_CASE_ST(ut_setup, ut_teardown,
11837 test_AES_GCM_auth_encryption_test_case_256_5),
11838 TEST_CASE_ST(ut_setup, ut_teardown,
11839 test_AES_GCM_auth_encryption_test_case_256_6),
11840 TEST_CASE_ST(ut_setup, ut_teardown,
11841 test_AES_GCM_auth_encryption_test_case_256_7),
11843 /** AES GCM Authenticated Decryption 256 bits key */
11844 TEST_CASE_ST(ut_setup, ut_teardown,
11845 test_AES_GCM_auth_decryption_test_case_256_1),
11846 TEST_CASE_ST(ut_setup, ut_teardown,
11847 test_AES_GCM_auth_decryption_test_case_256_2),
11848 TEST_CASE_ST(ut_setup, ut_teardown,
11849 test_AES_GCM_auth_decryption_test_case_256_3),
11850 TEST_CASE_ST(ut_setup, ut_teardown,
11851 test_AES_GCM_auth_decryption_test_case_256_4),
11852 TEST_CASE_ST(ut_setup, ut_teardown,
11853 test_AES_GCM_auth_decryption_test_case_256_5),
11854 TEST_CASE_ST(ut_setup, ut_teardown,
11855 test_AES_GCM_auth_decryption_test_case_256_6),
11856 TEST_CASE_ST(ut_setup, ut_teardown,
11857 test_AES_GCM_auth_decryption_test_case_256_7),
11859 /** Out of place tests */
11860 TEST_CASE_ST(ut_setup, ut_teardown,
11861 test_AES_GCM_authenticated_encryption_oop_test_case_1),
11862 TEST_CASE_ST(ut_setup, ut_teardown,
11863 test_AES_GCM_authenticated_decryption_oop_test_case_1),
11865 /** Scatter-Gather */
11866 TEST_CASE_ST(ut_setup, ut_teardown,
11867 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
11868 TEST_CASE_ST(ut_setup, ut_teardown,
11869 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
11870 TEST_CASE_ST(ut_setup, ut_teardown,
11871 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11872 TEST_CASE_ST(ut_setup, ut_teardown,
11873 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
11875 TEST_CASES_END() /**< NULL terminate unit test array */
11879 static struct unit_test_suite cryptodev_null_testsuite = {
11880 .suite_name = "Crypto Device NULL Unit Test Suite",
11881 .setup = testsuite_setup,
11882 .teardown = testsuite_teardown,
11883 .unit_test_cases = {
11884 TEST_CASE_ST(ut_setup, ut_teardown,
11885 test_null_invalid_operation),
11886 TEST_CASE_ST(ut_setup, ut_teardown,
11887 test_null_burst_operation),
11888 TEST_CASE_ST(ut_setup, ut_teardown,
11889 test_AES_chain_null_all),
11890 TEST_CASE_ST(ut_setup, ut_teardown,
11891 test_AES_cipheronly_null_all),
11892 TEST_CASE_ST(ut_setup, ut_teardown,
11893 test_authonly_null_all),
11895 TEST_CASES_END() /**< NULL terminate unit test array */
11899 static struct unit_test_suite cryptodev_armv8_testsuite = {
11900 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
11901 .setup = testsuite_setup,
11902 .teardown = testsuite_teardown,
11903 .unit_test_cases = {
11904 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
11906 /** Negative tests */
11907 TEST_CASE_ST(ut_setup, ut_teardown,
11908 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11909 TEST_CASE_ST(ut_setup, ut_teardown,
11910 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11912 TEST_CASES_END() /**< NULL terminate unit test array */
11916 static struct unit_test_suite cryptodev_mrvl_testsuite = {
11917 .suite_name = "Crypto Device Marvell Component Test Suite",
11918 .setup = testsuite_setup,
11919 .teardown = testsuite_teardown,
11920 .unit_test_cases = {
11921 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11922 TEST_CASE_ST(ut_setup, ut_teardown,
11923 test_multi_session_random_usage),
11924 TEST_CASE_ST(ut_setup, ut_teardown,
11925 test_AES_chain_mrvl_all),
11926 TEST_CASE_ST(ut_setup, ut_teardown,
11927 test_AES_cipheronly_mrvl_all),
11928 TEST_CASE_ST(ut_setup, ut_teardown,
11929 test_authonly_mrvl_all),
11930 TEST_CASE_ST(ut_setup, ut_teardown,
11931 test_3DES_chain_mrvl_all),
11932 TEST_CASE_ST(ut_setup, ut_teardown,
11933 test_3DES_cipheronly_mrvl_all),
11935 /** Negative tests */
11936 TEST_CASE_ST(ut_setup, ut_teardown,
11937 authentication_verify_HMAC_SHA1_fail_data_corrupt),
11938 TEST_CASE_ST(ut_setup, ut_teardown,
11939 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
11940 TEST_CASE_ST(ut_setup, ut_teardown,
11941 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11942 TEST_CASE_ST(ut_setup, ut_teardown,
11943 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11945 TEST_CASES_END() /**< NULL terminate unit test array */
11949 static struct unit_test_suite cryptodev_ccp_testsuite = {
11950 .suite_name = "Crypto Device CCP Unit Test Suite",
11951 .setup = testsuite_setup,
11952 .teardown = testsuite_teardown,
11953 .unit_test_cases = {
11954 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
11955 TEST_CASE_ST(ut_setup, ut_teardown,
11956 test_multi_session_random_usage),
11957 TEST_CASE_ST(ut_setup, ut_teardown,
11958 test_AES_chain_ccp_all),
11959 TEST_CASE_ST(ut_setup, ut_teardown,
11960 test_AES_cipheronly_ccp_all),
11961 TEST_CASE_ST(ut_setup, ut_teardown,
11962 test_3DES_chain_ccp_all),
11963 TEST_CASE_ST(ut_setup, ut_teardown,
11964 test_3DES_cipheronly_ccp_all),
11965 TEST_CASE_ST(ut_setup, ut_teardown,
11966 test_authonly_ccp_all),
11968 /** Negative tests */
11969 TEST_CASE_ST(ut_setup, ut_teardown,
11970 authentication_verify_HMAC_SHA1_fail_data_corrupt),
11971 TEST_CASE_ST(ut_setup, ut_teardown,
11972 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
11973 TEST_CASE_ST(ut_setup, ut_teardown,
11974 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
11975 TEST_CASE_ST(ut_setup, ut_teardown,
11976 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
11978 TEST_CASES_END() /**< NULL terminate unit test array */
11982 static struct unit_test_suite cryptodev_octeontx_testsuite = {
11983 .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
11984 .setup = testsuite_setup,
11985 .teardown = testsuite_teardown,
11986 .unit_test_cases = {
11987 TEST_CASE_ST(ut_setup, ut_teardown,
11988 test_AES_chain_octeontx_all),
11989 TEST_CASE_ST(ut_setup, ut_teardown,
11990 test_AES_cipheronly_octeontx_all),
11991 TEST_CASE_ST(ut_setup, ut_teardown,
11992 test_3DES_chain_octeontx_all),
11993 TEST_CASE_ST(ut_setup, ut_teardown,
11994 test_3DES_cipheronly_octeontx_all),
11995 TEST_CASE_ST(ut_setup, ut_teardown,
11996 test_authonly_octeontx_all),
11998 /** AES GCM Authenticated Encryption */
11999 TEST_CASE_ST(ut_setup, ut_teardown,
12000 test_AES_GCM_authenticated_encryption_test_case_1),
12001 TEST_CASE_ST(ut_setup, ut_teardown,
12002 test_AES_GCM_authenticated_encryption_test_case_2),
12003 TEST_CASE_ST(ut_setup, ut_teardown,
12004 test_AES_GCM_authenticated_encryption_test_case_3),
12005 TEST_CASE_ST(ut_setup, ut_teardown,
12006 test_AES_GCM_authenticated_encryption_test_case_4),
12007 TEST_CASE_ST(ut_setup, ut_teardown,
12008 test_AES_GCM_authenticated_encryption_test_case_5),
12009 TEST_CASE_ST(ut_setup, ut_teardown,
12010 test_AES_GCM_authenticated_encryption_test_case_6),
12011 TEST_CASE_ST(ut_setup, ut_teardown,
12012 test_AES_GCM_authenticated_encryption_test_case_7),
12014 /** AES GCM Authenticated Decryption */
12015 TEST_CASE_ST(ut_setup, ut_teardown,
12016 test_AES_GCM_authenticated_decryption_test_case_1),
12017 TEST_CASE_ST(ut_setup, ut_teardown,
12018 test_AES_GCM_authenticated_decryption_test_case_2),
12019 TEST_CASE_ST(ut_setup, ut_teardown,
12020 test_AES_GCM_authenticated_decryption_test_case_3),
12021 TEST_CASE_ST(ut_setup, ut_teardown,
12022 test_AES_GCM_authenticated_decryption_test_case_4),
12023 TEST_CASE_ST(ut_setup, ut_teardown,
12024 test_AES_GCM_authenticated_decryption_test_case_5),
12025 TEST_CASE_ST(ut_setup, ut_teardown,
12026 test_AES_GCM_authenticated_decryption_test_case_6),
12027 TEST_CASE_ST(ut_setup, ut_teardown,
12028 test_AES_GCM_authenticated_decryption_test_case_7),
12029 /** AES GMAC Authentication */
12030 TEST_CASE_ST(ut_setup, ut_teardown,
12031 test_AES_GMAC_authentication_test_case_1),
12032 TEST_CASE_ST(ut_setup, ut_teardown,
12033 test_AES_GMAC_authentication_verify_test_case_1),
12034 TEST_CASE_ST(ut_setup, ut_teardown,
12035 test_AES_GMAC_authentication_test_case_2),
12036 TEST_CASE_ST(ut_setup, ut_teardown,
12037 test_AES_GMAC_authentication_verify_test_case_2),
12038 TEST_CASE_ST(ut_setup, ut_teardown,
12039 test_AES_GMAC_authentication_test_case_3),
12040 TEST_CASE_ST(ut_setup, ut_teardown,
12041 test_AES_GMAC_authentication_verify_test_case_3),
12043 /** SNOW 3G encrypt only (UEA2) */
12044 TEST_CASE_ST(ut_setup, ut_teardown,
12045 test_snow3g_encryption_test_case_1),
12046 TEST_CASE_ST(ut_setup, ut_teardown,
12047 test_snow3g_encryption_test_case_2),
12048 TEST_CASE_ST(ut_setup, ut_teardown,
12049 test_snow3g_encryption_test_case_3),
12050 TEST_CASE_ST(ut_setup, ut_teardown,
12051 test_snow3g_encryption_test_case_4),
12052 TEST_CASE_ST(ut_setup, ut_teardown,
12053 test_snow3g_encryption_test_case_5),
12055 TEST_CASE_ST(ut_setup, ut_teardown,
12056 test_snow3g_encryption_test_case_1_oop),
12057 TEST_CASE_ST(ut_setup, ut_teardown,
12058 test_snow3g_decryption_test_case_1_oop),
12059 TEST_CASE_ST(ut_setup, ut_teardown,
12060 test_snow3g_encryption_test_case_1_oop_sgl),
12062 /** SNOW 3G decrypt only (UEA2) */
12063 TEST_CASE_ST(ut_setup, ut_teardown,
12064 test_snow3g_decryption_test_case_1),
12065 TEST_CASE_ST(ut_setup, ut_teardown,
12066 test_snow3g_decryption_test_case_2),
12067 TEST_CASE_ST(ut_setup, ut_teardown,
12068 test_snow3g_decryption_test_case_3),
12069 TEST_CASE_ST(ut_setup, ut_teardown,
12070 test_snow3g_decryption_test_case_4),
12071 TEST_CASE_ST(ut_setup, ut_teardown,
12072 test_snow3g_decryption_test_case_5),
12074 TEST_CASE_ST(ut_setup, ut_teardown,
12075 test_snow3g_hash_generate_test_case_1),
12076 TEST_CASE_ST(ut_setup, ut_teardown,
12077 test_snow3g_hash_generate_test_case_2),
12078 TEST_CASE_ST(ut_setup, ut_teardown,
12079 test_snow3g_hash_generate_test_case_3),
12080 TEST_CASE_ST(ut_setup, ut_teardown,
12081 test_snow3g_hash_verify_test_case_1),
12082 TEST_CASE_ST(ut_setup, ut_teardown,
12083 test_snow3g_hash_verify_test_case_2),
12084 TEST_CASE_ST(ut_setup, ut_teardown,
12085 test_snow3g_hash_verify_test_case_3),
12087 /** ZUC encrypt only (EEA3) */
12088 TEST_CASE_ST(ut_setup, ut_teardown,
12089 test_zuc_encryption_test_case_1),
12090 TEST_CASE_ST(ut_setup, ut_teardown,
12091 test_zuc_encryption_test_case_2),
12092 TEST_CASE_ST(ut_setup, ut_teardown,
12093 test_zuc_encryption_test_case_3),
12094 TEST_CASE_ST(ut_setup, ut_teardown,
12095 test_zuc_encryption_test_case_4),
12096 TEST_CASE_ST(ut_setup, ut_teardown,
12097 test_zuc_encryption_test_case_5),
12098 TEST_CASE_ST(ut_setup, ut_teardown,
12099 test_zuc_hash_generate_test_case_1),
12100 TEST_CASE_ST(ut_setup, ut_teardown,
12101 test_zuc_hash_generate_test_case_2),
12102 TEST_CASE_ST(ut_setup, ut_teardown,
12103 test_zuc_hash_generate_test_case_3),
12104 TEST_CASE_ST(ut_setup, ut_teardown,
12105 test_zuc_hash_generate_test_case_4),
12106 TEST_CASE_ST(ut_setup, ut_teardown,
12107 test_zuc_hash_generate_test_case_5),
12108 TEST_CASE_ST(ut_setup, ut_teardown,
12109 test_zuc_encryption_test_case_6_sgl),
12111 /** KASUMI encrypt only (UEA1) */
12112 TEST_CASE_ST(ut_setup, ut_teardown,
12113 test_kasumi_encryption_test_case_1),
12114 TEST_CASE_ST(ut_setup, ut_teardown,
12115 test_kasumi_encryption_test_case_2),
12116 TEST_CASE_ST(ut_setup, ut_teardown,
12117 test_kasumi_encryption_test_case_3),
12118 TEST_CASE_ST(ut_setup, ut_teardown,
12119 test_kasumi_encryption_test_case_4),
12120 TEST_CASE_ST(ut_setup, ut_teardown,
12121 test_kasumi_encryption_test_case_5),
12122 TEST_CASE_ST(ut_setup, ut_teardown,
12123 test_kasumi_encryption_test_case_1_sgl),
12124 TEST_CASE_ST(ut_setup, ut_teardown,
12125 test_kasumi_encryption_test_case_1_oop_sgl),
12126 /** KASUMI decrypt only (UEA1) */
12127 TEST_CASE_ST(ut_setup, ut_teardown,
12128 test_kasumi_decryption_test_case_1),
12129 TEST_CASE_ST(ut_setup, ut_teardown,
12130 test_kasumi_decryption_test_case_2),
12131 TEST_CASE_ST(ut_setup, ut_teardown,
12132 test_kasumi_decryption_test_case_3),
12133 TEST_CASE_ST(ut_setup, ut_teardown,
12134 test_kasumi_decryption_test_case_4),
12135 TEST_CASE_ST(ut_setup, ut_teardown,
12136 test_kasumi_decryption_test_case_5),
12138 TEST_CASE_ST(ut_setup, ut_teardown,
12139 test_kasumi_encryption_test_case_1_oop),
12140 TEST_CASE_ST(ut_setup, ut_teardown,
12141 test_kasumi_decryption_test_case_1_oop),
12143 /** KASUMI hash only (UIA1) */
12144 TEST_CASE_ST(ut_setup, ut_teardown,
12145 test_kasumi_hash_generate_test_case_1),
12146 TEST_CASE_ST(ut_setup, ut_teardown,
12147 test_kasumi_hash_generate_test_case_2),
12148 TEST_CASE_ST(ut_setup, ut_teardown,
12149 test_kasumi_hash_generate_test_case_3),
12150 TEST_CASE_ST(ut_setup, ut_teardown,
12151 test_kasumi_hash_generate_test_case_4),
12152 TEST_CASE_ST(ut_setup, ut_teardown,
12153 test_kasumi_hash_generate_test_case_5),
12154 TEST_CASE_ST(ut_setup, ut_teardown,
12155 test_kasumi_hash_generate_test_case_6),
12156 TEST_CASE_ST(ut_setup, ut_teardown,
12157 test_kasumi_hash_verify_test_case_1),
12158 TEST_CASE_ST(ut_setup, ut_teardown,
12159 test_kasumi_hash_verify_test_case_2),
12160 TEST_CASE_ST(ut_setup, ut_teardown,
12161 test_kasumi_hash_verify_test_case_3),
12162 TEST_CASE_ST(ut_setup, ut_teardown,
12163 test_kasumi_hash_verify_test_case_4),
12164 TEST_CASE_ST(ut_setup, ut_teardown,
12165 test_kasumi_hash_verify_test_case_5),
12168 TEST_CASE_ST(ut_setup, ut_teardown,
12169 test_null_cipher_only_operation),
12170 TEST_CASE_ST(ut_setup, ut_teardown,
12171 test_null_auth_only_operation),
12172 TEST_CASE_ST(ut_setup, ut_teardown,
12173 test_null_cipher_auth_operation),
12174 TEST_CASE_ST(ut_setup, ut_teardown,
12175 test_null_auth_cipher_operation),
12177 /** Negative tests */
12178 TEST_CASE_ST(ut_setup, ut_teardown,
12179 authentication_verify_HMAC_SHA1_fail_data_corrupt),
12180 TEST_CASE_ST(ut_setup, ut_teardown,
12181 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12182 TEST_CASE_ST(ut_setup, ut_teardown,
12183 authentication_verify_AES128_GMAC_fail_data_corrupt),
12184 TEST_CASE_ST(ut_setup, ut_teardown,
12185 authentication_verify_AES128_GMAC_fail_tag_corrupt),
12186 TEST_CASE_ST(ut_setup, ut_teardown,
12187 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12188 TEST_CASE_ST(ut_setup, ut_teardown,
12189 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12190 TEST_CASES_END() /**< NULL terminate unit test array */
12195 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
12197 gbl_driver_id = rte_cryptodev_driver_id_get(
12198 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
12200 if (gbl_driver_id == -1) {
12201 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
12202 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
12203 "are enabled in config file to run this testsuite.\n");
12204 return TEST_SKIPPED;
12207 return unit_test_suite_runner(&cryptodev_qat_testsuite);
12211 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
12213 gbl_driver_id = rte_cryptodev_driver_id_get(
12214 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
12216 if (gbl_driver_id == -1) {
12217 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
12218 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
12219 "in config file to run this testsuite.\n");
12220 return TEST_FAILED;
12223 return unit_test_suite_runner(&cryptodev_virtio_testsuite);
12227 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
12229 gbl_driver_id = rte_cryptodev_driver_id_get(
12230 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12232 if (gbl_driver_id == -1) {
12233 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
12234 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
12235 "in config file to run this testsuite.\n");
12236 return TEST_SKIPPED;
12239 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
12243 test_cryptodev_openssl(void)
12245 gbl_driver_id = rte_cryptodev_driver_id_get(
12246 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
12248 if (gbl_driver_id == -1) {
12249 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
12250 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
12251 "in config file to run this testsuite.\n");
12252 return TEST_SKIPPED;
12255 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
12259 test_cryptodev_aesni_gcm(void)
12261 gbl_driver_id = rte_cryptodev_driver_id_get(
12262 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
12264 if (gbl_driver_id == -1) {
12265 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
12266 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
12267 "in config file to run this testsuite.\n");
12268 return TEST_SKIPPED;
12271 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
12275 test_cryptodev_null(void)
12277 gbl_driver_id = rte_cryptodev_driver_id_get(
12278 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
12280 if (gbl_driver_id == -1) {
12281 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
12282 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
12283 "in config file to run this testsuite.\n");
12284 return TEST_SKIPPED;
12287 return unit_test_suite_runner(&cryptodev_null_testsuite);
12291 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
12293 gbl_driver_id = rte_cryptodev_driver_id_get(
12294 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
12296 if (gbl_driver_id == -1) {
12297 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
12298 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
12299 "in config file to run this testsuite.\n");
12300 return TEST_SKIPPED;
12303 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
12307 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
12309 gbl_driver_id = rte_cryptodev_driver_id_get(
12310 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
12312 if (gbl_driver_id == -1) {
12313 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
12314 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
12315 "in config file to run this testsuite.\n");
12316 return TEST_SKIPPED;
12319 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
12323 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
12325 gbl_driver_id = rte_cryptodev_driver_id_get(
12326 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
12328 if (gbl_driver_id == -1) {
12329 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
12330 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
12331 "in config file to run this testsuite.\n");
12332 return TEST_SKIPPED;
12335 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
12339 test_cryptodev_armv8(void)
12341 gbl_driver_id = rte_cryptodev_driver_id_get(
12342 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
12344 if (gbl_driver_id == -1) {
12345 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
12346 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
12347 "in config file to run this testsuite.\n");
12348 return TEST_SKIPPED;
12351 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
12355 test_cryptodev_mrvl(void)
12357 gbl_driver_id = rte_cryptodev_driver_id_get(
12358 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
12360 if (gbl_driver_id == -1) {
12361 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
12362 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
12363 "in config file to run this testsuite.\n");
12364 return TEST_SKIPPED;
12367 return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
12370 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
12373 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
12375 gbl_driver_id = rte_cryptodev_driver_id_get(
12376 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
12378 if (gbl_driver_id == -1) {
12379 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
12380 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
12381 "in config file to run this testsuite.\n");
12382 return TEST_SKIPPED;
12385 if (rte_cryptodev_driver_id_get(
12386 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
12387 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
12388 " enabled in config file to run this testsuite.\n");
12389 return TEST_SKIPPED;
12391 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
12394 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
12399 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
12401 gbl_driver_id = rte_cryptodev_driver_id_get(
12402 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
12404 if (gbl_driver_id == -1) {
12405 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
12406 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
12407 "in config file to run this testsuite.\n");
12408 return TEST_SKIPPED;
12411 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
12415 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
12417 gbl_driver_id = rte_cryptodev_driver_id_get(
12418 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
12420 if (gbl_driver_id == -1) {
12421 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
12422 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
12423 "in config file to run this testsuite.\n");
12424 return TEST_SKIPPED;
12427 return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
12431 test_cryptodev_ccp(void)
12433 gbl_driver_id = rte_cryptodev_driver_id_get(
12434 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
12436 if (gbl_driver_id == -1) {
12437 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
12438 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
12439 "in config file to run this testsuite.\n");
12440 return TEST_FAILED;
12443 return unit_test_suite_runner(&cryptodev_ccp_testsuite);
12447 test_cryptodev_octeontx(void)
12449 gbl_driver_id = rte_cryptodev_driver_id_get(
12450 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
12451 if (gbl_driver_id == -1) {
12452 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
12453 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
12454 "enabled in config file to run this "
12456 return TEST_FAILED;
12458 return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
12462 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
12464 gbl_driver_id = rte_cryptodev_driver_id_get(
12465 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
12467 if (gbl_driver_id == -1) {
12468 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
12469 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
12470 "in config file to run this testsuite.\n");
12471 return TEST_FAILED;
12474 return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
12477 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
12478 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
12479 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
12480 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
12481 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
12482 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
12483 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
12484 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
12485 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
12486 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
12487 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
12488 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
12489 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
12490 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
12491 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
12492 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);