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