4 * Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <rte_common.h>
34 #include <rte_hexdump.h>
36 #include <rte_malloc.h>
37 #include <rte_memcpy.h>
38 #include <rte_pause.h>
40 #include <rte_crypto.h>
41 #include <rte_cryptodev.h>
42 #include <rte_cryptodev_pmd.h>
44 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
45 #include <rte_cryptodev_scheduler.h>
46 #include <rte_cryptodev_scheduler_operations.h>
50 #include "test_cryptodev.h"
52 #include "test_cryptodev_blockcipher.h"
53 #include "test_cryptodev_aes_test_vectors.h"
54 #include "test_cryptodev_des_test_vectors.h"
55 #include "test_cryptodev_hash_test_vectors.h"
56 #include "test_cryptodev_kasumi_test_vectors.h"
57 #include "test_cryptodev_kasumi_hash_test_vectors.h"
58 #include "test_cryptodev_snow3g_test_vectors.h"
59 #include "test_cryptodev_snow3g_hash_test_vectors.h"
60 #include "test_cryptodev_zuc_test_vectors.h"
61 #include "test_cryptodev_gcm_test_vectors.h"
62 #include "test_cryptodev_hmac_test_vectors.h"
64 static int gbl_driver_id;
66 struct crypto_testsuite_params {
67 struct rte_mempool *mbuf_pool;
68 struct rte_mempool *large_mbuf_pool;
69 struct rte_mempool *op_mpool;
70 struct rte_mempool *session_mpool;
71 struct rte_cryptodev_config conf;
72 struct rte_cryptodev_qp_conf qp_conf;
74 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
75 uint8_t valid_dev_count;
78 struct crypto_unittest_params {
79 struct rte_crypto_sym_xform cipher_xform;
80 struct rte_crypto_sym_xform auth_xform;
81 struct rte_crypto_sym_xform aead_xform;
83 struct rte_cryptodev_sym_session *sess;
85 struct rte_crypto_op *op;
87 struct rte_mbuf *obuf, *ibuf;
92 #define ALIGN_POW2_ROUNDUP(num, align) \
93 (((num) + (align) - 1) & ~((align) - 1))
96 * Forward declarations.
99 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
100 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
104 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
105 struct crypto_unittest_params *ut_params,
106 struct crypto_testsuite_params *ts_param,
107 const uint8_t *cipher,
108 const uint8_t *digest,
111 static struct rte_mbuf *
112 setup_test_string(struct rte_mempool *mpool,
113 const char *string, size_t len, uint8_t blocksize)
115 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
116 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
118 memset(m->buf_addr, 0, m->buf_len);
120 char *dst = rte_pktmbuf_append(m, t_len);
127 rte_memcpy(dst, string, t_len);
129 memset(dst, 0, t_len);
135 /* Get number of bytes in X bits (rounding up) */
137 ceil_byte_length(uint32_t num_bits)
140 return ((num_bits >> 3) + 1);
142 return (num_bits >> 3);
145 static struct rte_crypto_op *
146 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
148 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
149 printf("Error sending packet for encryption");
155 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
161 static struct crypto_testsuite_params testsuite_params = { NULL };
162 static struct crypto_unittest_params unittest_params;
165 testsuite_setup(void)
167 struct crypto_testsuite_params *ts_params = &testsuite_params;
168 struct rte_cryptodev_info info;
169 uint32_t i = 0, nb_devs, dev_id;
173 memset(ts_params, 0, sizeof(*ts_params));
175 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
176 if (ts_params->mbuf_pool == NULL) {
177 /* Not already created so create */
178 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
180 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
182 if (ts_params->mbuf_pool == NULL) {
183 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
188 ts_params->large_mbuf_pool = rte_mempool_lookup(
189 "CRYPTO_LARGE_MBUFPOOL");
190 if (ts_params->large_mbuf_pool == NULL) {
191 /* Not already created so create */
192 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
193 "CRYPTO_LARGE_MBUFPOOL",
196 if (ts_params->large_mbuf_pool == NULL) {
198 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
203 ts_params->op_mpool = rte_crypto_op_pool_create(
204 "MBUF_CRYPTO_SYM_OP_POOL",
205 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
206 NUM_MBUFS, MBUF_CACHE_SIZE,
208 sizeof(struct rte_crypto_sym_xform) +
211 if (ts_params->op_mpool == NULL) {
212 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
216 /* Create an AESNI MB device if required */
217 if (gbl_driver_id == rte_cryptodev_driver_id_get(
218 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
219 nb_devs = rte_cryptodev_device_count_by_driver(
220 rte_cryptodev_driver_id_get(
221 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
224 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
226 TEST_ASSERT(ret == 0,
227 "Failed to create instance of"
229 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
233 /* Create an AESNI GCM device if required */
234 if (gbl_driver_id == rte_cryptodev_driver_id_get(
235 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
236 nb_devs = rte_cryptodev_device_count_by_driver(
237 rte_cryptodev_driver_id_get(
238 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
240 TEST_ASSERT_SUCCESS(rte_vdev_init(
241 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
242 "Failed to create instance of"
244 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
248 /* Create a SNOW 3G device if required */
249 if (gbl_driver_id == rte_cryptodev_driver_id_get(
250 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
251 nb_devs = rte_cryptodev_device_count_by_driver(
252 rte_cryptodev_driver_id_get(
253 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
255 TEST_ASSERT_SUCCESS(rte_vdev_init(
256 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
257 "Failed to create instance of"
259 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
263 /* Create a KASUMI device if required */
264 if (gbl_driver_id == rte_cryptodev_driver_id_get(
265 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
266 nb_devs = rte_cryptodev_device_count_by_driver(
267 rte_cryptodev_driver_id_get(
268 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
270 TEST_ASSERT_SUCCESS(rte_vdev_init(
271 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
272 "Failed to create instance of"
274 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
278 /* Create a ZUC device if required */
279 if (gbl_driver_id == rte_cryptodev_driver_id_get(
280 RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
281 nb_devs = rte_cryptodev_device_count_by_driver(
282 rte_cryptodev_driver_id_get(
283 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
285 TEST_ASSERT_SUCCESS(rte_vdev_init(
286 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
287 "Failed to create instance of"
289 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
293 /* Create a NULL device if required */
294 if (gbl_driver_id == rte_cryptodev_driver_id_get(
295 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
296 nb_devs = rte_cryptodev_device_count_by_driver(
297 rte_cryptodev_driver_id_get(
298 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
301 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
303 TEST_ASSERT(ret == 0,
304 "Failed to create instance of"
306 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
310 /* Create an OPENSSL device if required */
311 if (gbl_driver_id == rte_cryptodev_driver_id_get(
312 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
313 nb_devs = rte_cryptodev_device_count_by_driver(
314 rte_cryptodev_driver_id_get(
315 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
318 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
321 TEST_ASSERT(ret == 0, "Failed to create "
322 "instance of pmd : %s",
323 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
327 /* Create a ARMv8 device if required */
328 if (gbl_driver_id == rte_cryptodev_driver_id_get(
329 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
330 nb_devs = rte_cryptodev_device_count_by_driver(
331 rte_cryptodev_driver_id_get(
332 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
335 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
338 TEST_ASSERT(ret == 0, "Failed to create "
339 "instance of pmd : %s",
340 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
344 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
345 if (gbl_driver_id == rte_cryptodev_driver_id_get(
346 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
348 nb_devs = rte_cryptodev_device_count_by_driver(
349 rte_cryptodev_driver_id_get(
350 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
353 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
356 TEST_ASSERT(ret == 0,
357 "Failed to create instance %u of"
359 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
362 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
364 nb_devs = rte_cryptodev_count();
366 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
370 /* Create list of valid crypto devs */
371 for (i = 0; i < nb_devs; i++) {
372 rte_cryptodev_info_get(i, &info);
373 if (info.driver_id == gbl_driver_id)
374 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
377 if (ts_params->valid_dev_count < 1)
380 /* Set up all the qps on the first of the valid devices found */
382 dev_id = ts_params->valid_devs[0];
384 rte_cryptodev_info_get(dev_id, &info);
386 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
387 ts_params->conf.socket_id = SOCKET_ID_ANY;
389 unsigned int session_size = rte_cryptodev_get_private_session_size(dev_id);
392 * Create mempool with maximum number of sessions * 2,
393 * to include the session headers
395 ts_params->session_mpool = rte_mempool_create(
397 info.sym.max_nb_sessions * 2,
399 0, 0, NULL, NULL, NULL,
403 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
404 "session mempool allocation failed");
406 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
408 "Failed to configure cryptodev %u with %u qps",
409 dev_id, ts_params->conf.nb_queue_pairs);
411 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
413 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
414 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
415 dev_id, qp_id, &ts_params->qp_conf,
416 rte_cryptodev_socket_id(dev_id),
417 ts_params->session_mpool),
418 "Failed to setup queue pair %u on cryptodev %u",
426 testsuite_teardown(void)
428 struct crypto_testsuite_params *ts_params = &testsuite_params;
430 if (ts_params->mbuf_pool != NULL) {
431 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
432 rte_mempool_avail_count(ts_params->mbuf_pool));
435 if (ts_params->op_mpool != NULL) {
436 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
437 rte_mempool_avail_count(ts_params->op_mpool));
440 /* Free session mempools */
441 if (ts_params->session_mpool != NULL) {
442 rte_mempool_free(ts_params->session_mpool);
443 ts_params->session_mpool = NULL;
450 struct crypto_testsuite_params *ts_params = &testsuite_params;
451 struct crypto_unittest_params *ut_params = &unittest_params;
455 /* Clear unit test parameters before running test */
456 memset(ut_params, 0, sizeof(*ut_params));
458 /* Reconfigure device to default parameters */
459 ts_params->conf.socket_id = SOCKET_ID_ANY;
461 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
463 "Failed to configure cryptodev %u",
464 ts_params->valid_devs[0]);
466 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
467 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
468 ts_params->valid_devs[0], qp_id,
470 rte_cryptodev_socket_id(ts_params->valid_devs[0]),
471 ts_params->session_mpool),
472 "Failed to setup queue pair %u on cryptodev %u",
473 qp_id, ts_params->valid_devs[0]);
477 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
479 /* Start the device */
480 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
481 "Failed to start cryptodev %u",
482 ts_params->valid_devs[0]);
490 struct crypto_testsuite_params *ts_params = &testsuite_params;
491 struct crypto_unittest_params *ut_params = &unittest_params;
492 struct rte_cryptodev_stats stats;
494 /* free crypto session structure */
495 if (ut_params->sess) {
496 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
498 rte_cryptodev_sym_session_free(ut_params->sess);
499 ut_params->sess = NULL;
502 /* free crypto operation structure */
504 rte_crypto_op_free(ut_params->op);
507 * free mbuf - both obuf and ibuf are usually the same,
508 * so check if they point at the same address is necessary,
509 * to avoid freeing the mbuf twice.
511 if (ut_params->obuf) {
512 rte_pktmbuf_free(ut_params->obuf);
513 if (ut_params->ibuf == ut_params->obuf)
517 if (ut_params->ibuf) {
518 rte_pktmbuf_free(ut_params->ibuf);
522 if (ts_params->mbuf_pool != NULL)
523 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
524 rte_mempool_avail_count(ts_params->mbuf_pool));
526 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
528 /* Stop the device */
529 rte_cryptodev_stop(ts_params->valid_devs[0]);
533 test_device_configure_invalid_dev_id(void)
535 struct crypto_testsuite_params *ts_params = &testsuite_params;
536 uint16_t dev_id, num_devs = 0;
538 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
539 "Need at least %d devices for test", 1);
541 /* valid dev_id values */
542 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
544 /* Stop the device in case it's started so it can be configured */
545 rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
547 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
548 "Failed test for rte_cryptodev_configure: "
549 "invalid dev_num %u", dev_id);
551 /* invalid dev_id values */
554 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
555 "Failed test for rte_cryptodev_configure: "
556 "invalid dev_num %u", dev_id);
560 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
561 "Failed test for rte_cryptodev_configure:"
562 "invalid dev_num %u", dev_id);
568 test_device_configure_invalid_queue_pair_ids(void)
570 struct crypto_testsuite_params *ts_params = &testsuite_params;
571 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
573 /* Stop the device in case it's started so it can be configured */
574 rte_cryptodev_stop(ts_params->valid_devs[0]);
576 /* valid - one queue pairs */
577 ts_params->conf.nb_queue_pairs = 1;
579 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
581 "Failed to configure cryptodev: dev_id %u, qp_id %u",
582 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
585 /* valid - max value queue pairs */
586 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
588 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
590 "Failed to configure cryptodev: dev_id %u, qp_id %u",
591 ts_params->valid_devs[0],
592 ts_params->conf.nb_queue_pairs);
595 /* invalid - zero queue pairs */
596 ts_params->conf.nb_queue_pairs = 0;
598 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
600 "Failed test for rte_cryptodev_configure, dev_id %u,"
602 ts_params->valid_devs[0],
603 ts_params->conf.nb_queue_pairs);
606 /* invalid - max value supported by field queue pairs */
607 ts_params->conf.nb_queue_pairs = UINT16_MAX;
609 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
611 "Failed test for rte_cryptodev_configure, dev_id %u,"
613 ts_params->valid_devs[0],
614 ts_params->conf.nb_queue_pairs);
617 /* invalid - max value + 1 queue pairs */
618 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
620 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
622 "Failed test for rte_cryptodev_configure, dev_id %u,"
624 ts_params->valid_devs[0],
625 ts_params->conf.nb_queue_pairs);
627 /* revert to original testsuite value */
628 ts_params->conf.nb_queue_pairs = orig_nb_qps;
634 test_queue_pair_descriptor_setup(void)
636 struct crypto_testsuite_params *ts_params = &testsuite_params;
637 struct rte_cryptodev_info dev_info;
638 struct rte_cryptodev_qp_conf qp_conf = {
639 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
644 /* Stop the device in case it's started so it can be configured */
645 rte_cryptodev_stop(ts_params->valid_devs[0]);
648 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
650 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
652 "Failed to configure cryptodev %u",
653 ts_params->valid_devs[0]);
656 * Test various ring sizes on this device. memzones can't be
657 * freed so are re-used if ring is released and re-created.
659 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
661 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
662 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
663 ts_params->valid_devs[0], qp_id, &qp_conf,
664 rte_cryptodev_socket_id(
665 ts_params->valid_devs[0]),
666 ts_params->session_mpool),
668 "rte_cryptodev_queue_pair_setup: num_inflights "
669 "%u on qp %u on cryptodev %u",
670 qp_conf.nb_descriptors, qp_id,
671 ts_params->valid_devs[0]);
674 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
676 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
677 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
678 ts_params->valid_devs[0], qp_id, &qp_conf,
679 rte_cryptodev_socket_id(
680 ts_params->valid_devs[0]),
681 ts_params->session_mpool),
683 " rte_cryptodev_queue_pair_setup: num_inflights"
684 " %u on qp %u on cryptodev %u",
685 qp_conf.nb_descriptors, qp_id,
686 ts_params->valid_devs[0]);
689 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
691 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
692 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
693 ts_params->valid_devs[0], qp_id, &qp_conf,
694 rte_cryptodev_socket_id(
695 ts_params->valid_devs[0]),
696 ts_params->session_mpool),
698 "rte_cryptodev_queue_pair_setup: num_inflights"
699 " %u on qp %u on cryptodev %u",
700 qp_conf.nb_descriptors, qp_id,
701 ts_params->valid_devs[0]);
704 /* invalid number of descriptors - max supported + 2 */
705 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
707 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
708 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
709 ts_params->valid_devs[0], qp_id, &qp_conf,
710 rte_cryptodev_socket_id(
711 ts_params->valid_devs[0]),
712 ts_params->session_mpool),
713 "Unexpectedly passed test for "
714 "rte_cryptodev_queue_pair_setup:"
715 "num_inflights %u on qp %u on cryptodev %u",
716 qp_conf.nb_descriptors, qp_id,
717 ts_params->valid_devs[0]);
720 /* invalid number of descriptors - max value of parameter */
721 qp_conf.nb_descriptors = UINT32_MAX-1;
723 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
724 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
725 ts_params->valid_devs[0], qp_id, &qp_conf,
726 rte_cryptodev_socket_id(
727 ts_params->valid_devs[0]),
728 ts_params->session_mpool),
729 "Unexpectedly passed test for "
730 "rte_cryptodev_queue_pair_setup:"
731 "num_inflights %u on qp %u on cryptodev %u",
732 qp_conf.nb_descriptors, qp_id,
733 ts_params->valid_devs[0]);
736 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
738 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
739 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
740 ts_params->valid_devs[0], qp_id, &qp_conf,
741 rte_cryptodev_socket_id(
742 ts_params->valid_devs[0]),
743 ts_params->session_mpool),
745 " rte_cryptodev_queue_pair_setup:"
746 "num_inflights %u on qp %u on cryptodev %u",
747 qp_conf.nb_descriptors, qp_id,
748 ts_params->valid_devs[0]);
751 /* invalid number of descriptors - max supported + 1 */
752 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
754 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
755 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
756 ts_params->valid_devs[0], qp_id, &qp_conf,
757 rte_cryptodev_socket_id(
758 ts_params->valid_devs[0]),
759 ts_params->session_mpool),
760 "Unexpectedly passed test for "
761 "rte_cryptodev_queue_pair_setup:"
762 "num_inflights %u on qp %u on cryptodev %u",
763 qp_conf.nb_descriptors, qp_id,
764 ts_params->valid_devs[0]);
767 /* test invalid queue pair id */
768 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
770 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */
772 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
773 ts_params->valid_devs[0],
775 rte_cryptodev_socket_id(ts_params->valid_devs[0]),
776 ts_params->session_mpool),
777 "Failed test for rte_cryptodev_queue_pair_setup:"
778 "invalid qp %u on cryptodev %u",
779 qp_id, ts_params->valid_devs[0]);
781 qp_id = 0xffff; /*invalid*/
783 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
784 ts_params->valid_devs[0],
786 rte_cryptodev_socket_id(ts_params->valid_devs[0]),
787 ts_params->session_mpool),
788 "Failed test for rte_cryptodev_queue_pair_setup:"
789 "invalid qp %u on cryptodev %u",
790 qp_id, ts_params->valid_devs[0]);
795 /* ***** Plaintext data for tests ***** */
797 const char catch_22_quote_1[] =
798 "There was only one catch and that was Catch-22, which "
799 "specified that a concern for one's safety in the face of "
800 "dangers that were real and immediate was the process of a "
801 "rational mind. Orr was crazy and could be grounded. All he "
802 "had to do was ask; and as soon as he did, he would no longer "
803 "be crazy and would have to fly more missions. Orr would be "
804 "crazy to fly more missions and sane if he didn't, but if he "
805 "was sane he had to fly them. If he flew them he was crazy "
806 "and didn't have to; but if he didn't want to he was sane and "
807 "had to. Yossarian was moved very deeply by the absolute "
808 "simplicity of this clause of Catch-22 and let out a "
809 "respectful whistle. \"That's some catch, that Catch-22\", he "
810 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
812 const char catch_22_quote[] =
813 "What a lousy earth! He wondered how many people were "
814 "destitute that same night even in his own prosperous country, "
815 "how many homes were shanties, how many husbands were drunk "
816 "and wives socked, and how many children were bullied, abused, "
817 "or abandoned. How many families hungered for food they could "
818 "not afford to buy? How many hearts were broken? How many "
819 "suicides would take place that same night, how many people "
820 "would go insane? How many cockroaches and landlords would "
821 "triumph? How many winners were losers, successes failures, "
822 "and rich men poor men? How many wise guys were stupid? How "
823 "many happy endings were unhappy endings? How many honest men "
824 "were liars, brave men cowards, loyal men traitors, how many "
825 "sainted men were corrupt, how many people in positions of "
826 "trust had sold their souls to bodyguards, how many had never "
827 "had souls? How many straight-and-narrow paths were crooked "
828 "paths? How many best families were worst families and how "
829 "many good people were bad people? When you added them all up "
830 "and then subtracted, you might be left with only the children, "
831 "and perhaps with Albert Einstein and an old violinist or "
832 "sculptor somewhere.";
834 #define QUOTE_480_BYTES (480)
835 #define QUOTE_512_BYTES (512)
836 #define QUOTE_768_BYTES (768)
837 #define QUOTE_1024_BYTES (1024)
841 /* ***** SHA1 Hash Tests ***** */
843 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
845 static uint8_t hmac_sha1_key[] = {
846 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
847 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
848 0xDE, 0xF4, 0xDE, 0xAD };
850 /* ***** SHA224 Hash Tests ***** */
852 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
855 /* ***** AES-CBC Cipher Tests ***** */
857 #define CIPHER_KEY_LENGTH_AES_CBC (16)
858 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
860 static uint8_t aes_cbc_key[] = {
861 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
862 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
864 static uint8_t aes_cbc_iv[] = {
865 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
866 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
869 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
871 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
872 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
873 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
874 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
875 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
876 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
877 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
878 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
879 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
880 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
881 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
882 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
883 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
884 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
885 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
886 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
887 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
888 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
889 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
890 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
891 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
892 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
893 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
894 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
895 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
896 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
897 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
898 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
899 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
900 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
901 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
902 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
903 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
904 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
905 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
906 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
907 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
908 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
909 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
910 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
911 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
912 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
913 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
914 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
915 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
916 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
917 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
918 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
919 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
920 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
921 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
922 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
923 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
924 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
925 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
926 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
927 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
928 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
929 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
930 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
931 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
932 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
933 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
934 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
935 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
938 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
939 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
940 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
941 0x18, 0x8c, 0x1d, 0x32
945 /* Multisession Vector context Test */
947 static uint8_t ms_aes_cbc_key0[] = {
948 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
949 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
952 static uint8_t ms_aes_cbc_iv0[] = {
953 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
954 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
957 static const uint8_t ms_aes_cbc_cipher0[] = {
958 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
959 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
960 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
961 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
962 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
963 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
964 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
965 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
966 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
967 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
968 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
969 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
970 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
971 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
972 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
973 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
974 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
975 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
976 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
977 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
978 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
979 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
980 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
981 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
982 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
983 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
984 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
985 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
986 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
987 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
988 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
989 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
990 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
991 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
992 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
993 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
994 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
995 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
996 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
997 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
998 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
999 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1000 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1001 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1002 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1003 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1004 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1005 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1006 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1007 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1008 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1009 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1010 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1011 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1012 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1013 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1014 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1015 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1016 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1017 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1018 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1019 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1020 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1021 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1025 static uint8_t ms_hmac_key0[] = {
1026 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1027 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1028 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1029 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1030 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1031 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1032 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1033 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1036 static const uint8_t ms_hmac_digest0[] = {
1037 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1038 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1039 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1040 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1041 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1042 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1043 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1044 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1048 /* Begin session 1 */
1050 static uint8_t ms_aes_cbc_key1[] = {
1051 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1052 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1055 static uint8_t ms_aes_cbc_iv1[] = {
1056 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1057 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1060 static const uint8_t ms_aes_cbc_cipher1[] = {
1061 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1062 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1063 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1064 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1065 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1066 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1067 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1068 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1069 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1070 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1071 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1072 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1073 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1074 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1075 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1076 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1077 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1078 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1079 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1080 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1081 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1082 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1083 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1084 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1085 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1086 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1087 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1088 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1089 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1090 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1091 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1092 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1093 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1094 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1095 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1096 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1097 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1098 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1099 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1100 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1101 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1102 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1103 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1104 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1105 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1106 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1107 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1108 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1109 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1110 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1111 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1112 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1113 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1114 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1115 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1116 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1117 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1118 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1119 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1120 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1121 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1122 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1123 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1124 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1128 static uint8_t ms_hmac_key1[] = {
1129 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1130 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1131 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1132 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1133 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1134 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1135 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1136 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1139 static const uint8_t ms_hmac_digest1[] = {
1140 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1141 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1142 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1143 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1144 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1145 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1146 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1147 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1150 /* Begin Session 2 */
1151 static uint8_t ms_aes_cbc_key2[] = {
1152 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1153 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1156 static uint8_t ms_aes_cbc_iv2[] = {
1157 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1158 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1161 static const uint8_t ms_aes_cbc_cipher2[] = {
1162 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1163 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1164 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1165 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1166 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1167 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1168 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1169 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1170 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1171 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1172 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1173 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1174 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1175 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1176 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1177 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1178 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1179 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1180 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1181 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1182 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1183 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1184 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1185 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1186 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1187 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1188 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1189 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1190 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1191 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1192 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1193 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1194 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1195 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1196 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1197 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1198 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1199 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1200 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1201 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1202 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1203 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1204 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1205 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1206 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1207 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1208 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1209 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1210 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1211 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1212 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1213 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1214 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1215 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1216 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1217 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1218 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1219 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1220 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1221 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1222 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1223 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1224 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1225 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1228 static uint8_t ms_hmac_key2[] = {
1229 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1230 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1231 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1232 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1233 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1234 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1235 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1236 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1239 static const uint8_t ms_hmac_digest2[] = {
1240 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1241 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1242 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1243 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1244 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1245 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1246 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1247 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1254 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1256 struct crypto_testsuite_params *ts_params = &testsuite_params;
1257 struct crypto_unittest_params *ut_params = &unittest_params;
1259 /* Generate test mbuf data and space for digest */
1260 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1261 catch_22_quote, QUOTE_512_BYTES, 0);
1263 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1264 DIGEST_BYTE_LENGTH_SHA1);
1265 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1267 /* Setup Cipher Parameters */
1268 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1269 ut_params->cipher_xform.next = &ut_params->auth_xform;
1271 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1272 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1273 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1274 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1275 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1276 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1278 /* Setup HMAC Parameters */
1279 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1281 ut_params->auth_xform.next = NULL;
1283 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1284 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1285 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1286 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1287 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1289 ut_params->sess = rte_cryptodev_sym_session_create(
1290 ts_params->session_mpool);
1292 /* Create crypto session*/
1293 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1294 ut_params->sess, &ut_params->cipher_xform,
1295 ts_params->session_mpool);
1296 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1298 /* Generate crypto op data structure */
1299 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1300 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1301 TEST_ASSERT_NOT_NULL(ut_params->op,
1302 "Failed to allocate symmetric crypto operation struct");
1304 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1306 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1308 /* set crypto operation source mbuf */
1309 sym_op->m_src = ut_params->ibuf;
1311 /* Set crypto operation authentication parameters */
1312 sym_op->auth.digest.data = ut_params->digest;
1313 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1314 ut_params->ibuf, QUOTE_512_BYTES);
1316 sym_op->auth.data.offset = 0;
1317 sym_op->auth.data.length = QUOTE_512_BYTES;
1319 /* Copy IV at the end of the crypto operation */
1320 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1321 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1323 /* Set crypto operation cipher parameters */
1324 sym_op->cipher.data.offset = 0;
1325 sym_op->cipher.data.length = QUOTE_512_BYTES;
1327 /* Process crypto operation */
1328 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1329 ut_params->op), "failed to process sym crypto op");
1331 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1332 "crypto op processing failed");
1335 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1338 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1339 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1341 "ciphertext data not as expected");
1343 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1345 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1346 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1347 gbl_driver_id == rte_cryptodev_driver_id_get(
1348 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1349 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1350 DIGEST_BYTE_LENGTH_SHA1,
1351 "Generated digest data not as expected");
1353 return TEST_SUCCESS;
1356 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1358 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1360 static uint8_t hmac_sha512_key[] = {
1361 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1362 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1363 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1364 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1365 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1366 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1367 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1368 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1370 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1371 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1372 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1373 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1374 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1375 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1376 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1377 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1378 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1383 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1384 struct crypto_unittest_params *ut_params,
1385 uint8_t *cipher_key,
1389 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1390 struct crypto_unittest_params *ut_params,
1391 struct crypto_testsuite_params *ts_params,
1392 const uint8_t *cipher,
1393 const uint8_t *digest,
1398 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1399 struct crypto_unittest_params *ut_params,
1400 uint8_t *cipher_key,
1404 /* Setup Cipher Parameters */
1405 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1406 ut_params->cipher_xform.next = NULL;
1408 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1409 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1410 ut_params->cipher_xform.cipher.key.data = cipher_key;
1411 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1412 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1413 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1415 /* Setup HMAC Parameters */
1416 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1417 ut_params->auth_xform.next = &ut_params->cipher_xform;
1419 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1420 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1421 ut_params->auth_xform.auth.key.data = hmac_key;
1422 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1423 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1425 return TEST_SUCCESS;
1430 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1431 struct crypto_unittest_params *ut_params,
1432 struct crypto_testsuite_params *ts_params,
1433 const uint8_t *cipher,
1434 const uint8_t *digest,
1437 /* Generate test mbuf data and digest */
1438 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1441 QUOTE_512_BYTES, 0);
1443 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1444 DIGEST_BYTE_LENGTH_SHA512);
1445 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1447 rte_memcpy(ut_params->digest,
1449 DIGEST_BYTE_LENGTH_SHA512);
1451 /* Generate Crypto op data structure */
1452 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1453 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1454 TEST_ASSERT_NOT_NULL(ut_params->op,
1455 "Failed to allocate symmetric crypto operation struct");
1457 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1459 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1461 /* set crypto operation source mbuf */
1462 sym_op->m_src = ut_params->ibuf;
1464 sym_op->auth.digest.data = ut_params->digest;
1465 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1466 ut_params->ibuf, QUOTE_512_BYTES);
1468 sym_op->auth.data.offset = 0;
1469 sym_op->auth.data.length = QUOTE_512_BYTES;
1471 /* Copy IV at the end of the crypto operation */
1472 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1473 iv, CIPHER_IV_LENGTH_AES_CBC);
1475 sym_op->cipher.data.offset = 0;
1476 sym_op->cipher.data.length = QUOTE_512_BYTES;
1478 /* Process crypto operation */
1479 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1480 ut_params->op), "failed to process sym crypto op");
1482 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1483 "crypto op processing failed");
1485 ut_params->obuf = ut_params->op->sym->m_src;
1488 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1489 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1492 "Plaintext data not as expected");
1495 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1496 "Digest verification failed");
1498 return TEST_SUCCESS;
1502 test_AES_cipheronly_mb_all(void)
1504 struct crypto_testsuite_params *ts_params = &testsuite_params;
1507 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1508 ts_params->op_mpool,
1509 ts_params->session_mpool,
1510 ts_params->valid_devs[0],
1511 rte_cryptodev_driver_id_get(
1512 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1513 BLKCIPHER_AES_CIPHERONLY_TYPE);
1515 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1517 return TEST_SUCCESS;
1521 test_AES_docsis_mb_all(void)
1523 struct crypto_testsuite_params *ts_params = &testsuite_params;
1526 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1527 ts_params->op_mpool,
1528 ts_params->session_mpool,
1529 ts_params->valid_devs[0],
1530 rte_cryptodev_driver_id_get(
1531 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1532 BLKCIPHER_AES_DOCSIS_TYPE);
1534 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1536 return TEST_SUCCESS;
1540 test_AES_docsis_qat_all(void)
1542 struct crypto_testsuite_params *ts_params = &testsuite_params;
1545 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1546 ts_params->op_mpool,
1547 ts_params->session_mpool,
1548 ts_params->valid_devs[0],
1549 rte_cryptodev_driver_id_get(
1550 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1551 BLKCIPHER_AES_DOCSIS_TYPE);
1553 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1555 return TEST_SUCCESS;
1559 test_DES_docsis_qat_all(void)
1561 struct crypto_testsuite_params *ts_params = &testsuite_params;
1564 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1565 ts_params->op_mpool,
1566 ts_params->session_mpool,
1567 ts_params->valid_devs[0],
1568 rte_cryptodev_driver_id_get(
1569 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1570 BLKCIPHER_DES_DOCSIS_TYPE);
1572 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1574 return TEST_SUCCESS;
1578 test_authonly_mb_all(void)
1580 struct crypto_testsuite_params *ts_params = &testsuite_params;
1583 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1584 ts_params->op_mpool,
1585 ts_params->session_mpool,
1586 ts_params->valid_devs[0],
1587 rte_cryptodev_driver_id_get(
1588 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1589 BLKCIPHER_AUTHONLY_TYPE);
1591 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1593 return TEST_SUCCESS;
1597 test_authonly_qat_all(void)
1599 struct crypto_testsuite_params *ts_params = &testsuite_params;
1602 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1603 ts_params->op_mpool,
1604 ts_params->session_mpool,
1605 ts_params->valid_devs[0],
1606 rte_cryptodev_driver_id_get(
1607 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1608 BLKCIPHER_AUTHONLY_TYPE);
1610 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1612 return TEST_SUCCESS;
1615 test_AES_chain_mb_all(void)
1617 struct crypto_testsuite_params *ts_params = &testsuite_params;
1620 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1621 ts_params->op_mpool,
1622 ts_params->session_mpool,
1623 ts_params->valid_devs[0],
1624 rte_cryptodev_driver_id_get(
1625 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1626 BLKCIPHER_AES_CHAIN_TYPE);
1628 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1630 return TEST_SUCCESS;
1633 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1636 test_AES_cipheronly_scheduler_all(void)
1638 struct crypto_testsuite_params *ts_params = &testsuite_params;
1641 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1642 ts_params->op_mpool,
1643 ts_params->session_mpool,
1644 ts_params->valid_devs[0],
1645 rte_cryptodev_driver_id_get(
1646 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1647 BLKCIPHER_AES_CIPHERONLY_TYPE);
1649 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1651 return TEST_SUCCESS;
1655 test_AES_chain_scheduler_all(void)
1657 struct crypto_testsuite_params *ts_params = &testsuite_params;
1660 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1661 ts_params->op_mpool,
1662 ts_params->session_mpool,
1663 ts_params->valid_devs[0],
1664 rte_cryptodev_driver_id_get(
1665 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1666 BLKCIPHER_AES_CHAIN_TYPE);
1668 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1670 return TEST_SUCCESS;
1674 test_authonly_scheduler_all(void)
1676 struct crypto_testsuite_params *ts_params = &testsuite_params;
1679 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1680 ts_params->op_mpool,
1681 ts_params->session_mpool,
1682 ts_params->valid_devs[0],
1683 rte_cryptodev_driver_id_get(
1684 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1685 BLKCIPHER_AUTHONLY_TYPE);
1687 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1689 return TEST_SUCCESS;
1692 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1695 test_AES_chain_openssl_all(void)
1697 struct crypto_testsuite_params *ts_params = &testsuite_params;
1700 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1701 ts_params->op_mpool,
1702 ts_params->session_mpool,
1703 ts_params->valid_devs[0],
1704 rte_cryptodev_driver_id_get(
1705 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1706 BLKCIPHER_AES_CHAIN_TYPE);
1708 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1710 return TEST_SUCCESS;
1714 test_AES_cipheronly_openssl_all(void)
1716 struct crypto_testsuite_params *ts_params = &testsuite_params;
1719 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1720 ts_params->op_mpool,
1721 ts_params->session_mpool,
1722 ts_params->valid_devs[0],
1723 rte_cryptodev_driver_id_get(
1724 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1725 BLKCIPHER_AES_CIPHERONLY_TYPE);
1727 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1729 return TEST_SUCCESS;
1733 test_AES_chain_qat_all(void)
1735 struct crypto_testsuite_params *ts_params = &testsuite_params;
1738 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1739 ts_params->op_mpool,
1740 ts_params->session_mpool,
1741 ts_params->valid_devs[0],
1742 rte_cryptodev_driver_id_get(
1743 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1744 BLKCIPHER_AES_CHAIN_TYPE);
1746 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1748 return TEST_SUCCESS;
1752 test_AES_cipheronly_qat_all(void)
1754 struct crypto_testsuite_params *ts_params = &testsuite_params;
1757 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1758 ts_params->op_mpool,
1759 ts_params->session_mpool,
1760 ts_params->valid_devs[0],
1761 rte_cryptodev_driver_id_get(
1762 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1763 BLKCIPHER_AES_CIPHERONLY_TYPE);
1765 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1767 return TEST_SUCCESS;
1771 test_AES_chain_dpaa2_sec_all(void)
1773 struct crypto_testsuite_params *ts_params = &testsuite_params;
1776 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1777 ts_params->op_mpool,
1778 ts_params->session_mpool,
1779 ts_params->valid_devs[0],
1780 rte_cryptodev_driver_id_get(
1781 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
1782 BLKCIPHER_AES_CHAIN_TYPE);
1784 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1786 return TEST_SUCCESS;
1790 test_AES_cipheronly_dpaa2_sec_all(void)
1792 struct crypto_testsuite_params *ts_params = &testsuite_params;
1795 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1796 ts_params->op_mpool,
1797 ts_params->session_mpool,
1798 ts_params->valid_devs[0],
1799 rte_cryptodev_driver_id_get(
1800 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
1801 BLKCIPHER_AES_CIPHERONLY_TYPE);
1803 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1805 return TEST_SUCCESS;
1809 test_authonly_dpaa2_sec_all(void)
1811 struct crypto_testsuite_params *ts_params = &testsuite_params;
1814 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1815 ts_params->op_mpool,
1816 ts_params->session_mpool,
1817 ts_params->valid_devs[0],
1818 rte_cryptodev_driver_id_get(
1819 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
1820 BLKCIPHER_AUTHONLY_TYPE);
1822 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1824 return TEST_SUCCESS;
1828 test_authonly_openssl_all(void)
1830 struct crypto_testsuite_params *ts_params = &testsuite_params;
1833 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1834 ts_params->op_mpool,
1835 ts_params->session_mpool,
1836 ts_params->valid_devs[0],
1837 rte_cryptodev_driver_id_get(
1838 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1839 BLKCIPHER_AUTHONLY_TYPE);
1841 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1843 return TEST_SUCCESS;
1847 test_AES_chain_armv8_all(void)
1849 struct crypto_testsuite_params *ts_params = &testsuite_params;
1852 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1853 ts_params->op_mpool,
1854 ts_params->session_mpool,
1855 ts_params->valid_devs[0],
1856 rte_cryptodev_driver_id_get(
1857 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
1858 BLKCIPHER_AES_CHAIN_TYPE);
1860 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1862 return TEST_SUCCESS;
1865 /* ***** SNOW 3G Tests ***** */
1867 create_wireless_algo_hash_session(uint8_t dev_id,
1868 const uint8_t *key, const uint8_t key_len,
1869 const uint8_t iv_len, const uint8_t auth_len,
1870 enum rte_crypto_auth_operation op,
1871 enum rte_crypto_auth_algorithm algo)
1873 uint8_t hash_key[key_len];
1875 struct crypto_testsuite_params *ts_params = &testsuite_params;
1876 struct crypto_unittest_params *ut_params = &unittest_params;
1878 memcpy(hash_key, key, key_len);
1880 TEST_HEXDUMP(stdout, "key:", key, key_len);
1882 /* Setup Authentication Parameters */
1883 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1884 ut_params->auth_xform.next = NULL;
1886 ut_params->auth_xform.auth.op = op;
1887 ut_params->auth_xform.auth.algo = algo;
1888 ut_params->auth_xform.auth.key.length = key_len;
1889 ut_params->auth_xform.auth.key.data = hash_key;
1890 ut_params->auth_xform.auth.digest_length = auth_len;
1891 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
1892 ut_params->auth_xform.auth.iv.length = iv_len;
1893 ut_params->sess = rte_cryptodev_sym_session_create(
1894 ts_params->session_mpool);
1896 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1897 &ut_params->auth_xform, ts_params->session_mpool);
1898 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1903 create_wireless_algo_cipher_session(uint8_t dev_id,
1904 enum rte_crypto_cipher_operation op,
1905 enum rte_crypto_cipher_algorithm algo,
1906 const uint8_t *key, const uint8_t key_len,
1909 uint8_t cipher_key[key_len];
1911 struct crypto_testsuite_params *ts_params = &testsuite_params;
1912 struct crypto_unittest_params *ut_params = &unittest_params;
1914 memcpy(cipher_key, key, key_len);
1916 /* Setup Cipher Parameters */
1917 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1918 ut_params->cipher_xform.next = NULL;
1920 ut_params->cipher_xform.cipher.algo = algo;
1921 ut_params->cipher_xform.cipher.op = op;
1922 ut_params->cipher_xform.cipher.key.data = cipher_key;
1923 ut_params->cipher_xform.cipher.key.length = key_len;
1924 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1925 ut_params->cipher_xform.cipher.iv.length = iv_len;
1927 TEST_HEXDUMP(stdout, "key:", key, key_len);
1929 /* Create Crypto session */
1930 ut_params->sess = rte_cryptodev_sym_session_create(
1931 ts_params->session_mpool);
1933 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1934 &ut_params->cipher_xform, ts_params->session_mpool);
1935 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1940 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
1941 unsigned int cipher_len,
1942 unsigned int cipher_offset)
1944 struct crypto_testsuite_params *ts_params = &testsuite_params;
1945 struct crypto_unittest_params *ut_params = &unittest_params;
1947 /* Generate Crypto op data structure */
1948 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1949 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1950 TEST_ASSERT_NOT_NULL(ut_params->op,
1951 "Failed to allocate pktmbuf offload");
1953 /* Set crypto operation data parameters */
1954 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1956 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1958 /* set crypto operation source mbuf */
1959 sym_op->m_src = ut_params->ibuf;
1962 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1964 sym_op->cipher.data.length = cipher_len;
1965 sym_op->cipher.data.offset = cipher_offset;
1970 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
1971 unsigned int cipher_len,
1972 unsigned int cipher_offset)
1974 struct crypto_testsuite_params *ts_params = &testsuite_params;
1975 struct crypto_unittest_params *ut_params = &unittest_params;
1977 /* Generate Crypto op data structure */
1978 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1979 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1980 TEST_ASSERT_NOT_NULL(ut_params->op,
1981 "Failed to allocate pktmbuf offload");
1983 /* Set crypto operation data parameters */
1984 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1986 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1988 /* set crypto operation source mbuf */
1989 sym_op->m_src = ut_params->ibuf;
1990 sym_op->m_dst = ut_params->obuf;
1993 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1995 sym_op->cipher.data.length = cipher_len;
1996 sym_op->cipher.data.offset = cipher_offset;
2001 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2002 enum rte_crypto_cipher_operation cipher_op,
2003 enum rte_crypto_auth_operation auth_op,
2004 enum rte_crypto_auth_algorithm auth_algo,
2005 enum rte_crypto_cipher_algorithm cipher_algo,
2006 const uint8_t *key, uint8_t key_len,
2007 uint8_t auth_iv_len, uint8_t auth_len,
2008 uint8_t cipher_iv_len)
2011 uint8_t cipher_auth_key[key_len];
2013 struct crypto_testsuite_params *ts_params = &testsuite_params;
2014 struct crypto_unittest_params *ut_params = &unittest_params;
2016 memcpy(cipher_auth_key, key, key_len);
2018 /* Setup Authentication Parameters */
2019 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2020 ut_params->auth_xform.next = NULL;
2022 ut_params->auth_xform.auth.op = auth_op;
2023 ut_params->auth_xform.auth.algo = auth_algo;
2024 ut_params->auth_xform.auth.key.length = key_len;
2025 /* Hash key = cipher key */
2026 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2027 ut_params->auth_xform.auth.digest_length = auth_len;
2028 /* Auth IV will be after cipher IV */
2029 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2030 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2032 /* Setup Cipher Parameters */
2033 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2034 ut_params->cipher_xform.next = &ut_params->auth_xform;
2036 ut_params->cipher_xform.cipher.algo = cipher_algo;
2037 ut_params->cipher_xform.cipher.op = cipher_op;
2038 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2039 ut_params->cipher_xform.cipher.key.length = key_len;
2040 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2041 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2043 TEST_HEXDUMP(stdout, "key:", key, key_len);
2045 /* Create Crypto session*/
2046 ut_params->sess = rte_cryptodev_sym_session_create(
2047 ts_params->session_mpool);
2049 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2050 &ut_params->cipher_xform, ts_params->session_mpool);
2052 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2057 create_wireless_cipher_auth_session(uint8_t dev_id,
2058 enum rte_crypto_cipher_operation cipher_op,
2059 enum rte_crypto_auth_operation auth_op,
2060 enum rte_crypto_auth_algorithm auth_algo,
2061 enum rte_crypto_cipher_algorithm cipher_algo,
2062 const struct wireless_test_data *tdata)
2064 const uint8_t key_len = tdata->key.len;
2065 uint8_t cipher_auth_key[key_len];
2067 struct crypto_testsuite_params *ts_params = &testsuite_params;
2068 struct crypto_unittest_params *ut_params = &unittest_params;
2069 const uint8_t *key = tdata->key.data;
2070 const uint8_t auth_len = tdata->digest.len;
2071 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2072 uint8_t auth_iv_len = tdata->auth_iv.len;
2074 memcpy(cipher_auth_key, key, key_len);
2076 /* Setup Authentication Parameters */
2077 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2078 ut_params->auth_xform.next = NULL;
2080 ut_params->auth_xform.auth.op = auth_op;
2081 ut_params->auth_xform.auth.algo = auth_algo;
2082 ut_params->auth_xform.auth.key.length = key_len;
2083 /* Hash key = cipher key */
2084 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2085 ut_params->auth_xform.auth.digest_length = auth_len;
2086 /* Auth IV will be after cipher IV */
2087 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2088 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2090 /* Setup Cipher Parameters */
2091 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2092 ut_params->cipher_xform.next = &ut_params->auth_xform;
2094 ut_params->cipher_xform.cipher.algo = cipher_algo;
2095 ut_params->cipher_xform.cipher.op = cipher_op;
2096 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2097 ut_params->cipher_xform.cipher.key.length = key_len;
2098 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2099 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2102 TEST_HEXDUMP(stdout, "key:", key, key_len);
2104 /* Create Crypto session*/
2105 ut_params->sess = rte_cryptodev_sym_session_create(
2106 ts_params->session_mpool);
2108 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2109 &ut_params->cipher_xform, ts_params->session_mpool);
2111 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2116 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2117 const struct wireless_test_data *tdata)
2119 return create_wireless_cipher_auth_session(dev_id,
2120 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2121 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2122 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2126 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2127 enum rte_crypto_cipher_operation cipher_op,
2128 enum rte_crypto_auth_operation auth_op,
2129 enum rte_crypto_auth_algorithm auth_algo,
2130 enum rte_crypto_cipher_algorithm cipher_algo,
2131 const uint8_t *key, const uint8_t key_len,
2132 uint8_t auth_iv_len, uint8_t auth_len,
2133 uint8_t cipher_iv_len)
2135 uint8_t auth_cipher_key[key_len];
2137 struct crypto_testsuite_params *ts_params = &testsuite_params;
2138 struct crypto_unittest_params *ut_params = &unittest_params;
2140 memcpy(auth_cipher_key, key, key_len);
2142 /* Setup Authentication Parameters */
2143 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2144 ut_params->auth_xform.auth.op = auth_op;
2145 ut_params->auth_xform.next = &ut_params->cipher_xform;
2146 ut_params->auth_xform.auth.algo = auth_algo;
2147 ut_params->auth_xform.auth.key.length = key_len;
2148 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2149 ut_params->auth_xform.auth.digest_length = auth_len;
2150 /* Auth IV will be after cipher IV */
2151 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2152 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2154 /* Setup Cipher Parameters */
2155 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2156 ut_params->cipher_xform.next = NULL;
2157 ut_params->cipher_xform.cipher.algo = cipher_algo;
2158 ut_params->cipher_xform.cipher.op = cipher_op;
2159 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2160 ut_params->cipher_xform.cipher.key.length = key_len;
2161 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2162 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2164 TEST_HEXDUMP(stdout, "key:", key, key_len);
2166 /* Create Crypto session*/
2167 ut_params->sess = rte_cryptodev_sym_session_create(
2168 ts_params->session_mpool);
2170 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2171 &ut_params->auth_xform, ts_params->session_mpool);
2173 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2179 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2180 unsigned int auth_tag_len,
2181 const uint8_t *iv, unsigned int iv_len,
2182 unsigned int data_pad_len,
2183 enum rte_crypto_auth_operation op,
2184 unsigned int auth_len, unsigned int auth_offset)
2186 struct crypto_testsuite_params *ts_params = &testsuite_params;
2188 struct crypto_unittest_params *ut_params = &unittest_params;
2190 /* Generate Crypto op data structure */
2191 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2192 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2193 TEST_ASSERT_NOT_NULL(ut_params->op,
2194 "Failed to allocate pktmbuf offload");
2196 /* Set crypto operation data parameters */
2197 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2199 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2201 /* set crypto operation source mbuf */
2202 sym_op->m_src = ut_params->ibuf;
2205 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2208 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2209 ut_params->ibuf, auth_tag_len);
2211 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2212 "no room to append auth tag");
2213 ut_params->digest = sym_op->auth.digest.data;
2214 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2215 ut_params->ibuf, data_pad_len);
2216 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2217 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2219 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2221 TEST_HEXDUMP(stdout, "digest:",
2222 sym_op->auth.digest.data,
2225 sym_op->auth.data.length = auth_len;
2226 sym_op->auth.data.offset = auth_offset;
2232 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2233 enum rte_crypto_auth_operation op)
2235 struct crypto_testsuite_params *ts_params = &testsuite_params;
2236 struct crypto_unittest_params *ut_params = &unittest_params;
2238 const uint8_t *auth_tag = tdata->digest.data;
2239 const unsigned int auth_tag_len = tdata->digest.len;
2240 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2241 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2243 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2244 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2245 const uint8_t *auth_iv = tdata->auth_iv.data;
2246 const uint8_t auth_iv_len = tdata->auth_iv.len;
2247 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2248 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2250 /* Generate Crypto op data structure */
2251 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2252 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2253 TEST_ASSERT_NOT_NULL(ut_params->op,
2254 "Failed to allocate pktmbuf offload");
2255 /* Set crypto operation data parameters */
2256 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2258 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2260 /* set crypto operation source mbuf */
2261 sym_op->m_src = ut_params->ibuf;
2264 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2265 ut_params->ibuf, auth_tag_len);
2267 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2268 "no room to append auth tag");
2269 ut_params->digest = sym_op->auth.digest.data;
2270 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2271 ut_params->ibuf, data_pad_len);
2272 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2273 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2275 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2277 TEST_HEXDUMP(stdout, "digest:",
2278 sym_op->auth.digest.data,
2281 /* Copy cipher and auth IVs at the end of the crypto operation */
2282 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2284 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2285 iv_ptr += cipher_iv_len;
2286 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2288 sym_op->cipher.data.length = cipher_len;
2289 sym_op->cipher.data.offset = 0;
2290 sym_op->auth.data.length = auth_len;
2291 sym_op->auth.data.offset = 0;
2297 create_zuc_cipher_hash_generate_operation(
2298 const struct wireless_test_data *tdata)
2300 return create_wireless_cipher_hash_operation(tdata,
2301 RTE_CRYPTO_AUTH_OP_GENERATE);
2305 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2306 const unsigned auth_tag_len,
2307 const uint8_t *auth_iv, uint8_t auth_iv_len,
2308 unsigned data_pad_len,
2309 enum rte_crypto_auth_operation op,
2310 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2311 const unsigned cipher_len, const unsigned cipher_offset,
2312 const unsigned auth_len, const unsigned auth_offset)
2314 struct crypto_testsuite_params *ts_params = &testsuite_params;
2315 struct crypto_unittest_params *ut_params = &unittest_params;
2317 /* Generate Crypto op data structure */
2318 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2319 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2320 TEST_ASSERT_NOT_NULL(ut_params->op,
2321 "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 source mbuf */
2328 sym_op->m_src = ut_params->ibuf;
2331 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2332 ut_params->ibuf, auth_tag_len);
2334 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2335 "no room to append auth tag");
2336 ut_params->digest = sym_op->auth.digest.data;
2337 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2338 ut_params->ibuf, data_pad_len);
2339 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2340 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2342 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2344 TEST_HEXDUMP(stdout, "digest:",
2345 sym_op->auth.digest.data,
2348 /* Copy cipher and auth IVs at the end of the crypto operation */
2349 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2351 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2352 iv_ptr += cipher_iv_len;
2353 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2355 sym_op->cipher.data.length = cipher_len;
2356 sym_op->cipher.data.offset = cipher_offset;
2357 sym_op->auth.data.length = auth_len;
2358 sym_op->auth.data.offset = auth_offset;
2364 create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
2365 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2366 const uint8_t *auth_iv, uint8_t auth_iv_len,
2367 unsigned int data_pad_len,
2368 unsigned int cipher_len, unsigned int cipher_offset,
2369 unsigned int auth_len, unsigned int auth_offset)
2371 struct crypto_testsuite_params *ts_params = &testsuite_params;
2372 struct crypto_unittest_params *ut_params = &unittest_params;
2374 /* Generate Crypto op data structure */
2375 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2376 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2377 TEST_ASSERT_NOT_NULL(ut_params->op,
2378 "Failed to allocate pktmbuf offload");
2380 /* Set crypto operation data parameters */
2381 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2383 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2385 /* set crypto operation source mbuf */
2386 sym_op->m_src = ut_params->ibuf;
2389 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2390 ut_params->ibuf, auth_tag_len);
2392 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2393 "no room to append auth tag");
2395 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2396 ut_params->ibuf, data_pad_len);
2398 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2400 TEST_HEXDUMP(stdout, "digest:",
2401 sym_op->auth.digest.data,
2404 /* Copy cipher and auth IVs at the end of the crypto operation */
2405 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2407 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2408 iv_ptr += cipher_iv_len;
2409 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2411 sym_op->cipher.data.length = cipher_len;
2412 sym_op->cipher.data.offset = cipher_offset;
2414 sym_op->auth.data.length = auth_len;
2415 sym_op->auth.data.offset = auth_offset;
2421 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2423 struct crypto_testsuite_params *ts_params = &testsuite_params;
2424 struct crypto_unittest_params *ut_params = &unittest_params;
2427 unsigned plaintext_pad_len;
2428 unsigned plaintext_len;
2431 /* Create SNOW 3G session */
2432 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2433 tdata->key.data, tdata->key.len,
2434 tdata->auth_iv.len, tdata->digest.len,
2435 RTE_CRYPTO_AUTH_OP_GENERATE,
2436 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2440 /* alloc mbuf and set payload */
2441 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2443 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2444 rte_pktmbuf_tailroom(ut_params->ibuf));
2446 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2447 /* Append data which is padded to a multiple of */
2448 /* the algorithms block size */
2449 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2450 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2452 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2454 /* Create SNOW 3G operation */
2455 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2456 tdata->auth_iv.data, tdata->auth_iv.len,
2457 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2458 tdata->validAuthLenInBits.len,
2463 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2465 ut_params->obuf = ut_params->op->sym->m_src;
2466 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2467 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2468 + plaintext_pad_len;
2471 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2474 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2475 "SNOW 3G Generated auth tag not as expected");
2481 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2483 struct crypto_testsuite_params *ts_params = &testsuite_params;
2484 struct crypto_unittest_params *ut_params = &unittest_params;
2487 unsigned plaintext_pad_len;
2488 unsigned plaintext_len;
2491 /* Create SNOW 3G session */
2492 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2493 tdata->key.data, tdata->key.len,
2494 tdata->auth_iv.len, tdata->digest.len,
2495 RTE_CRYPTO_AUTH_OP_VERIFY,
2496 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2499 /* alloc mbuf and set payload */
2500 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2502 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2503 rte_pktmbuf_tailroom(ut_params->ibuf));
2505 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2506 /* Append data which is padded to a multiple of */
2507 /* the algorithms block size */
2508 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2509 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2511 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2513 /* Create SNOW 3G operation */
2514 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2516 tdata->auth_iv.data, tdata->auth_iv.len,
2518 RTE_CRYPTO_AUTH_OP_VERIFY,
2519 tdata->validAuthLenInBits.len,
2524 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2526 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2527 ut_params->obuf = ut_params->op->sym->m_src;
2528 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2529 + plaintext_pad_len;
2532 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2541 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2543 struct crypto_testsuite_params *ts_params = &testsuite_params;
2544 struct crypto_unittest_params *ut_params = &unittest_params;
2547 unsigned plaintext_pad_len;
2548 unsigned plaintext_len;
2551 /* Create KASUMI session */
2552 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2553 tdata->key.data, tdata->key.len,
2554 0, tdata->digest.len,
2555 RTE_CRYPTO_AUTH_OP_GENERATE,
2556 RTE_CRYPTO_AUTH_KASUMI_F9);
2560 /* alloc mbuf and set payload */
2561 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2563 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2564 rte_pktmbuf_tailroom(ut_params->ibuf));
2566 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2567 /* Append data which is padded to a multiple of */
2568 /* the algorithms block size */
2569 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2570 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2572 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2574 /* Create KASUMI operation */
2575 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2577 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2578 tdata->plaintext.len,
2583 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2585 ut_params->obuf = ut_params->op->sym->m_src;
2586 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2587 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2588 + plaintext_pad_len;
2591 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2594 DIGEST_BYTE_LENGTH_KASUMI_F9,
2595 "KASUMI Generated auth tag not as expected");
2601 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2603 struct crypto_testsuite_params *ts_params = &testsuite_params;
2604 struct crypto_unittest_params *ut_params = &unittest_params;
2607 unsigned plaintext_pad_len;
2608 unsigned plaintext_len;
2611 /* Create KASUMI session */
2612 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2613 tdata->key.data, tdata->key.len,
2614 0, tdata->digest.len,
2615 RTE_CRYPTO_AUTH_OP_VERIFY,
2616 RTE_CRYPTO_AUTH_KASUMI_F9);
2619 /* alloc mbuf and set payload */
2620 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2622 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2623 rte_pktmbuf_tailroom(ut_params->ibuf));
2625 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2626 /* Append data which is padded to a multiple */
2627 /* of the algorithms block size */
2628 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2629 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2631 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2633 /* Create KASUMI operation */
2634 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2638 RTE_CRYPTO_AUTH_OP_VERIFY,
2639 tdata->plaintext.len,
2644 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2646 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2647 ut_params->obuf = ut_params->op->sym->m_src;
2648 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2649 + plaintext_pad_len;
2652 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2661 test_snow3g_hash_generate_test_case_1(void)
2663 return test_snow3g_authentication(&snow3g_hash_test_case_1);
2667 test_snow3g_hash_generate_test_case_2(void)
2669 return test_snow3g_authentication(&snow3g_hash_test_case_2);
2673 test_snow3g_hash_generate_test_case_3(void)
2675 return test_snow3g_authentication(&snow3g_hash_test_case_3);
2679 test_snow3g_hash_generate_test_case_4(void)
2681 return test_snow3g_authentication(&snow3g_hash_test_case_4);
2685 test_snow3g_hash_generate_test_case_5(void)
2687 return test_snow3g_authentication(&snow3g_hash_test_case_5);
2691 test_snow3g_hash_generate_test_case_6(void)
2693 return test_snow3g_authentication(&snow3g_hash_test_case_6);
2697 test_snow3g_hash_verify_test_case_1(void)
2699 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2704 test_snow3g_hash_verify_test_case_2(void)
2706 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2710 test_snow3g_hash_verify_test_case_3(void)
2712 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2716 test_snow3g_hash_verify_test_case_4(void)
2718 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2722 test_snow3g_hash_verify_test_case_5(void)
2724 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2728 test_snow3g_hash_verify_test_case_6(void)
2730 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2734 test_kasumi_hash_generate_test_case_1(void)
2736 return test_kasumi_authentication(&kasumi_hash_test_case_1);
2740 test_kasumi_hash_generate_test_case_2(void)
2742 return test_kasumi_authentication(&kasumi_hash_test_case_2);
2746 test_kasumi_hash_generate_test_case_3(void)
2748 return test_kasumi_authentication(&kasumi_hash_test_case_3);
2752 test_kasumi_hash_generate_test_case_4(void)
2754 return test_kasumi_authentication(&kasumi_hash_test_case_4);
2758 test_kasumi_hash_generate_test_case_5(void)
2760 return test_kasumi_authentication(&kasumi_hash_test_case_5);
2764 test_kasumi_hash_generate_test_case_6(void)
2766 return test_kasumi_authentication(&kasumi_hash_test_case_6);
2770 test_kasumi_hash_verify_test_case_1(void)
2772 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2776 test_kasumi_hash_verify_test_case_2(void)
2778 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2782 test_kasumi_hash_verify_test_case_3(void)
2784 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2788 test_kasumi_hash_verify_test_case_4(void)
2790 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2794 test_kasumi_hash_verify_test_case_5(void)
2796 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2800 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2802 struct crypto_testsuite_params *ts_params = &testsuite_params;
2803 struct crypto_unittest_params *ut_params = &unittest_params;
2806 uint8_t *plaintext, *ciphertext;
2807 unsigned plaintext_pad_len;
2808 unsigned plaintext_len;
2810 /* Create KASUMI session */
2811 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2812 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2813 RTE_CRYPTO_CIPHER_KASUMI_F8,
2814 tdata->key.data, tdata->key.len,
2815 tdata->cipher_iv.len);
2819 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2821 /* Clear mbuf payload */
2822 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2823 rte_pktmbuf_tailroom(ut_params->ibuf));
2825 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2826 /* Append data which is padded to a multiple */
2827 /* of the algorithms block size */
2828 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2829 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2831 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2833 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2835 /* Create KASUMI operation */
2836 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
2837 tdata->cipher_iv.len,
2838 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2839 tdata->validCipherOffsetInBits.len);
2843 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2845 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2847 ut_params->obuf = ut_params->op->sym->m_dst;
2848 if (ut_params->obuf)
2849 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
2851 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
2853 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2855 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
2856 (tdata->validCipherOffsetInBits.len >> 3);
2858 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2860 reference_ciphertext,
2861 tdata->validCipherLenInBits.len,
2862 "KASUMI Ciphertext data not as expected");
2867 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2869 struct crypto_testsuite_params *ts_params = &testsuite_params;
2870 struct crypto_unittest_params *ut_params = &unittest_params;
2874 unsigned int plaintext_pad_len;
2875 unsigned int plaintext_len;
2877 uint8_t buffer[10000];
2878 const uint8_t *ciphertext;
2880 struct rte_cryptodev_info dev_info;
2882 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2883 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
2884 printf("Device doesn't support scatter-gather. "
2889 /* Create KASUMI session */
2890 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2891 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2892 RTE_CRYPTO_CIPHER_KASUMI_F8,
2893 tdata->key.data, tdata->key.len,
2894 tdata->cipher_iv.len);
2898 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2901 /* Append data which is padded to a multiple */
2902 /* of the algorithms block size */
2903 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2905 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2906 plaintext_pad_len, 10, 0);
2908 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2910 /* Create KASUMI operation */
2911 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
2912 tdata->cipher_iv.len,
2913 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2914 tdata->validCipherOffsetInBits.len);
2918 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2920 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2922 ut_params->obuf = ut_params->op->sym->m_dst;
2924 if (ut_params->obuf)
2925 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
2926 plaintext_len, buffer);
2928 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
2929 tdata->validCipherOffsetInBits.len >> 3,
2930 plaintext_len, buffer);
2933 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2935 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
2936 (tdata->validCipherOffsetInBits.len >> 3);
2938 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2940 reference_ciphertext,
2941 tdata->validCipherLenInBits.len,
2942 "KASUMI Ciphertext data not as expected");
2947 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2949 struct crypto_testsuite_params *ts_params = &testsuite_params;
2950 struct crypto_unittest_params *ut_params = &unittest_params;
2953 uint8_t *plaintext, *ciphertext;
2954 unsigned plaintext_pad_len;
2955 unsigned plaintext_len;
2957 /* Create KASUMI session */
2958 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2959 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2960 RTE_CRYPTO_CIPHER_KASUMI_F8,
2961 tdata->key.data, tdata->key.len,
2962 tdata->cipher_iv.len);
2966 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2967 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2969 /* Clear mbuf payload */
2970 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2971 rte_pktmbuf_tailroom(ut_params->ibuf));
2973 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2974 /* Append data which is padded to a multiple */
2975 /* of the algorithms block size */
2976 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2977 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2979 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2980 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2982 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2984 /* Create KASUMI operation */
2985 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
2986 tdata->cipher_iv.len,
2987 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2988 tdata->validCipherOffsetInBits.len);
2992 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2994 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2996 ut_params->obuf = ut_params->op->sym->m_dst;
2997 if (ut_params->obuf)
2998 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3000 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3002 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3004 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3005 (tdata->validCipherOffsetInBits.len >> 3);
3007 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3009 reference_ciphertext,
3010 tdata->validCipherLenInBits.len,
3011 "KASUMI Ciphertext data not as expected");
3016 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3018 struct crypto_testsuite_params *ts_params = &testsuite_params;
3019 struct crypto_unittest_params *ut_params = &unittest_params;
3022 unsigned int plaintext_pad_len;
3023 unsigned int plaintext_len;
3025 const uint8_t *ciphertext;
3026 uint8_t buffer[2048];
3028 struct rte_cryptodev_info dev_info;
3030 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3031 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3032 printf("Device doesn't support scatter-gather. "
3037 /* Create KASUMI session */
3038 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3039 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3040 RTE_CRYPTO_CIPHER_KASUMI_F8,
3041 tdata->key.data, tdata->key.len,
3042 tdata->cipher_iv.len);
3046 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3047 /* Append data which is padded to a multiple */
3048 /* of the algorithms block size */
3049 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3051 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3052 plaintext_pad_len, 10, 0);
3053 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3054 plaintext_pad_len, 3, 0);
3056 /* Append data which is padded to a multiple */
3057 /* of the algorithms block size */
3058 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3060 /* Create KASUMI operation */
3061 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3062 tdata->cipher_iv.len,
3063 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3064 tdata->validCipherOffsetInBits.len);
3068 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3070 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3072 ut_params->obuf = ut_params->op->sym->m_dst;
3073 if (ut_params->obuf)
3074 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3075 plaintext_pad_len, buffer);
3077 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3078 tdata->validCipherOffsetInBits.len >> 3,
3079 plaintext_pad_len, buffer);
3081 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3082 (tdata->validCipherOffsetInBits.len >> 3);
3084 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3086 reference_ciphertext,
3087 tdata->validCipherLenInBits.len,
3088 "KASUMI Ciphertext data not as expected");
3094 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3096 struct crypto_testsuite_params *ts_params = &testsuite_params;
3097 struct crypto_unittest_params *ut_params = &unittest_params;
3100 uint8_t *ciphertext, *plaintext;
3101 unsigned ciphertext_pad_len;
3102 unsigned ciphertext_len;
3104 /* Create KASUMI session */
3105 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3106 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3107 RTE_CRYPTO_CIPHER_KASUMI_F8,
3108 tdata->key.data, tdata->key.len,
3109 tdata->cipher_iv.len);
3113 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3114 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3116 /* Clear mbuf payload */
3117 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3118 rte_pktmbuf_tailroom(ut_params->ibuf));
3120 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3121 /* Append data which is padded to a multiple */
3122 /* of the algorithms block size */
3123 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3124 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3125 ciphertext_pad_len);
3126 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3127 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3129 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3131 /* Create KASUMI operation */
3132 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3133 tdata->cipher_iv.len,
3134 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3135 tdata->validCipherOffsetInBits.len);
3139 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3141 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3143 ut_params->obuf = ut_params->op->sym->m_dst;
3144 if (ut_params->obuf)
3145 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3147 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3149 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3151 const uint8_t *reference_plaintext = tdata->plaintext.data +
3152 (tdata->validCipherOffsetInBits.len >> 3);
3154 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3156 reference_plaintext,
3157 tdata->validCipherLenInBits.len,
3158 "KASUMI Plaintext data not as expected");
3163 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3165 struct crypto_testsuite_params *ts_params = &testsuite_params;
3166 struct crypto_unittest_params *ut_params = &unittest_params;
3169 uint8_t *ciphertext, *plaintext;
3170 unsigned ciphertext_pad_len;
3171 unsigned ciphertext_len;
3173 /* Create KASUMI session */
3174 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3175 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3176 RTE_CRYPTO_CIPHER_KASUMI_F8,
3177 tdata->key.data, tdata->key.len,
3178 tdata->cipher_iv.len);
3182 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3184 /* Clear mbuf payload */
3185 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3186 rte_pktmbuf_tailroom(ut_params->ibuf));
3188 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3189 /* Append data which is padded to a multiple */
3190 /* of the algorithms block size */
3191 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3192 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3193 ciphertext_pad_len);
3194 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3196 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3198 /* Create KASUMI operation */
3199 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3200 tdata->cipher_iv.len,
3201 tdata->ciphertext.len,
3202 tdata->validCipherOffsetInBits.len);
3206 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3208 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3210 ut_params->obuf = ut_params->op->sym->m_dst;
3211 if (ut_params->obuf)
3212 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3214 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3216 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3218 const uint8_t *reference_plaintext = tdata->plaintext.data +
3219 (tdata->validCipherOffsetInBits.len >> 3);
3221 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3223 reference_plaintext,
3224 tdata->validCipherLenInBits.len,
3225 "KASUMI Plaintext data not as expected");
3230 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3232 struct crypto_testsuite_params *ts_params = &testsuite_params;
3233 struct crypto_unittest_params *ut_params = &unittest_params;
3236 uint8_t *plaintext, *ciphertext;
3237 unsigned plaintext_pad_len;
3238 unsigned plaintext_len;
3240 /* Create SNOW 3G session */
3241 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3242 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3243 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3244 tdata->key.data, tdata->key.len,
3245 tdata->cipher_iv.len);
3249 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3251 /* Clear mbuf payload */
3252 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3253 rte_pktmbuf_tailroom(ut_params->ibuf));
3255 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3256 /* Append data which is padded to a multiple of */
3257 /* the algorithms block size */
3258 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3259 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3261 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3263 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3265 /* Create SNOW 3G operation */
3266 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3267 tdata->cipher_iv.len,
3268 tdata->validCipherLenInBits.len,
3273 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3275 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3277 ut_params->obuf = ut_params->op->sym->m_dst;
3278 if (ut_params->obuf)
3279 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3281 ciphertext = plaintext;
3283 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3286 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3288 tdata->ciphertext.data,
3289 tdata->validDataLenInBits.len,
3290 "SNOW 3G Ciphertext data not as expected");
3296 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3298 struct crypto_testsuite_params *ts_params = &testsuite_params;
3299 struct crypto_unittest_params *ut_params = &unittest_params;
3300 uint8_t *plaintext, *ciphertext;
3303 unsigned plaintext_pad_len;
3304 unsigned plaintext_len;
3306 /* Create SNOW 3G session */
3307 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3308 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3309 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3310 tdata->key.data, tdata->key.len,
3311 tdata->cipher_iv.len);
3315 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3316 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3318 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3319 "Failed to allocate input buffer in mempool");
3320 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3321 "Failed to allocate output buffer in mempool");
3323 /* Clear mbuf payload */
3324 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3325 rte_pktmbuf_tailroom(ut_params->ibuf));
3327 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3328 /* Append data which is padded to a multiple of */
3329 /* the algorithms block size */
3330 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3331 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3333 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3334 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3336 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3338 /* Create SNOW 3G operation */
3339 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3340 tdata->cipher_iv.len,
3341 tdata->validCipherLenInBits.len,
3346 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3348 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3350 ut_params->obuf = ut_params->op->sym->m_dst;
3351 if (ut_params->obuf)
3352 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3354 ciphertext = plaintext;
3356 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3359 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3361 tdata->ciphertext.data,
3362 tdata->validDataLenInBits.len,
3363 "SNOW 3G Ciphertext data not as expected");
3368 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3370 struct crypto_testsuite_params *ts_params = &testsuite_params;
3371 struct crypto_unittest_params *ut_params = &unittest_params;
3374 unsigned int plaintext_pad_len;
3375 unsigned int plaintext_len;
3376 uint8_t buffer[10000];
3377 const uint8_t *ciphertext;
3379 struct rte_cryptodev_info dev_info;
3381 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3382 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3383 printf("Device doesn't support scatter-gather. "
3388 /* Create SNOW 3G session */
3389 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3390 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3391 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3392 tdata->key.data, tdata->key.len,
3393 tdata->cipher_iv.len);
3397 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3398 /* Append data which is padded to a multiple of */
3399 /* the algorithms block size */
3400 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3402 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3403 plaintext_pad_len, 10, 0);
3404 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3405 plaintext_pad_len, 3, 0);
3407 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3408 "Failed to allocate input buffer in mempool");
3409 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3410 "Failed to allocate output buffer in mempool");
3412 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3414 /* Create SNOW 3G operation */
3415 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3416 tdata->cipher_iv.len,
3417 tdata->validCipherLenInBits.len,
3422 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3424 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3426 ut_params->obuf = ut_params->op->sym->m_dst;
3427 if (ut_params->obuf)
3428 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3429 plaintext_len, buffer);
3431 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3432 plaintext_len, buffer);
3434 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3437 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3439 tdata->ciphertext.data,
3440 tdata->validDataLenInBits.len,
3441 "SNOW 3G Ciphertext data not as expected");
3446 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3448 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3450 uint8_t curr_byte, prev_byte;
3451 uint32_t length_in_bytes = ceil_byte_length(length + offset);
3452 uint8_t lower_byte_mask = (1 << offset) - 1;
3455 prev_byte = buffer[0];
3456 buffer[0] >>= offset;
3458 for (i = 1; i < length_in_bytes; i++) {
3459 curr_byte = buffer[i];
3460 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3461 (curr_byte >> offset);
3462 prev_byte = curr_byte;
3467 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3469 struct crypto_testsuite_params *ts_params = &testsuite_params;
3470 struct crypto_unittest_params *ut_params = &unittest_params;
3471 uint8_t *plaintext, *ciphertext;
3473 uint32_t plaintext_len;
3474 uint32_t plaintext_pad_len;
3475 uint8_t extra_offset = 4;
3476 uint8_t *expected_ciphertext_shifted;
3478 /* Create SNOW 3G session */
3479 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3480 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3481 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3482 tdata->key.data, tdata->key.len,
3483 tdata->cipher_iv.len);
3487 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3488 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3490 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3491 "Failed to allocate input buffer in mempool");
3492 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3493 "Failed to allocate output buffer in mempool");
3495 /* Clear mbuf payload */
3496 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3497 rte_pktmbuf_tailroom(ut_params->ibuf));
3499 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3501 * Append data which is padded to a
3502 * multiple of the algorithms block size
3504 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3506 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3509 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3511 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3512 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3514 #ifdef RTE_APP_TEST_DEBUG
3515 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3517 /* Create SNOW 3G operation */
3518 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3519 tdata->cipher_iv.len,
3520 tdata->validCipherLenInBits.len,
3525 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3527 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3529 ut_params->obuf = ut_params->op->sym->m_dst;
3530 if (ut_params->obuf)
3531 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3533 ciphertext = plaintext;
3535 #ifdef RTE_APP_TEST_DEBUG
3536 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3539 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3541 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3542 "failed to reserve memory for ciphertext shifted\n");
3544 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3545 ceil_byte_length(tdata->ciphertext.len));
3546 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3549 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3551 expected_ciphertext_shifted,
3552 tdata->validDataLenInBits.len,
3554 "SNOW 3G Ciphertext data not as expected");
3558 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3560 struct crypto_testsuite_params *ts_params = &testsuite_params;
3561 struct crypto_unittest_params *ut_params = &unittest_params;
3565 uint8_t *plaintext, *ciphertext;
3566 unsigned ciphertext_pad_len;
3567 unsigned ciphertext_len;
3569 /* Create SNOW 3G session */
3570 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3571 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3572 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3573 tdata->key.data, tdata->key.len,
3574 tdata->cipher_iv.len);
3578 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3580 /* Clear mbuf payload */
3581 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3582 rte_pktmbuf_tailroom(ut_params->ibuf));
3584 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3585 /* Append data which is padded to a multiple of */
3586 /* the algorithms block size */
3587 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3588 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3589 ciphertext_pad_len);
3590 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3592 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3594 /* Create SNOW 3G operation */
3595 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3596 tdata->cipher_iv.len,
3597 tdata->validCipherLenInBits.len,
3602 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3604 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3605 ut_params->obuf = ut_params->op->sym->m_dst;
3606 if (ut_params->obuf)
3607 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3609 plaintext = ciphertext;
3611 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3614 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3615 tdata->plaintext.data,
3616 tdata->validDataLenInBits.len,
3617 "SNOW 3G Plaintext data not as expected");
3621 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3623 struct crypto_testsuite_params *ts_params = &testsuite_params;
3624 struct crypto_unittest_params *ut_params = &unittest_params;
3628 uint8_t *plaintext, *ciphertext;
3629 unsigned ciphertext_pad_len;
3630 unsigned ciphertext_len;
3632 /* Create SNOW 3G session */
3633 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3634 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3635 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3636 tdata->key.data, tdata->key.len,
3637 tdata->cipher_iv.len);
3641 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3642 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3644 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3645 "Failed to allocate input buffer");
3646 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3647 "Failed to allocate output buffer");
3649 /* Clear mbuf payload */
3650 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3651 rte_pktmbuf_tailroom(ut_params->ibuf));
3653 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3654 rte_pktmbuf_tailroom(ut_params->obuf));
3656 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3657 /* Append data which is padded to a multiple of */
3658 /* the algorithms block size */
3659 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3660 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3661 ciphertext_pad_len);
3662 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3663 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3665 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3667 /* Create SNOW 3G operation */
3668 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3669 tdata->cipher_iv.len,
3670 tdata->validCipherLenInBits.len,
3675 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3677 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3678 ut_params->obuf = ut_params->op->sym->m_dst;
3679 if (ut_params->obuf)
3680 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3682 plaintext = ciphertext;
3684 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3687 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3688 tdata->plaintext.data,
3689 tdata->validDataLenInBits.len,
3690 "SNOW 3G Plaintext data not as expected");
3695 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
3697 struct crypto_testsuite_params *ts_params = &testsuite_params;
3698 struct crypto_unittest_params *ut_params = &unittest_params;
3702 uint8_t *plaintext, *ciphertext;
3703 unsigned int plaintext_pad_len;
3704 unsigned int plaintext_len;
3706 struct rte_cryptodev_sym_capability_idx cap_idx;
3708 /* Check if device supports ZUC EEA3 */
3709 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3710 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
3712 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3716 /* Check if device supports ZUC EIA3 */
3717 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3718 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
3720 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3724 /* Create ZUC session */
3725 retval = create_zuc_cipher_auth_encrypt_generate_session(
3726 ts_params->valid_devs[0],
3730 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3732 /* clear mbuf payload */
3733 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3734 rte_pktmbuf_tailroom(ut_params->ibuf));
3736 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3737 /* Append data which is padded to a multiple of */
3738 /* the algorithms block size */
3739 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3740 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3742 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3744 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3746 /* Create ZUC operation */
3747 retval = create_zuc_cipher_hash_generate_operation(tdata);
3751 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3753 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3754 ut_params->obuf = ut_params->op->sym->m_src;
3755 if (ut_params->obuf)
3756 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3758 ciphertext = plaintext;
3760 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3762 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3764 tdata->ciphertext.data,
3765 tdata->validDataLenInBits.len,
3766 "ZUC Ciphertext data not as expected");
3768 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3769 + plaintext_pad_len;
3772 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3776 "ZUC Generated auth tag not as expected");
3781 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3783 struct crypto_testsuite_params *ts_params = &testsuite_params;
3784 struct crypto_unittest_params *ut_params = &unittest_params;
3788 uint8_t *plaintext, *ciphertext;
3789 unsigned plaintext_pad_len;
3790 unsigned plaintext_len;
3792 /* Create SNOW 3G session */
3793 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3794 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3795 RTE_CRYPTO_AUTH_OP_GENERATE,
3796 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3797 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3798 tdata->key.data, tdata->key.len,
3799 tdata->auth_iv.len, tdata->digest.len,
3800 tdata->cipher_iv.len);
3803 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3805 /* clear mbuf payload */
3806 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3807 rte_pktmbuf_tailroom(ut_params->ibuf));
3809 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3810 /* Append data which is padded to a multiple of */
3811 /* the algorithms block size */
3812 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3813 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3815 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3817 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3819 /* Create SNOW 3G operation */
3820 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3821 tdata->digest.len, tdata->auth_iv.data,
3823 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3824 tdata->cipher_iv.data, tdata->cipher_iv.len,
3825 tdata->validCipherLenInBits.len,
3827 tdata->validAuthLenInBits.len,
3833 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3835 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3836 ut_params->obuf = ut_params->op->sym->m_src;
3837 if (ut_params->obuf)
3838 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3840 ciphertext = plaintext;
3842 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3844 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3846 tdata->ciphertext.data,
3847 tdata->validDataLenInBits.len,
3848 "SNOW 3G Ciphertext data not as expected");
3850 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3851 + plaintext_pad_len;
3854 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3857 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3858 "SNOW 3G Generated auth tag not as expected");
3862 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3864 struct crypto_testsuite_params *ts_params = &testsuite_params;
3865 struct crypto_unittest_params *ut_params = &unittest_params;
3869 uint8_t *plaintext, *ciphertext;
3870 unsigned plaintext_pad_len;
3871 unsigned plaintext_len;
3873 /* Create SNOW 3G session */
3874 retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3875 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3876 RTE_CRYPTO_AUTH_OP_GENERATE,
3877 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3878 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3879 tdata->key.data, tdata->key.len,
3880 tdata->auth_iv.len, tdata->digest.len,
3881 tdata->cipher_iv.len);
3885 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3887 /* clear mbuf payload */
3888 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3889 rte_pktmbuf_tailroom(ut_params->ibuf));
3891 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3892 /* Append data which is padded to a multiple of */
3893 /* the algorithms block size */
3894 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3895 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3897 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3899 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3901 /* Create SNOW 3G operation */
3902 retval = create_wireless_algo_auth_cipher_operation(
3904 tdata->cipher_iv.data, tdata->cipher_iv.len,
3905 tdata->auth_iv.data, tdata->auth_iv.len,
3907 tdata->validCipherLenInBits.len,
3909 tdata->validAuthLenInBits.len,
3915 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3917 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3918 ut_params->obuf = ut_params->op->sym->m_src;
3919 if (ut_params->obuf)
3920 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3922 ciphertext = plaintext;
3924 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3925 + plaintext_pad_len;
3926 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3929 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3931 tdata->ciphertext.data,
3932 tdata->validDataLenInBits.len,
3933 "SNOW 3G Ciphertext data not as expected");
3936 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3939 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3940 "SNOW 3G Generated auth tag not as expected");
3945 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3947 struct crypto_testsuite_params *ts_params = &testsuite_params;
3948 struct crypto_unittest_params *ut_params = &unittest_params;
3952 uint8_t *plaintext, *ciphertext;
3953 unsigned plaintext_pad_len;
3954 unsigned plaintext_len;
3956 /* Create KASUMI session */
3957 retval = create_wireless_algo_auth_cipher_session(
3958 ts_params->valid_devs[0],
3959 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3960 RTE_CRYPTO_AUTH_OP_GENERATE,
3961 RTE_CRYPTO_AUTH_KASUMI_F9,
3962 RTE_CRYPTO_CIPHER_KASUMI_F8,
3963 tdata->key.data, tdata->key.len,
3964 0, tdata->digest.len,
3965 tdata->cipher_iv.len);
3968 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3970 /* clear mbuf payload */
3971 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3972 rte_pktmbuf_tailroom(ut_params->ibuf));
3974 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3975 /* Append data which is padded to a multiple of */
3976 /* the algorithms block size */
3977 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3978 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3980 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3982 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3984 /* Create KASUMI operation */
3985 retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
3986 tdata->cipher_iv.data, tdata->cipher_iv.len,
3989 tdata->validCipherLenInBits.len,
3990 tdata->validCipherOffsetInBits.len,
3991 tdata->validAuthLenInBits.len,
3998 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4000 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4001 if (ut_params->op->sym->m_dst)
4002 ut_params->obuf = ut_params->op->sym->m_dst;
4004 ut_params->obuf = ut_params->op->sym->m_src;
4006 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4007 tdata->validCipherOffsetInBits.len >> 3);
4009 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4010 (tdata->validCipherOffsetInBits.len >> 3);
4012 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4014 reference_ciphertext,
4015 tdata->validCipherLenInBits.len,
4016 "KASUMI Ciphertext data not as expected");
4017 ut_params->digest = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *)
4018 + plaintext_pad_len;
4021 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4024 DIGEST_BYTE_LENGTH_KASUMI_F9,
4025 "KASUMI Generated auth tag not as expected");
4030 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4032 struct crypto_testsuite_params *ts_params = &testsuite_params;
4033 struct crypto_unittest_params *ut_params = &unittest_params;
4037 uint8_t *plaintext, *ciphertext;
4038 unsigned plaintext_pad_len;
4039 unsigned plaintext_len;
4041 /* Create KASUMI session */
4042 retval = create_wireless_algo_cipher_auth_session(
4043 ts_params->valid_devs[0],
4044 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4045 RTE_CRYPTO_AUTH_OP_GENERATE,
4046 RTE_CRYPTO_AUTH_KASUMI_F9,
4047 RTE_CRYPTO_CIPHER_KASUMI_F8,
4048 tdata->key.data, tdata->key.len,
4049 0, tdata->digest.len,
4050 tdata->cipher_iv.len);
4054 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4056 /* clear mbuf payload */
4057 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4058 rte_pktmbuf_tailroom(ut_params->ibuf));
4060 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4061 /* Append data which is padded to a multiple of */
4062 /* the algorithms block size */
4063 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4064 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4066 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4068 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4070 /* Create KASUMI operation */
4071 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4072 tdata->digest.len, NULL, 0,
4073 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4074 tdata->cipher_iv.data, tdata->cipher_iv.len,
4075 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4076 tdata->validCipherOffsetInBits.len,
4077 tdata->validAuthLenInBits.len,
4083 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4085 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4087 if (ut_params->op->sym->m_dst)
4088 ut_params->obuf = ut_params->op->sym->m_dst;
4090 ut_params->obuf = ut_params->op->sym->m_src;
4092 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4093 tdata->validCipherOffsetInBits.len >> 3);
4095 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4096 + plaintext_pad_len;
4098 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4099 (tdata->validCipherOffsetInBits.len >> 3);
4101 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4103 reference_ciphertext,
4104 tdata->validCipherLenInBits.len,
4105 "KASUMI Ciphertext data not as expected");
4108 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4111 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4112 "KASUMI Generated auth tag not as expected");
4117 test_zuc_encryption(const struct wireless_test_data *tdata)
4119 struct crypto_testsuite_params *ts_params = &testsuite_params;
4120 struct crypto_unittest_params *ut_params = &unittest_params;
4123 uint8_t *plaintext, *ciphertext;
4124 unsigned plaintext_pad_len;
4125 unsigned plaintext_len;
4127 struct rte_cryptodev_sym_capability_idx cap_idx;
4129 /* Check if device supports ZUC EEA3 */
4130 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4131 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4133 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4137 /* Create ZUC session */
4138 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4139 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4140 RTE_CRYPTO_CIPHER_ZUC_EEA3,
4141 tdata->key.data, tdata->key.len,
4142 tdata->cipher_iv.len);
4146 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4148 /* Clear mbuf payload */
4149 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4150 rte_pktmbuf_tailroom(ut_params->ibuf));
4152 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4153 /* Append data which is padded to a multiple */
4154 /* of the algorithms block size */
4155 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4156 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4158 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4160 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4162 /* Create ZUC operation */
4163 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4164 tdata->cipher_iv.len,
4165 tdata->plaintext.len,
4170 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4172 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4174 ut_params->obuf = ut_params->op->sym->m_dst;
4175 if (ut_params->obuf)
4176 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4178 ciphertext = plaintext;
4180 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4183 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4185 tdata->ciphertext.data,
4186 tdata->validCipherLenInBits.len,
4187 "ZUC Ciphertext data not as expected");
4192 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4194 struct crypto_testsuite_params *ts_params = &testsuite_params;
4195 struct crypto_unittest_params *ut_params = &unittest_params;
4199 unsigned int plaintext_pad_len;
4200 unsigned int plaintext_len;
4201 const uint8_t *ciphertext;
4202 uint8_t ciphertext_buffer[2048];
4203 struct rte_cryptodev_info dev_info;
4205 struct rte_cryptodev_sym_capability_idx cap_idx;
4207 /* Check if device supports ZUC EEA3 */
4208 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4209 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4211 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4215 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4216 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
4217 printf("Device doesn't support scatter-gather. "
4222 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4224 /* Append data which is padded to a multiple */
4225 /* of the algorithms block size */
4226 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4228 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4229 plaintext_pad_len, 10, 0);
4231 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4232 tdata->plaintext.data);
4234 /* Create ZUC session */
4235 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4236 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4237 RTE_CRYPTO_CIPHER_ZUC_EEA3,
4238 tdata->key.data, tdata->key.len,
4239 tdata->cipher_iv.len);
4243 /* Clear mbuf payload */
4245 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4247 /* Create ZUC operation */
4248 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4249 tdata->cipher_iv.len, tdata->plaintext.len,
4254 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4256 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4258 ut_params->obuf = ut_params->op->sym->m_dst;
4259 if (ut_params->obuf)
4260 ciphertext = rte_pktmbuf_read(ut_params->obuf,
4261 0, plaintext_len, ciphertext_buffer);
4263 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
4264 0, plaintext_len, ciphertext_buffer);
4267 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4270 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4272 tdata->ciphertext.data,
4273 tdata->validCipherLenInBits.len,
4274 "ZUC Ciphertext data not as expected");
4280 test_zuc_authentication(const struct wireless_test_data *tdata)
4282 struct crypto_testsuite_params *ts_params = &testsuite_params;
4283 struct crypto_unittest_params *ut_params = &unittest_params;
4286 unsigned plaintext_pad_len;
4287 unsigned plaintext_len;
4290 struct rte_cryptodev_sym_capability_idx cap_idx;
4292 /* Check if device supports ZUC EIA3 */
4293 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4294 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4296 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4300 /* Create ZUC session */
4301 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
4302 tdata->key.data, tdata->key.len,
4303 tdata->auth_iv.len, tdata->digest.len,
4304 RTE_CRYPTO_AUTH_OP_GENERATE,
4305 RTE_CRYPTO_AUTH_ZUC_EIA3);
4309 /* alloc mbuf and set payload */
4310 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4312 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4313 rte_pktmbuf_tailroom(ut_params->ibuf));
4315 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4316 /* Append data which is padded to a multiple of */
4317 /* the algorithms block size */
4318 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4319 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4321 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4323 /* Create ZUC operation */
4324 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
4325 tdata->auth_iv.data, tdata->auth_iv.len,
4326 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4327 tdata->validAuthLenInBits.len,
4332 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4334 ut_params->obuf = ut_params->op->sym->m_src;
4335 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4336 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4337 + plaintext_pad_len;
4340 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4343 DIGEST_BYTE_LENGTH_KASUMI_F9,
4344 "ZUC Generated auth tag not as expected");
4350 test_kasumi_encryption_test_case_1(void)
4352 return test_kasumi_encryption(&kasumi_test_case_1);
4356 test_kasumi_encryption_test_case_1_sgl(void)
4358 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
4362 test_kasumi_encryption_test_case_1_oop(void)
4364 return test_kasumi_encryption_oop(&kasumi_test_case_1);
4368 test_kasumi_encryption_test_case_1_oop_sgl(void)
4370 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
4374 test_kasumi_encryption_test_case_2(void)
4376 return test_kasumi_encryption(&kasumi_test_case_2);
4380 test_kasumi_encryption_test_case_3(void)
4382 return test_kasumi_encryption(&kasumi_test_case_3);
4386 test_kasumi_encryption_test_case_4(void)
4388 return test_kasumi_encryption(&kasumi_test_case_4);
4392 test_kasumi_encryption_test_case_5(void)
4394 return test_kasumi_encryption(&kasumi_test_case_5);
4398 test_kasumi_decryption_test_case_1(void)
4400 return test_kasumi_decryption(&kasumi_test_case_1);
4404 test_kasumi_decryption_test_case_1_oop(void)
4406 return test_kasumi_decryption_oop(&kasumi_test_case_1);
4410 test_kasumi_decryption_test_case_2(void)
4412 return test_kasumi_decryption(&kasumi_test_case_2);
4416 test_kasumi_decryption_test_case_3(void)
4418 return test_kasumi_decryption(&kasumi_test_case_3);
4422 test_kasumi_decryption_test_case_4(void)
4424 return test_kasumi_decryption(&kasumi_test_case_4);
4428 test_kasumi_decryption_test_case_5(void)
4430 return test_kasumi_decryption(&kasumi_test_case_5);
4433 test_snow3g_encryption_test_case_1(void)
4435 return test_snow3g_encryption(&snow3g_test_case_1);
4439 test_snow3g_encryption_test_case_1_oop(void)
4441 return test_snow3g_encryption_oop(&snow3g_test_case_1);
4445 test_snow3g_encryption_test_case_1_oop_sgl(void)
4447 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
4452 test_snow3g_encryption_test_case_1_offset_oop(void)
4454 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
4458 test_snow3g_encryption_test_case_2(void)
4460 return test_snow3g_encryption(&snow3g_test_case_2);
4464 test_snow3g_encryption_test_case_3(void)
4466 return test_snow3g_encryption(&snow3g_test_case_3);
4470 test_snow3g_encryption_test_case_4(void)
4472 return test_snow3g_encryption(&snow3g_test_case_4);
4476 test_snow3g_encryption_test_case_5(void)
4478 return test_snow3g_encryption(&snow3g_test_case_5);
4482 test_snow3g_decryption_test_case_1(void)
4484 return test_snow3g_decryption(&snow3g_test_case_1);
4488 test_snow3g_decryption_test_case_1_oop(void)
4490 return test_snow3g_decryption_oop(&snow3g_test_case_1);
4494 test_snow3g_decryption_test_case_2(void)
4496 return test_snow3g_decryption(&snow3g_test_case_2);
4500 test_snow3g_decryption_test_case_3(void)
4502 return test_snow3g_decryption(&snow3g_test_case_3);
4506 test_snow3g_decryption_test_case_4(void)
4508 return test_snow3g_decryption(&snow3g_test_case_4);
4512 test_snow3g_decryption_test_case_5(void)
4514 return test_snow3g_decryption(&snow3g_test_case_5);
4517 test_snow3g_cipher_auth_test_case_1(void)
4519 return test_snow3g_cipher_auth(&snow3g_test_case_3);
4523 test_snow3g_auth_cipher_test_case_1(void)
4525 return test_snow3g_auth_cipher(&snow3g_test_case_6);
4529 test_kasumi_auth_cipher_test_case_1(void)
4531 return test_kasumi_auth_cipher(&kasumi_test_case_3);
4535 test_kasumi_cipher_auth_test_case_1(void)
4537 return test_kasumi_cipher_auth(&kasumi_test_case_6);
4541 test_zuc_encryption_test_case_1(void)
4543 return test_zuc_encryption(&zuc_test_case_cipher_193b);
4547 test_zuc_encryption_test_case_2(void)
4549 return test_zuc_encryption(&zuc_test_case_cipher_800b);
4553 test_zuc_encryption_test_case_3(void)
4555 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
4559 test_zuc_encryption_test_case_4(void)
4561 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
4565 test_zuc_encryption_test_case_5(void)
4567 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
4571 test_zuc_encryption_test_case_6_sgl(void)
4573 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
4577 test_zuc_hash_generate_test_case_1(void)
4579 return test_zuc_authentication(&zuc_test_case_auth_1b);
4583 test_zuc_hash_generate_test_case_2(void)
4585 return test_zuc_authentication(&zuc_test_case_auth_90b);
4589 test_zuc_hash_generate_test_case_3(void)
4591 return test_zuc_authentication(&zuc_test_case_auth_577b);
4595 test_zuc_hash_generate_test_case_4(void)
4597 return test_zuc_authentication(&zuc_test_case_auth_2079b);
4601 test_zuc_hash_generate_test_case_5(void)
4603 return test_zuc_authentication(&zuc_test_auth_5670b);
4607 test_zuc_hash_generate_test_case_6(void)
4609 return test_zuc_authentication(&zuc_test_case_auth_128b);
4613 test_zuc_hash_generate_test_case_7(void)
4615 return test_zuc_authentication(&zuc_test_case_auth_2080b);
4619 test_zuc_hash_generate_test_case_8(void)
4621 return test_zuc_authentication(&zuc_test_case_auth_584b);
4625 test_zuc_cipher_auth_test_case_1(void)
4627 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
4631 test_zuc_cipher_auth_test_case_2(void)
4633 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
4637 test_3DES_chain_qat_all(void)
4639 struct crypto_testsuite_params *ts_params = &testsuite_params;
4642 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4643 ts_params->op_mpool,
4644 ts_params->session_mpool,
4645 ts_params->valid_devs[0],
4646 rte_cryptodev_driver_id_get(
4647 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
4648 BLKCIPHER_3DES_CHAIN_TYPE);
4650 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4652 return TEST_SUCCESS;
4656 test_DES_cipheronly_qat_all(void)
4658 struct crypto_testsuite_params *ts_params = &testsuite_params;
4661 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4662 ts_params->op_mpool,
4663 ts_params->session_mpool,
4664 ts_params->valid_devs[0],
4665 rte_cryptodev_driver_id_get(
4666 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
4667 BLKCIPHER_DES_CIPHERONLY_TYPE);
4669 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4671 return TEST_SUCCESS;
4675 test_DES_docsis_openssl_all(void)
4677 struct crypto_testsuite_params *ts_params = &testsuite_params;
4680 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4681 ts_params->op_mpool,
4682 ts_params->session_mpool,
4683 ts_params->valid_devs[0],
4684 rte_cryptodev_driver_id_get(
4685 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
4686 BLKCIPHER_DES_DOCSIS_TYPE);
4688 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4690 return TEST_SUCCESS;
4694 test_DES_cipheronly_mb_all(void)
4696 struct crypto_testsuite_params *ts_params = &testsuite_params;
4699 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4700 ts_params->op_mpool,
4701 ts_params->session_mpool,
4702 ts_params->valid_devs[0],
4703 rte_cryptodev_driver_id_get(
4704 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
4705 BLKCIPHER_DES_CIPHERONLY_TYPE);
4707 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4709 return TEST_SUCCESS;
4713 test_DES_docsis_mb_all(void)
4715 struct crypto_testsuite_params *ts_params = &testsuite_params;
4718 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4719 ts_params->op_mpool,
4720 ts_params->session_mpool,
4721 ts_params->valid_devs[0],
4722 rte_cryptodev_driver_id_get(
4723 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
4724 BLKCIPHER_DES_DOCSIS_TYPE);
4726 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4728 return TEST_SUCCESS;
4732 test_3DES_chain_dpaa2_sec_all(void)
4734 struct crypto_testsuite_params *ts_params = &testsuite_params;
4737 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4738 ts_params->op_mpool,
4739 ts_params->session_mpool,
4740 ts_params->valid_devs[0],
4741 rte_cryptodev_driver_id_get(
4742 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
4743 BLKCIPHER_3DES_CHAIN_TYPE);
4745 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4747 return TEST_SUCCESS;
4751 test_3DES_cipheronly_dpaa2_sec_all(void)
4753 struct crypto_testsuite_params *ts_params = &testsuite_params;
4756 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4757 ts_params->op_mpool,
4758 ts_params->session_mpool,
4759 ts_params->valid_devs[0],
4760 rte_cryptodev_driver_id_get(
4761 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
4762 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4764 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4766 return TEST_SUCCESS;
4770 test_3DES_cipheronly_qat_all(void)
4772 struct crypto_testsuite_params *ts_params = &testsuite_params;
4775 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4776 ts_params->op_mpool,
4777 ts_params->session_mpool,
4778 ts_params->valid_devs[0],
4779 rte_cryptodev_driver_id_get(
4780 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
4781 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4783 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4785 return TEST_SUCCESS;
4789 test_3DES_chain_openssl_all(void)
4791 struct crypto_testsuite_params *ts_params = &testsuite_params;
4794 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4795 ts_params->op_mpool,
4796 ts_params->session_mpool,
4797 ts_params->valid_devs[0],
4798 rte_cryptodev_driver_id_get(
4799 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
4800 BLKCIPHER_3DES_CHAIN_TYPE);
4802 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4804 return TEST_SUCCESS;
4808 test_3DES_cipheronly_openssl_all(void)
4810 struct crypto_testsuite_params *ts_params = &testsuite_params;
4813 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4814 ts_params->op_mpool,
4815 ts_params->session_mpool,
4816 ts_params->valid_devs[0],
4817 rte_cryptodev_driver_id_get(
4818 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
4819 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4821 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4823 return TEST_SUCCESS;
4826 /* ***** AES-GCM Tests ***** */
4829 create_gcm_session(uint8_t dev_id, enum rte_crypto_aead_operation op,
4830 const uint8_t *key, const uint8_t key_len,
4831 const uint16_t aad_len, const uint8_t auth_len,
4834 uint8_t aead_key[key_len];
4836 struct crypto_testsuite_params *ts_params = &testsuite_params;
4837 struct crypto_unittest_params *ut_params = &unittest_params;
4839 memcpy(aead_key, key, key_len);
4841 /* Setup AEAD Parameters */
4842 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
4843 ut_params->aead_xform.next = NULL;
4844 ut_params->aead_xform.aead.algo = RTE_CRYPTO_AEAD_AES_GCM;
4845 ut_params->aead_xform.aead.op = op;
4846 ut_params->aead_xform.aead.key.data = aead_key;
4847 ut_params->aead_xform.aead.key.length = key_len;
4848 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
4849 ut_params->aead_xform.aead.iv.length = iv_len;
4850 ut_params->aead_xform.aead.digest_length = auth_len;
4851 ut_params->aead_xform.aead.aad_length = aad_len;
4853 TEST_HEXDUMP(stdout, "key:", key, key_len);
4855 /* Create Crypto session*/
4856 ut_params->sess = rte_cryptodev_sym_session_create(
4857 ts_params->session_mpool);
4859 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
4860 &ut_params->aead_xform, ts_params->session_mpool);
4862 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4868 create_gcm_xforms(struct rte_crypto_op *op,
4869 enum rte_crypto_aead_operation aead_op,
4870 uint8_t *key, const uint8_t key_len,
4871 const uint8_t aad_len, const uint8_t auth_len,
4874 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
4875 "failed to allocate space for crypto transform");
4877 struct rte_crypto_sym_op *sym_op = op->sym;
4879 /* Setup AEAD Parameters */
4880 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
4881 sym_op->xform->next = NULL;
4882 sym_op->xform->aead.algo = RTE_CRYPTO_AEAD_AES_GCM;
4883 sym_op->xform->aead.op = aead_op;
4884 sym_op->xform->aead.key.data = key;
4885 sym_op->xform->aead.key.length = key_len;
4886 sym_op->xform->aead.iv.offset = IV_OFFSET;
4887 sym_op->xform->aead.iv.length = iv_len;
4888 sym_op->xform->aead.digest_length = auth_len;
4889 sym_op->xform->aead.aad_length = aad_len;
4891 TEST_HEXDUMP(stdout, "key:", key, key_len);
4897 create_gcm_operation(enum rte_crypto_aead_operation op,
4898 const struct gcm_test_data *tdata)
4900 struct crypto_testsuite_params *ts_params = &testsuite_params;
4901 struct crypto_unittest_params *ut_params = &unittest_params;
4903 uint8_t *plaintext, *ciphertext;
4904 unsigned int aad_pad_len, plaintext_pad_len;
4906 /* Generate Crypto op data structure */
4907 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4908 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4909 TEST_ASSERT_NOT_NULL(ut_params->op,
4910 "Failed to allocate symmetric crypto operation struct");
4912 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4914 /* Append aad data */
4915 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
4916 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4918 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
4919 "no room to append aad");
4921 sym_op->aead.aad.phys_addr =
4922 rte_pktmbuf_mtophys(ut_params->ibuf);
4923 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
4924 TEST_HEXDUMP(stdout, "aad:", sym_op->aead.aad.data,
4927 /* Append IV at the end of the crypto operation*/
4928 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
4929 uint8_t *, IV_OFFSET);
4931 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
4932 TEST_HEXDUMP(stdout, "iv:", iv_ptr,
4935 /* Append plaintext/ciphertext */
4936 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
4937 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4938 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4940 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
4942 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4943 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
4944 tdata->plaintext.len);
4946 if (ut_params->obuf) {
4947 ciphertext = (uint8_t *)rte_pktmbuf_append(
4949 plaintext_pad_len + aad_pad_len);
4950 TEST_ASSERT_NOT_NULL(ciphertext,
4951 "no room to append ciphertext");
4953 memset(ciphertext + aad_pad_len, 0,
4954 tdata->ciphertext.len);
4957 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4958 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4960 TEST_ASSERT_NOT_NULL(ciphertext,
4961 "no room to append ciphertext");
4963 memcpy(ciphertext, tdata->ciphertext.data,
4964 tdata->ciphertext.len);
4965 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
4966 tdata->ciphertext.len);
4968 if (ut_params->obuf) {
4969 plaintext = (uint8_t *)rte_pktmbuf_append(
4971 plaintext_pad_len + aad_pad_len);
4972 TEST_ASSERT_NOT_NULL(plaintext,
4973 "no room to append plaintext");
4975 memset(plaintext + aad_pad_len, 0,
4976 tdata->plaintext.len);
4980 /* Append digest data */
4981 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
4982 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
4983 ut_params->obuf ? ut_params->obuf :
4985 tdata->auth_tag.len);
4986 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
4987 "no room to append digest");
4988 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
4989 sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4990 ut_params->obuf ? ut_params->obuf :
4995 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
4996 ut_params->ibuf, tdata->auth_tag.len);
4997 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
4998 "no room to append digest");
4999 sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5001 plaintext_pad_len + aad_pad_len);
5003 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
5004 tdata->auth_tag.len);
5005 TEST_HEXDUMP(stdout, "digest:",
5006 sym_op->aead.digest.data,
5007 tdata->auth_tag.len);
5010 sym_op->aead.data.length = tdata->plaintext.len;
5011 sym_op->aead.data.offset = aad_pad_len;
5017 test_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
5019 struct crypto_testsuite_params *ts_params = &testsuite_params;
5020 struct crypto_unittest_params *ut_params = &unittest_params;
5023 uint8_t *ciphertext, *auth_tag;
5024 uint16_t plaintext_pad_len;
5027 /* Create GCM session */
5028 retval = create_gcm_session(ts_params->valid_devs[0],
5029 RTE_CRYPTO_AEAD_OP_ENCRYPT,
5030 tdata->key.data, tdata->key.len,
5031 tdata->aad.len, tdata->auth_tag.len,
5036 if (tdata->aad.len > MBUF_SIZE) {
5037 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5038 /* Populate full size of add data */
5039 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5040 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5042 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5044 /* clear mbuf payload */
5045 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5046 rte_pktmbuf_tailroom(ut_params->ibuf));
5048 /* Create GCM operation */
5049 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5053 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5055 ut_params->op->sym->m_src = ut_params->ibuf;
5057 /* Process crypto operation */
5058 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5059 ut_params->op), "failed to process sym crypto op");
5061 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5062 "crypto op processing failed");
5064 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5066 if (ut_params->op->sym->m_dst) {
5067 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5069 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5070 uint8_t *, plaintext_pad_len);
5072 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5074 ut_params->op->sym->cipher.data.offset);
5075 auth_tag = ciphertext + plaintext_pad_len;
5078 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5079 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5082 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5084 tdata->ciphertext.data,
5085 tdata->ciphertext.len,
5086 "GCM Ciphertext data not as expected");
5088 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5090 tdata->auth_tag.data,
5091 tdata->auth_tag.len,
5092 "GCM Generated auth tag not as expected");
5099 test_AES_GCM_authenticated_encryption_test_case_1(void)
5101 return test_AES_GCM_authenticated_encryption(&gcm_test_case_1);
5105 test_AES_GCM_authenticated_encryption_test_case_2(void)
5107 return test_AES_GCM_authenticated_encryption(&gcm_test_case_2);
5111 test_AES_GCM_authenticated_encryption_test_case_3(void)
5113 return test_AES_GCM_authenticated_encryption(&gcm_test_case_3);
5117 test_AES_GCM_authenticated_encryption_test_case_4(void)
5119 return test_AES_GCM_authenticated_encryption(&gcm_test_case_4);
5123 test_AES_GCM_authenticated_encryption_test_case_5(void)
5125 return test_AES_GCM_authenticated_encryption(&gcm_test_case_5);
5129 test_AES_GCM_authenticated_encryption_test_case_6(void)
5131 return test_AES_GCM_authenticated_encryption(&gcm_test_case_6);
5135 test_AES_GCM_authenticated_encryption_test_case_7(void)
5137 return test_AES_GCM_authenticated_encryption(&gcm_test_case_7);
5141 test_AES_GCM_auth_encryption_test_case_192_1(void)
5143 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_1);
5147 test_AES_GCM_auth_encryption_test_case_192_2(void)
5149 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_2);
5153 test_AES_GCM_auth_encryption_test_case_192_3(void)
5155 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_3);
5159 test_AES_GCM_auth_encryption_test_case_192_4(void)
5161 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_4);
5165 test_AES_GCM_auth_encryption_test_case_192_5(void)
5167 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_5);
5171 test_AES_GCM_auth_encryption_test_case_192_6(void)
5173 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_6);
5177 test_AES_GCM_auth_encryption_test_case_192_7(void)
5179 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_7);
5183 test_AES_GCM_auth_encryption_test_case_256_1(void)
5185 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
5189 test_AES_GCM_auth_encryption_test_case_256_2(void)
5191 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
5195 test_AES_GCM_auth_encryption_test_case_256_3(void)
5197 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
5201 test_AES_GCM_auth_encryption_test_case_256_4(void)
5203 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
5207 test_AES_GCM_auth_encryption_test_case_256_5(void)
5209 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
5213 test_AES_GCM_auth_encryption_test_case_256_6(void)
5215 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
5219 test_AES_GCM_auth_encryption_test_case_256_7(void)
5221 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
5225 test_AES_GCM_auth_encryption_test_case_aad_1(void)
5227 return test_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
5231 test_AES_GCM_auth_encryption_test_case_aad_2(void)
5233 return test_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
5237 test_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
5239 struct crypto_testsuite_params *ts_params = &testsuite_params;
5240 struct crypto_unittest_params *ut_params = &unittest_params;
5246 /* Create GCM session */
5247 retval = create_gcm_session(ts_params->valid_devs[0],
5248 RTE_CRYPTO_AEAD_OP_DECRYPT,
5249 tdata->key.data, tdata->key.len,
5250 tdata->aad.len, tdata->auth_tag.len,
5255 /* alloc mbuf and set payload */
5256 if (tdata->aad.len > MBUF_SIZE) {
5257 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5258 /* Populate full size of add data */
5259 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5260 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5262 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5264 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5265 rte_pktmbuf_tailroom(ut_params->ibuf));
5267 /* Create GCM operation */
5268 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5272 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5274 ut_params->op->sym->m_src = ut_params->ibuf;
5276 /* Process crypto operation */
5277 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5278 ut_params->op), "failed to process sym crypto op");
5280 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5281 "crypto op processing failed");
5283 if (ut_params->op->sym->m_dst)
5284 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5287 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5289 ut_params->op->sym->cipher.data.offset);
5291 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5294 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5296 tdata->plaintext.data,
5297 tdata->plaintext.len,
5298 "GCM plaintext data not as expected");
5300 TEST_ASSERT_EQUAL(ut_params->op->status,
5301 RTE_CRYPTO_OP_STATUS_SUCCESS,
5302 "GCM authentication failed");
5307 test_AES_GCM_authenticated_decryption_test_case_1(void)
5309 return test_AES_GCM_authenticated_decryption(&gcm_test_case_1);
5313 test_AES_GCM_authenticated_decryption_test_case_2(void)
5315 return test_AES_GCM_authenticated_decryption(&gcm_test_case_2);
5319 test_AES_GCM_authenticated_decryption_test_case_3(void)
5321 return test_AES_GCM_authenticated_decryption(&gcm_test_case_3);
5325 test_AES_GCM_authenticated_decryption_test_case_4(void)
5327 return test_AES_GCM_authenticated_decryption(&gcm_test_case_4);
5331 test_AES_GCM_authenticated_decryption_test_case_5(void)
5333 return test_AES_GCM_authenticated_decryption(&gcm_test_case_5);
5337 test_AES_GCM_authenticated_decryption_test_case_6(void)
5339 return test_AES_GCM_authenticated_decryption(&gcm_test_case_6);
5343 test_AES_GCM_authenticated_decryption_test_case_7(void)
5345 return test_AES_GCM_authenticated_decryption(&gcm_test_case_7);
5349 test_AES_GCM_auth_decryption_test_case_192_1(void)
5351 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_1);
5355 test_AES_GCM_auth_decryption_test_case_192_2(void)
5357 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_2);
5361 test_AES_GCM_auth_decryption_test_case_192_3(void)
5363 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_3);
5367 test_AES_GCM_auth_decryption_test_case_192_4(void)
5369 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_4);
5373 test_AES_GCM_auth_decryption_test_case_192_5(void)
5375 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_5);
5379 test_AES_GCM_auth_decryption_test_case_192_6(void)
5381 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_6);
5385 test_AES_GCM_auth_decryption_test_case_192_7(void)
5387 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_7);
5391 test_AES_GCM_auth_decryption_test_case_256_1(void)
5393 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
5397 test_AES_GCM_auth_decryption_test_case_256_2(void)
5399 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
5403 test_AES_GCM_auth_decryption_test_case_256_3(void)
5405 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
5409 test_AES_GCM_auth_decryption_test_case_256_4(void)
5411 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
5415 test_AES_GCM_auth_decryption_test_case_256_5(void)
5417 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
5421 test_AES_GCM_auth_decryption_test_case_256_6(void)
5423 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
5427 test_AES_GCM_auth_decryption_test_case_256_7(void)
5429 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
5433 test_AES_GCM_auth_decryption_test_case_aad_1(void)
5435 return test_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
5439 test_AES_GCM_auth_decryption_test_case_aad_2(void)
5441 return test_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
5445 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
5447 struct crypto_testsuite_params *ts_params = &testsuite_params;
5448 struct crypto_unittest_params *ut_params = &unittest_params;
5451 uint8_t *ciphertext, *auth_tag;
5452 uint16_t plaintext_pad_len;
5454 /* Create GCM session */
5455 retval = create_gcm_session(ts_params->valid_devs[0],
5456 RTE_CRYPTO_AEAD_OP_ENCRYPT,
5457 tdata->key.data, tdata->key.len,
5458 tdata->aad.len, tdata->auth_tag.len,
5463 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5464 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5466 /* clear mbuf payload */
5467 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5468 rte_pktmbuf_tailroom(ut_params->ibuf));
5469 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5470 rte_pktmbuf_tailroom(ut_params->obuf));
5472 /* Create GCM operation */
5473 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5477 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5479 ut_params->op->sym->m_src = ut_params->ibuf;
5480 ut_params->op->sym->m_dst = ut_params->obuf;
5482 /* Process crypto operation */
5483 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5484 ut_params->op), "failed to process sym crypto op");
5486 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5487 "crypto op processing failed");
5489 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5491 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5492 ut_params->op->sym->cipher.data.offset);
5493 auth_tag = ciphertext + plaintext_pad_len;
5495 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5496 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5499 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5501 tdata->ciphertext.data,
5502 tdata->ciphertext.len,
5503 "GCM Ciphertext data not as expected");
5505 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5507 tdata->auth_tag.data,
5508 tdata->auth_tag.len,
5509 "GCM Generated auth tag not as expected");
5516 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
5518 return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
5522 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
5524 struct crypto_testsuite_params *ts_params = &testsuite_params;
5525 struct crypto_unittest_params *ut_params = &unittest_params;
5530 /* Create GCM session */
5531 retval = create_gcm_session(ts_params->valid_devs[0],
5532 RTE_CRYPTO_AEAD_OP_DECRYPT,
5533 tdata->key.data, tdata->key.len,
5534 tdata->aad.len, tdata->auth_tag.len,
5539 /* alloc mbuf and set payload */
5540 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5541 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5543 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5544 rte_pktmbuf_tailroom(ut_params->ibuf));
5545 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5546 rte_pktmbuf_tailroom(ut_params->obuf));
5548 /* Create GCM operation */
5549 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5553 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5555 ut_params->op->sym->m_src = ut_params->ibuf;
5556 ut_params->op->sym->m_dst = ut_params->obuf;
5558 /* Process crypto operation */
5559 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5560 ut_params->op), "failed to process sym crypto op");
5562 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5563 "crypto op processing failed");
5565 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5566 ut_params->op->sym->cipher.data.offset);
5568 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5571 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5573 tdata->plaintext.data,
5574 tdata->plaintext.len,
5575 "GCM plaintext data not as expected");
5577 TEST_ASSERT_EQUAL(ut_params->op->status,
5578 RTE_CRYPTO_OP_STATUS_SUCCESS,
5579 "GCM authentication failed");
5584 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
5586 return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
5590 test_AES_GCM_authenticated_encryption_sessionless(
5591 const struct gcm_test_data *tdata)
5593 struct crypto_testsuite_params *ts_params = &testsuite_params;
5594 struct crypto_unittest_params *ut_params = &unittest_params;
5597 uint8_t *ciphertext, *auth_tag;
5598 uint16_t plaintext_pad_len;
5599 uint8_t key[tdata->key.len + 1];
5601 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5603 /* clear mbuf payload */
5604 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5605 rte_pktmbuf_tailroom(ut_params->ibuf));
5607 /* Create GCM operation */
5608 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5612 /* Create GCM xforms */
5613 memcpy(key, tdata->key.data, tdata->key.len);
5614 retval = create_gcm_xforms(ut_params->op,
5615 RTE_CRYPTO_AEAD_OP_ENCRYPT,
5616 key, tdata->key.len,
5617 tdata->aad.len, tdata->auth_tag.len,
5622 ut_params->op->sym->m_src = ut_params->ibuf;
5624 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
5625 RTE_CRYPTO_OP_SESSIONLESS,
5626 "crypto op session type not sessionless");
5628 /* Process crypto operation */
5629 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5630 ut_params->op), "failed to process sym crypto op");
5632 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5634 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5635 "crypto op status not success");
5637 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5639 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5640 ut_params->op->sym->cipher.data.offset);
5641 auth_tag = ciphertext + plaintext_pad_len;
5643 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5644 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5647 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5649 tdata->ciphertext.data,
5650 tdata->ciphertext.len,
5651 "GCM Ciphertext data not as expected");
5653 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5655 tdata->auth_tag.data,
5656 tdata->auth_tag.len,
5657 "GCM Generated auth tag not as expected");
5664 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
5666 return test_AES_GCM_authenticated_encryption_sessionless(
5671 test_AES_GCM_authenticated_decryption_sessionless(
5672 const struct gcm_test_data *tdata)
5674 struct crypto_testsuite_params *ts_params = &testsuite_params;
5675 struct crypto_unittest_params *ut_params = &unittest_params;
5679 uint8_t key[tdata->key.len + 1];
5681 /* alloc mbuf and set payload */
5682 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5684 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5685 rte_pktmbuf_tailroom(ut_params->ibuf));
5687 /* Create GCM operation */
5688 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5692 /* Create GCM xforms */
5693 memcpy(key, tdata->key.data, tdata->key.len);
5694 retval = create_gcm_xforms(ut_params->op,
5695 RTE_CRYPTO_AEAD_OP_DECRYPT,
5696 key, tdata->key.len,
5697 tdata->aad.len, tdata->auth_tag.len,
5702 ut_params->op->sym->m_src = ut_params->ibuf;
5704 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
5705 RTE_CRYPTO_OP_SESSIONLESS,
5706 "crypto op session type not sessionless");
5708 /* Process crypto operation */
5709 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5710 ut_params->op), "failed to process sym crypto op");
5712 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5714 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5715 "crypto op status not success");
5717 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5718 ut_params->op->sym->cipher.data.offset);
5720 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5723 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5725 tdata->plaintext.data,
5726 tdata->plaintext.len,
5727 "GCM plaintext data not as expected");
5729 TEST_ASSERT_EQUAL(ut_params->op->status,
5730 RTE_CRYPTO_OP_STATUS_SUCCESS,
5731 "GCM authentication failed");
5736 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
5738 return test_AES_GCM_authenticated_decryption_sessionless(
5745 struct crypto_testsuite_params *ts_params = &testsuite_params;
5746 struct rte_cryptodev_stats stats;
5747 struct rte_cryptodev *dev;
5748 cryptodev_stats_get_t temp_pfn;
5750 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5751 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
5752 &stats) == -ENODEV),
5753 "rte_cryptodev_stats_get invalid dev failed");
5754 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
5755 "rte_cryptodev_stats_get invalid Param failed");
5756 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
5757 temp_pfn = dev->dev_ops->stats_get;
5758 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
5759 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
5761 "rte_cryptodev_stats_get invalid Param failed");
5762 dev->dev_ops->stats_get = temp_pfn;
5764 /* Test expected values */
5766 test_AES_CBC_HMAC_SHA1_encrypt_digest();
5768 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5770 "rte_cryptodev_stats_get failed");
5771 TEST_ASSERT((stats.enqueued_count == 1),
5772 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5773 TEST_ASSERT((stats.dequeued_count == 1),
5774 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5775 TEST_ASSERT((stats.enqueue_err_count == 0),
5776 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5777 TEST_ASSERT((stats.dequeue_err_count == 0),
5778 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5780 /* invalid device but should ignore and not reset device stats*/
5781 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
5782 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5784 "rte_cryptodev_stats_get failed");
5785 TEST_ASSERT((stats.enqueued_count == 1),
5786 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5788 /* check that a valid reset clears stats */
5789 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5790 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5792 "rte_cryptodev_stats_get failed");
5793 TEST_ASSERT((stats.enqueued_count == 0),
5794 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5795 TEST_ASSERT((stats.dequeued_count == 0),
5796 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5798 return TEST_SUCCESS;
5801 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
5802 struct crypto_unittest_params *ut_params,
5803 enum rte_crypto_auth_operation op,
5804 const struct HMAC_MD5_vector *test_case)
5808 memcpy(key, test_case->key.data, test_case->key.len);
5810 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5811 ut_params->auth_xform.next = NULL;
5812 ut_params->auth_xform.auth.op = op;
5814 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
5816 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
5817 ut_params->auth_xform.auth.key.length = test_case->key.len;
5818 ut_params->auth_xform.auth.key.data = key;
5820 ut_params->sess = rte_cryptodev_sym_session_create(
5821 ts_params->session_mpool);
5823 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
5824 ut_params->sess, &ut_params->auth_xform,
5825 ts_params->session_mpool);
5827 if (ut_params->sess == NULL)
5830 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5832 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5833 rte_pktmbuf_tailroom(ut_params->ibuf));
5838 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
5839 const struct HMAC_MD5_vector *test_case,
5840 uint8_t **plaintext)
5842 uint16_t plaintext_pad_len;
5844 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5846 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5849 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5851 memcpy(*plaintext, test_case->plaintext.data,
5852 test_case->plaintext.len);
5854 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5855 ut_params->ibuf, MD5_DIGEST_LEN);
5856 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5857 "no room to append digest");
5858 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5859 ut_params->ibuf, plaintext_pad_len);
5861 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5862 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
5863 test_case->auth_tag.len);
5866 sym_op->auth.data.offset = 0;
5867 sym_op->auth.data.length = test_case->plaintext.len;
5869 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5870 ut_params->op->sym->m_src = ut_params->ibuf;
5876 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
5878 uint16_t plaintext_pad_len;
5879 uint8_t *plaintext, *auth_tag;
5881 struct crypto_testsuite_params *ts_params = &testsuite_params;
5882 struct crypto_unittest_params *ut_params = &unittest_params;
5884 if (MD5_HMAC_create_session(ts_params, ut_params,
5885 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
5888 /* Generate Crypto op data structure */
5889 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5890 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5891 TEST_ASSERT_NOT_NULL(ut_params->op,
5892 "Failed to allocate symmetric crypto operation struct");
5894 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5897 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5900 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5901 ut_params->op), "failed to process sym crypto op");
5903 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5904 "crypto op processing failed");
5906 if (ut_params->op->sym->m_dst) {
5907 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5908 uint8_t *, plaintext_pad_len);
5910 auth_tag = plaintext + plaintext_pad_len;
5913 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5915 test_case->auth_tag.data,
5916 test_case->auth_tag.len,
5917 "HMAC_MD5 generated tag not as expected");
5919 return TEST_SUCCESS;
5923 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
5927 struct crypto_testsuite_params *ts_params = &testsuite_params;
5928 struct crypto_unittest_params *ut_params = &unittest_params;
5930 if (MD5_HMAC_create_session(ts_params, ut_params,
5931 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
5935 /* Generate Crypto op data structure */
5936 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5937 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5938 TEST_ASSERT_NOT_NULL(ut_params->op,
5939 "Failed to allocate symmetric crypto operation struct");
5941 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5944 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5945 ut_params->op), "failed to process sym crypto op");
5947 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5948 "HMAC_MD5 crypto op processing failed");
5950 return TEST_SUCCESS;
5954 test_MD5_HMAC_generate_case_1(void)
5956 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
5960 test_MD5_HMAC_verify_case_1(void)
5962 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
5966 test_MD5_HMAC_generate_case_2(void)
5968 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
5972 test_MD5_HMAC_verify_case_2(void)
5974 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
5978 test_multi_session(void)
5980 struct crypto_testsuite_params *ts_params = &testsuite_params;
5981 struct crypto_unittest_params *ut_params = &unittest_params;
5983 struct rte_cryptodev_info dev_info;
5984 struct rte_cryptodev_sym_session **sessions;
5988 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
5989 aes_cbc_key, hmac_sha512_key);
5992 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5994 sessions = rte_malloc(NULL,
5995 (sizeof(struct rte_cryptodev_sym_session *) *
5996 dev_info.sym.max_nb_sessions) + 1, 0);
5998 /* Create multiple crypto sessions*/
5999 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
6001 sessions[i] = rte_cryptodev_sym_session_create(
6002 ts_params->session_mpool);
6004 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6005 sessions[i], &ut_params->auth_xform,
6006 ts_params->session_mpool);
6007 TEST_ASSERT_NOT_NULL(sessions[i],
6008 "Session creation failed at session number %u",
6011 /* Attempt to send a request on each session */
6012 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
6016 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
6017 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
6019 "Failed to perform decrypt on request number %u.", i);
6020 /* free crypto operation structure */
6022 rte_crypto_op_free(ut_params->op);
6025 * free mbuf - both obuf and ibuf are usually the same,
6026 * so check if they point at the same address is necessary,
6027 * to avoid freeing the mbuf twice.
6029 if (ut_params->obuf) {
6030 rte_pktmbuf_free(ut_params->obuf);
6031 if (ut_params->ibuf == ut_params->obuf)
6032 ut_params->ibuf = 0;
6033 ut_params->obuf = 0;
6035 if (ut_params->ibuf) {
6036 rte_pktmbuf_free(ut_params->ibuf);
6037 ut_params->ibuf = 0;
6041 /* Next session create should fail */
6042 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6043 sessions[i], &ut_params->auth_xform,
6044 ts_params->session_mpool);
6045 TEST_ASSERT_NULL(sessions[i],
6046 "Session creation succeeded unexpectedly!");
6048 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
6049 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6051 rte_cryptodev_sym_session_free(sessions[i]);
6056 return TEST_SUCCESS;
6059 struct multi_session_params {
6060 struct crypto_unittest_params ut_params;
6061 uint8_t *cipher_key;
6063 const uint8_t *cipher;
6064 const uint8_t *digest;
6068 #define MB_SESSION_NUMBER 3
6071 test_multi_session_random_usage(void)
6073 struct crypto_testsuite_params *ts_params = &testsuite_params;
6074 struct rte_cryptodev_info dev_info;
6075 struct rte_cryptodev_sym_session **sessions;
6077 struct multi_session_params ut_paramz[] = {
6080 .cipher_key = ms_aes_cbc_key0,
6081 .hmac_key = ms_hmac_key0,
6082 .cipher = ms_aes_cbc_cipher0,
6083 .digest = ms_hmac_digest0,
6084 .iv = ms_aes_cbc_iv0
6087 .cipher_key = ms_aes_cbc_key1,
6088 .hmac_key = ms_hmac_key1,
6089 .cipher = ms_aes_cbc_cipher1,
6090 .digest = ms_hmac_digest1,
6091 .iv = ms_aes_cbc_iv1
6094 .cipher_key = ms_aes_cbc_key2,
6095 .hmac_key = ms_hmac_key2,
6096 .cipher = ms_aes_cbc_cipher2,
6097 .digest = ms_hmac_digest2,
6098 .iv = ms_aes_cbc_iv2
6103 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6105 sessions = rte_malloc(NULL,
6106 (sizeof(struct rte_cryptodev_sym_session *)
6107 * dev_info.sym.max_nb_sessions) + 1, 0);
6109 for (i = 0; i < MB_SESSION_NUMBER; i++) {
6110 sessions[i] = rte_cryptodev_sym_session_create(
6111 ts_params->session_mpool);
6113 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
6114 sizeof(struct crypto_unittest_params));
6116 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
6117 &ut_paramz[i].ut_params,
6118 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
6120 /* Create multiple crypto sessions*/
6121 rte_cryptodev_sym_session_init(
6122 ts_params->valid_devs[0],
6124 &ut_paramz[i].ut_params.auth_xform,
6125 ts_params->session_mpool);
6127 TEST_ASSERT_NOT_NULL(sessions[i],
6128 "Session creation failed at session number %u",
6134 for (i = 0; i < 40000; i++) {
6136 j = rand() % MB_SESSION_NUMBER;
6138 TEST_ASSERT_SUCCESS(
6139 test_AES_CBC_HMAC_SHA512_decrypt_perform(
6141 &ut_paramz[j].ut_params,
6142 ts_params, ut_paramz[j].cipher,
6143 ut_paramz[j].digest,
6145 "Failed to perform decrypt on request number %u.", i);
6147 if (ut_paramz[j].ut_params.op)
6148 rte_crypto_op_free(ut_paramz[j].ut_params.op);
6151 * free mbuf - both obuf and ibuf are usually the same,
6152 * so check if they point at the same address is necessary,
6153 * to avoid freeing the mbuf twice.
6155 if (ut_paramz[j].ut_params.obuf) {
6156 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
6157 if (ut_paramz[j].ut_params.ibuf
6158 == ut_paramz[j].ut_params.obuf)
6159 ut_paramz[j].ut_params.ibuf = 0;
6160 ut_paramz[j].ut_params.obuf = 0;
6162 if (ut_paramz[j].ut_params.ibuf) {
6163 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
6164 ut_paramz[j].ut_params.ibuf = 0;
6168 for (i = 0; i < MB_SESSION_NUMBER; i++) {
6169 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6171 rte_cryptodev_sym_session_free(sessions[i]);
6176 return TEST_SUCCESS;
6180 test_null_cipher_only_operation(void)
6182 struct crypto_testsuite_params *ts_params = &testsuite_params;
6183 struct crypto_unittest_params *ut_params = &unittest_params;
6185 /* Generate test mbuf data and space for digest */
6186 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6187 catch_22_quote, QUOTE_512_BYTES, 0);
6189 /* Setup Cipher Parameters */
6190 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6191 ut_params->cipher_xform.next = NULL;
6193 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6194 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6196 ut_params->sess = rte_cryptodev_sym_session_create(
6197 ts_params->session_mpool);
6199 /* Create Crypto session*/
6200 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6202 &ut_params->cipher_xform,
6203 ts_params->session_mpool);
6204 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6206 /* Generate Crypto op data structure */
6207 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6208 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6209 TEST_ASSERT_NOT_NULL(ut_params->op,
6210 "Failed to allocate symmetric crypto operation struct");
6212 /* Set crypto operation data parameters */
6213 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6215 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6217 /* set crypto operation source mbuf */
6218 sym_op->m_src = ut_params->ibuf;
6220 sym_op->cipher.data.offset = 0;
6221 sym_op->cipher.data.length = QUOTE_512_BYTES;
6223 /* Process crypto operation */
6224 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6226 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6228 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6229 "crypto operation processing failed");
6232 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6233 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6236 "Ciphertext data not as expected");
6238 return TEST_SUCCESS;
6242 test_null_auth_only_operation(void)
6244 struct crypto_testsuite_params *ts_params = &testsuite_params;
6245 struct crypto_unittest_params *ut_params = &unittest_params;
6247 /* Generate test mbuf data and space for digest */
6248 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6249 catch_22_quote, QUOTE_512_BYTES, 0);
6251 /* Setup HMAC Parameters */
6252 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6253 ut_params->auth_xform.next = NULL;
6255 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6256 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6258 ut_params->sess = rte_cryptodev_sym_session_create(
6259 ts_params->session_mpool);
6261 /* Create Crypto session*/
6262 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6263 ut_params->sess, &ut_params->auth_xform,
6264 ts_params->session_mpool);
6265 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6267 /* Generate Crypto op data structure */
6268 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6269 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6270 TEST_ASSERT_NOT_NULL(ut_params->op,
6271 "Failed to allocate symmetric crypto operation struct");
6273 /* Set crypto operation data parameters */
6274 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6276 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6278 sym_op->m_src = ut_params->ibuf;
6280 sym_op->auth.data.offset = 0;
6281 sym_op->auth.data.length = QUOTE_512_BYTES;
6283 /* Process crypto operation */
6284 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6286 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6288 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6289 "crypto operation processing failed");
6291 return TEST_SUCCESS;
6295 test_null_cipher_auth_operation(void)
6297 struct crypto_testsuite_params *ts_params = &testsuite_params;
6298 struct crypto_unittest_params *ut_params = &unittest_params;
6300 /* Generate test mbuf data and space for digest */
6301 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6302 catch_22_quote, QUOTE_512_BYTES, 0);
6304 /* Setup Cipher Parameters */
6305 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6306 ut_params->cipher_xform.next = &ut_params->auth_xform;
6308 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6309 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6311 /* Setup HMAC Parameters */
6312 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6313 ut_params->auth_xform.next = NULL;
6315 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6316 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6318 ut_params->sess = rte_cryptodev_sym_session_create(
6319 ts_params->session_mpool);
6321 /* Create Crypto session*/
6322 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6323 ut_params->sess, &ut_params->cipher_xform,
6324 ts_params->session_mpool);
6325 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6327 /* Generate Crypto op data structure */
6328 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6329 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6330 TEST_ASSERT_NOT_NULL(ut_params->op,
6331 "Failed to allocate symmetric crypto operation struct");
6333 /* Set crypto operation data parameters */
6334 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6336 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6338 sym_op->m_src = ut_params->ibuf;
6340 sym_op->cipher.data.offset = 0;
6341 sym_op->cipher.data.length = QUOTE_512_BYTES;
6343 sym_op->auth.data.offset = 0;
6344 sym_op->auth.data.length = QUOTE_512_BYTES;
6346 /* Process crypto operation */
6347 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6349 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6351 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6352 "crypto operation processing failed");
6355 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6356 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6359 "Ciphertext data not as expected");
6361 return TEST_SUCCESS;
6365 test_null_auth_cipher_operation(void)
6367 struct crypto_testsuite_params *ts_params = &testsuite_params;
6368 struct crypto_unittest_params *ut_params = &unittest_params;
6370 /* Generate test mbuf data and space for digest */
6371 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6372 catch_22_quote, QUOTE_512_BYTES, 0);
6374 /* Setup Cipher Parameters */
6375 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6376 ut_params->cipher_xform.next = NULL;
6378 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6379 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6381 /* Setup HMAC Parameters */
6382 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6383 ut_params->auth_xform.next = &ut_params->cipher_xform;
6385 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6386 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6388 ut_params->sess = rte_cryptodev_sym_session_create(
6389 ts_params->session_mpool);
6391 /* Create Crypto session*/
6392 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6393 ut_params->sess, &ut_params->cipher_xform,
6394 ts_params->session_mpool);
6395 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6397 /* Generate Crypto op data structure */
6398 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6399 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6400 TEST_ASSERT_NOT_NULL(ut_params->op,
6401 "Failed to allocate symmetric crypto operation struct");
6403 /* Set crypto operation data parameters */
6404 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6406 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6408 sym_op->m_src = ut_params->ibuf;
6410 sym_op->cipher.data.offset = 0;
6411 sym_op->cipher.data.length = QUOTE_512_BYTES;
6413 sym_op->auth.data.offset = 0;
6414 sym_op->auth.data.length = QUOTE_512_BYTES;
6416 /* Process crypto operation */
6417 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6419 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6421 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6422 "crypto operation processing failed");
6425 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6426 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6429 "Ciphertext data not as expected");
6431 return TEST_SUCCESS;
6436 test_null_invalid_operation(void)
6438 struct crypto_testsuite_params *ts_params = &testsuite_params;
6439 struct crypto_unittest_params *ut_params = &unittest_params;
6442 /* Setup Cipher Parameters */
6443 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6444 ut_params->cipher_xform.next = NULL;
6446 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
6447 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6449 ut_params->sess = rte_cryptodev_sym_session_create(
6450 ts_params->session_mpool);
6452 /* Create Crypto session*/
6453 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6454 ut_params->sess, &ut_params->cipher_xform,
6455 ts_params->session_mpool);
6456 TEST_ASSERT(ret < 0,
6457 "Session creation succeeded unexpectedly");
6460 /* Setup HMAC Parameters */
6461 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6462 ut_params->auth_xform.next = NULL;
6464 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
6465 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6467 ut_params->sess = rte_cryptodev_sym_session_create(
6468 ts_params->session_mpool);
6470 /* Create Crypto session*/
6471 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6472 ut_params->sess, &ut_params->auth_xform,
6473 ts_params->session_mpool);
6474 TEST_ASSERT(ret < 0,
6475 "Session creation succeeded unexpectedly");
6477 return TEST_SUCCESS;
6481 #define NULL_BURST_LENGTH (32)
6484 test_null_burst_operation(void)
6486 struct crypto_testsuite_params *ts_params = &testsuite_params;
6487 struct crypto_unittest_params *ut_params = &unittest_params;
6489 unsigned i, burst_len = NULL_BURST_LENGTH;
6491 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
6492 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
6494 /* Setup Cipher Parameters */
6495 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6496 ut_params->cipher_xform.next = &ut_params->auth_xform;
6498 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6499 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6501 /* Setup HMAC Parameters */
6502 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6503 ut_params->auth_xform.next = NULL;
6505 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6506 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6508 ut_params->sess = rte_cryptodev_sym_session_create(
6509 ts_params->session_mpool);
6511 /* Create Crypto session*/
6512 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6513 ut_params->sess, &ut_params->cipher_xform,
6514 ts_params->session_mpool);
6515 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6517 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
6518 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
6519 burst_len, "failed to generate burst of crypto ops");
6521 /* Generate an operation for each mbuf in burst */
6522 for (i = 0; i < burst_len; i++) {
6523 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6525 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
6527 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
6531 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
6533 burst[i]->sym->m_src = m;
6536 /* Process crypto operation */
6537 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
6538 0, burst, burst_len),
6540 "Error enqueuing burst");
6542 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
6543 0, burst_dequeued, burst_len),
6545 "Error dequeuing burst");
6548 for (i = 0; i < burst_len; i++) {
6550 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
6551 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
6553 "data not as expected");
6555 rte_pktmbuf_free(burst[i]->sym->m_src);
6556 rte_crypto_op_free(burst[i]);
6559 return TEST_SUCCESS;
6563 generate_gmac_large_plaintext(uint8_t *data)
6567 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
6568 memcpy(&data[i], &data[0], 32);
6572 create_gmac_operation(enum rte_crypto_auth_operation op,
6573 const struct gmac_test_data *tdata)
6575 struct crypto_testsuite_params *ts_params = &testsuite_params;
6576 struct crypto_unittest_params *ut_params = &unittest_params;
6577 struct rte_crypto_sym_op *sym_op;
6579 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6581 /* Generate Crypto op data structure */
6582 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6583 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6584 TEST_ASSERT_NOT_NULL(ut_params->op,
6585 "Failed to allocate symmetric crypto operation struct");
6587 sym_op = ut_params->op->sym;
6589 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6590 ut_params->ibuf, tdata->gmac_tag.len);
6591 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6592 "no room to append digest");
6594 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6595 ut_params->ibuf, plaintext_pad_len);
6597 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6598 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
6599 tdata->gmac_tag.len);
6600 TEST_HEXDUMP(stdout, "digest:",
6601 sym_op->auth.digest.data,
6602 tdata->gmac_tag.len);
6605 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6606 uint8_t *, IV_OFFSET);
6608 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
6610 TEST_HEXDUMP(stdout, "iv:", iv_ptr, tdata->iv.len);
6612 sym_op->cipher.data.length = 0;
6613 sym_op->cipher.data.offset = 0;
6615 sym_op->auth.data.offset = 0;
6616 sym_op->auth.data.length = tdata->plaintext.len;
6621 static int create_gmac_session(uint8_t dev_id,
6622 const struct gmac_test_data *tdata,
6623 enum rte_crypto_auth_operation auth_op)
6625 uint8_t auth_key[tdata->key.len];
6627 struct crypto_testsuite_params *ts_params = &testsuite_params;
6628 struct crypto_unittest_params *ut_params = &unittest_params;
6630 memcpy(auth_key, tdata->key.data, tdata->key.len);
6632 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6633 ut_params->auth_xform.next = NULL;
6635 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
6636 ut_params->auth_xform.auth.op = auth_op;
6637 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
6638 ut_params->auth_xform.auth.key.length = tdata->key.len;
6639 ut_params->auth_xform.auth.key.data = auth_key;
6640 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
6641 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
6644 ut_params->sess = rte_cryptodev_sym_session_create(
6645 ts_params->session_mpool);
6647 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6648 &ut_params->auth_xform,
6649 ts_params->session_mpool);
6651 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6657 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
6659 struct crypto_testsuite_params *ts_params = &testsuite_params;
6660 struct crypto_unittest_params *ut_params = &unittest_params;
6664 uint8_t *auth_tag, *plaintext;
6665 uint16_t plaintext_pad_len;
6667 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6668 "No GMAC length in the source data");
6670 retval = create_gmac_session(ts_params->valid_devs[0],
6671 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
6676 if (tdata->plaintext.len > MBUF_SIZE)
6677 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6679 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6680 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6681 "Failed to allocate input buffer in mempool");
6683 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6684 rte_pktmbuf_tailroom(ut_params->ibuf));
6686 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6688 * Runtime generate the large plain text instead of use hard code
6689 * plain text vector. It is done to avoid create huge source file
6690 * with the test vector.
6692 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6693 generate_gmac_large_plaintext(tdata->plaintext.data);
6695 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6697 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6699 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6700 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
6701 tdata->plaintext.len);
6703 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
6709 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6711 ut_params->op->sym->m_src = ut_params->ibuf;
6713 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6714 ut_params->op), "failed to process sym crypto op");
6716 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6717 "crypto op processing failed");
6719 if (ut_params->op->sym->m_dst) {
6720 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6721 uint8_t *, plaintext_pad_len);
6723 auth_tag = plaintext + plaintext_pad_len;
6726 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
6728 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6730 tdata->gmac_tag.data,
6731 tdata->gmac_tag.len,
6732 "GMAC Generated auth tag not as expected");
6738 test_AES_GMAC_authentication_test_case_1(void)
6740 return test_AES_GMAC_authentication(&gmac_test_case_1);
6744 test_AES_GMAC_authentication_test_case_2(void)
6746 return test_AES_GMAC_authentication(&gmac_test_case_2);
6750 test_AES_GMAC_authentication_test_case_3(void)
6752 return test_AES_GMAC_authentication(&gmac_test_case_3);
6756 test_AES_GMAC_authentication_test_case_4(void)
6758 return test_AES_GMAC_authentication(&gmac_test_case_4);
6762 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
6764 struct crypto_testsuite_params *ts_params = &testsuite_params;
6765 struct crypto_unittest_params *ut_params = &unittest_params;
6767 uint32_t plaintext_pad_len;
6770 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6771 "No GMAC length in the source data");
6773 retval = create_gmac_session(ts_params->valid_devs[0],
6774 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
6779 if (tdata->plaintext.len > MBUF_SIZE)
6780 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6782 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6783 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6784 "Failed to allocate input buffer in mempool");
6786 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6787 rte_pktmbuf_tailroom(ut_params->ibuf));
6789 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6792 * Runtime generate the large plain text instead of use hard code
6793 * plain text vector. It is done to avoid create huge source file
6794 * with the test vector.
6796 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6797 generate_gmac_large_plaintext(tdata->plaintext.data);
6799 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6801 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6803 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6804 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
6805 tdata->plaintext.len);
6807 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
6813 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6815 ut_params->op->sym->m_src = ut_params->ibuf;
6817 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6818 ut_params->op), "failed to process sym crypto op");
6820 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6821 "crypto op processing failed");
6828 test_AES_GMAC_authentication_verify_test_case_1(void)
6830 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
6834 test_AES_GMAC_authentication_verify_test_case_2(void)
6836 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
6840 test_AES_GMAC_authentication_verify_test_case_3(void)
6842 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
6846 test_AES_GMAC_authentication_verify_test_case_4(void)
6848 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
6851 struct test_crypto_vector {
6852 enum rte_crypto_cipher_algorithm crypto_algo;
6865 const uint8_t *data;
6870 const uint8_t *data;
6874 enum rte_crypto_auth_algorithm auth_algo;
6882 const uint8_t *data;
6892 static const struct test_crypto_vector
6893 hmac_sha1_test_crypto_vector = {
6894 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6896 .data = plaintext_hash,
6901 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6902 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6903 0xDE, 0xF4, 0xDE, 0xAD
6909 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
6910 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
6911 0x3F, 0x91, 0x64, 0x59
6917 static const struct test_crypto_vector
6918 aes128_gmac_test_vector = {
6919 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
6921 .data = plaintext_hash,
6926 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6927 0x08, 0x09, 0x0A, 0x0B
6933 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6934 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
6940 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
6941 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
6947 static const struct test_crypto_vector
6948 aes128cbc_hmac_sha1_test_vector = {
6949 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
6952 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
6953 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
6959 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6960 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
6965 .data = plaintext_hash,
6969 .data = ciphertext512_aes128cbc,
6972 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6975 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6976 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6977 0xDE, 0xF4, 0xDE, 0xAD
6983 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
6984 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6985 0x18, 0x8C, 0x1D, 0x32
6992 data_corruption(uint8_t *data)
6998 tag_corruption(uint8_t *data, unsigned int tag_offset)
7000 data[tag_offset] += 1;
7004 create_auth_session(struct crypto_unittest_params *ut_params,
7006 const struct test_crypto_vector *reference,
7007 enum rte_crypto_auth_operation auth_op)
7009 struct crypto_testsuite_params *ts_params = &testsuite_params;
7010 uint8_t auth_key[reference->auth_key.len + 1];
7012 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
7014 /* Setup Authentication Parameters */
7015 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7016 ut_params->auth_xform.auth.op = auth_op;
7017 ut_params->auth_xform.next = NULL;
7018 ut_params->auth_xform.auth.algo = reference->auth_algo;
7019 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
7020 ut_params->auth_xform.auth.key.data = auth_key;
7021 ut_params->auth_xform.auth.digest_length = reference->digest.len;
7023 /* Create Crypto session*/
7024 ut_params->sess = rte_cryptodev_sym_session_create(
7025 ts_params->session_mpool);
7027 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7028 &ut_params->auth_xform,
7029 ts_params->session_mpool);
7031 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7037 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
7039 const struct test_crypto_vector *reference,
7040 enum rte_crypto_auth_operation auth_op,
7041 enum rte_crypto_cipher_operation cipher_op)
7043 struct crypto_testsuite_params *ts_params = &testsuite_params;
7044 uint8_t cipher_key[reference->cipher_key.len + 1];
7045 uint8_t auth_key[reference->auth_key.len + 1];
7047 memcpy(cipher_key, reference->cipher_key.data,
7048 reference->cipher_key.len);
7049 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
7051 /* Setup Authentication Parameters */
7052 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7053 ut_params->auth_xform.auth.op = auth_op;
7054 ut_params->auth_xform.auth.algo = reference->auth_algo;
7055 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
7056 ut_params->auth_xform.auth.key.data = auth_key;
7057 ut_params->auth_xform.auth.digest_length = reference->digest.len;
7059 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
7060 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
7061 ut_params->auth_xform.auth.iv.length = reference->iv.len;
7063 ut_params->auth_xform.next = &ut_params->cipher_xform;
7065 /* Setup Cipher Parameters */
7066 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7067 ut_params->cipher_xform.next = NULL;
7068 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
7069 ut_params->cipher_xform.cipher.op = cipher_op;
7070 ut_params->cipher_xform.cipher.key.data = cipher_key;
7071 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
7072 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7073 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
7076 /* Create Crypto session*/
7077 ut_params->sess = rte_cryptodev_sym_session_create(
7078 ts_params->session_mpool);
7080 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7081 &ut_params->auth_xform,
7082 ts_params->session_mpool);
7084 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7090 create_auth_operation(struct crypto_testsuite_params *ts_params,
7091 struct crypto_unittest_params *ut_params,
7092 const struct test_crypto_vector *reference,
7093 unsigned int auth_generate)
7095 /* Generate Crypto op data structure */
7096 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7097 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7098 TEST_ASSERT_NOT_NULL(ut_params->op,
7099 "Failed to allocate pktmbuf offload");
7101 /* Set crypto operation data parameters */
7102 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7104 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7106 /* set crypto operation source mbuf */
7107 sym_op->m_src = ut_params->ibuf;
7110 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7111 ut_params->ibuf, reference->digest.len);
7113 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7114 "no room to append auth tag");
7116 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7117 ut_params->ibuf, reference->plaintext.len);
7120 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7122 memcpy(sym_op->auth.digest.data,
7123 reference->digest.data,
7124 reference->digest.len);
7126 TEST_HEXDUMP(stdout, "digest:",
7127 sym_op->auth.digest.data,
7128 reference->digest.len);
7130 sym_op->auth.data.length = reference->plaintext.len;
7131 sym_op->auth.data.offset = 0;
7137 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
7138 struct crypto_unittest_params *ut_params,
7139 const struct test_crypto_vector *reference,
7140 unsigned int auth_generate)
7142 /* Generate Crypto op data structure */
7143 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7144 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7145 TEST_ASSERT_NOT_NULL(ut_params->op,
7146 "Failed to allocate pktmbuf offload");
7148 /* Set crypto operation data parameters */
7149 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7151 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7153 /* set crypto operation source mbuf */
7154 sym_op->m_src = ut_params->ibuf;
7157 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7158 ut_params->ibuf, reference->digest.len);
7160 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7161 "no room to append auth tag");
7163 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7164 ut_params->ibuf, reference->ciphertext.len);
7167 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7169 memcpy(sym_op->auth.digest.data,
7170 reference->digest.data,
7171 reference->digest.len);
7173 TEST_HEXDUMP(stdout, "digest:",
7174 sym_op->auth.digest.data,
7175 reference->digest.len);
7177 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
7178 reference->iv.data, reference->iv.len);
7180 sym_op->cipher.data.length = 0;
7181 sym_op->cipher.data.offset = 0;
7183 sym_op->auth.data.length = reference->plaintext.len;
7184 sym_op->auth.data.offset = 0;
7190 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
7191 struct crypto_unittest_params *ut_params,
7192 const struct test_crypto_vector *reference,
7193 unsigned int auth_generate)
7195 /* Generate Crypto op data structure */
7196 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7197 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7198 TEST_ASSERT_NOT_NULL(ut_params->op,
7199 "Failed to allocate pktmbuf offload");
7201 /* Set crypto operation data parameters */
7202 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7204 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7206 /* set crypto operation source mbuf */
7207 sym_op->m_src = ut_params->ibuf;
7210 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7211 ut_params->ibuf, reference->digest.len);
7213 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7214 "no room to append auth tag");
7216 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7217 ut_params->ibuf, reference->ciphertext.len);
7220 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7222 memcpy(sym_op->auth.digest.data,
7223 reference->digest.data,
7224 reference->digest.len);
7226 TEST_HEXDUMP(stdout, "digest:",
7227 sym_op->auth.digest.data,
7228 reference->digest.len);
7230 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
7231 reference->iv.data, reference->iv.len);
7233 sym_op->cipher.data.length = reference->ciphertext.len;
7234 sym_op->cipher.data.offset = 0;
7236 sym_op->auth.data.length = reference->ciphertext.len;
7237 sym_op->auth.data.offset = 0;
7243 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7244 struct crypto_unittest_params *ut_params,
7245 const struct test_crypto_vector *reference)
7247 return create_auth_operation(ts_params, ut_params, reference, 0);
7251 create_auth_verify_GMAC_operation(
7252 struct crypto_testsuite_params *ts_params,
7253 struct crypto_unittest_params *ut_params,
7254 const struct test_crypto_vector *reference)
7256 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
7260 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7261 struct crypto_unittest_params *ut_params,
7262 const struct test_crypto_vector *reference)
7264 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
7268 test_authentication_verify_fail_when_data_corruption(
7269 struct crypto_testsuite_params *ts_params,
7270 struct crypto_unittest_params *ut_params,
7271 const struct test_crypto_vector *reference,
7272 unsigned int data_corrupted)
7278 /* Create session */
7279 retval = create_auth_session(ut_params,
7280 ts_params->valid_devs[0],
7282 RTE_CRYPTO_AUTH_OP_VERIFY);
7286 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7287 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7288 "Failed to allocate input buffer in mempool");
7290 /* clear mbuf payload */
7291 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7292 rte_pktmbuf_tailroom(ut_params->ibuf));
7294 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7295 reference->plaintext.len);
7296 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7297 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7299 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7301 /* Create operation */
7302 retval = create_auth_verify_operation(ts_params, ut_params, reference);
7308 data_corruption(plaintext);
7310 tag_corruption(plaintext, reference->plaintext.len);
7312 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7314 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7315 TEST_ASSERT_EQUAL(ut_params->op->status,
7316 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7317 "authentication not failed");
7319 ut_params->obuf = ut_params->op->sym->m_src;
7320 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7326 test_authentication_verify_GMAC_fail_when_corruption(
7327 struct crypto_testsuite_params *ts_params,
7328 struct crypto_unittest_params *ut_params,
7329 const struct test_crypto_vector *reference,
7330 unsigned int data_corrupted)
7335 /* Create session */
7336 retval = create_auth_cipher_session(ut_params,
7337 ts_params->valid_devs[0],
7339 RTE_CRYPTO_AUTH_OP_VERIFY,
7340 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7344 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7345 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7346 "Failed to allocate input buffer in mempool");
7348 /* clear mbuf payload */
7349 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7350 rte_pktmbuf_tailroom(ut_params->ibuf));
7352 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7353 reference->plaintext.len);
7354 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7355 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7357 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7359 /* Create operation */
7360 retval = create_auth_verify_GMAC_operation(ts_params,
7368 data_corruption(plaintext);
7370 tag_corruption(plaintext, reference->aad.len);
7372 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7374 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7375 TEST_ASSERT_EQUAL(ut_params->op->status,
7376 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7377 "authentication not failed");
7379 ut_params->obuf = ut_params->op->sym->m_src;
7380 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7386 test_authenticated_decryption_fail_when_corruption(
7387 struct crypto_testsuite_params *ts_params,
7388 struct crypto_unittest_params *ut_params,
7389 const struct test_crypto_vector *reference,
7390 unsigned int data_corrupted)
7394 uint8_t *ciphertext;
7396 /* Create session */
7397 retval = create_auth_cipher_session(ut_params,
7398 ts_params->valid_devs[0],
7400 RTE_CRYPTO_AUTH_OP_VERIFY,
7401 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7405 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7406 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7407 "Failed to allocate input buffer in mempool");
7409 /* clear mbuf payload */
7410 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7411 rte_pktmbuf_tailroom(ut_params->ibuf));
7413 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7414 reference->ciphertext.len);
7415 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
7416 memcpy(ciphertext, reference->ciphertext.data,
7417 reference->ciphertext.len);
7419 /* Create operation */
7420 retval = create_cipher_auth_verify_operation(ts_params,
7428 data_corruption(ciphertext);
7430 tag_corruption(ciphertext, reference->ciphertext.len);
7432 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7435 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7436 TEST_ASSERT_EQUAL(ut_params->op->status,
7437 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7438 "authentication not failed");
7440 ut_params->obuf = ut_params->op->sym->m_src;
7441 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7447 create_gcm_operation_SGL(enum rte_crypto_aead_operation op,
7448 const struct gcm_test_data *tdata,
7449 void *digest_mem, uint64_t digest_phys)
7451 struct crypto_testsuite_params *ts_params = &testsuite_params;
7452 struct crypto_unittest_params *ut_params = &unittest_params;
7454 const unsigned int auth_tag_len = tdata->auth_tag.len;
7455 const unsigned int iv_len = tdata->iv.len;
7456 const unsigned int aad_len = tdata->aad.len;
7458 /* Generate Crypto op data structure */
7459 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7460 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7461 TEST_ASSERT_NOT_NULL(ut_params->op,
7462 "Failed to allocate symmetric crypto operation struct");
7464 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7466 sym_op->aead.digest.data = digest_mem;
7468 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7469 "no room to append digest");
7471 sym_op->aead.digest.phys_addr = digest_phys;
7473 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
7474 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7476 TEST_HEXDUMP(stdout, "digest:",
7477 sym_op->aead.digest.data,
7481 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7482 uint8_t *, IV_OFFSET);
7484 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
7486 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
7487 ut_params->ibuf, aad_len);
7488 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7489 "no room to prepend aad");
7490 sym_op->aead.aad.phys_addr = rte_pktmbuf_mtophys(
7493 memset(sym_op->aead.aad.data, 0, aad_len);
7494 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
7496 TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
7497 TEST_HEXDUMP(stdout, "aad:",
7498 sym_op->aead.aad.data, aad_len);
7500 sym_op->aead.data.length = tdata->plaintext.len;
7501 sym_op->aead.data.offset = aad_len;
7506 #define SGL_MAX_NO 16
7509 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
7510 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
7512 struct crypto_testsuite_params *ts_params = &testsuite_params;
7513 struct crypto_unittest_params *ut_params = &unittest_params;
7514 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
7517 int to_trn_tbl[SGL_MAX_NO];
7519 unsigned int trn_data = 0;
7520 uint8_t *plaintext, *ciphertext, *auth_tag;
7522 if (fragsz > tdata->plaintext.len)
7523 fragsz = tdata->plaintext.len;
7525 uint16_t plaintext_len = fragsz;
7526 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7528 if (fragsz_oop > tdata->plaintext.len)
7529 frag_size_oop = tdata->plaintext.len;
7532 void *digest_mem = NULL;
7534 uint32_t prepend_len = tdata->aad.len;
7536 if (tdata->plaintext.len % fragsz != 0) {
7537 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
7540 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
7545 * For out-op-place we need to alloc another mbuf
7548 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7549 rte_pktmbuf_append(ut_params->obuf,
7550 frag_size_oop + prepend_len);
7551 buf_oop = ut_params->obuf;
7554 /* Create GCM session */
7555 retval = create_gcm_session(ts_params->valid_devs[0],
7556 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7557 tdata->key.data, tdata->key.len,
7558 tdata->aad.len, tdata->auth_tag.len,
7563 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7565 /* clear mbuf payload */
7566 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7567 rte_pktmbuf_tailroom(ut_params->ibuf));
7569 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7572 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7574 trn_data += plaintext_len;
7576 buf = ut_params->ibuf;
7579 * Loop until no more fragments
7582 while (trn_data < tdata->plaintext.len) {
7584 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
7585 (tdata->plaintext.len - trn_data) : fragsz;
7587 to_trn_tbl[ecx++] = to_trn;
7589 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7592 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7593 rte_pktmbuf_tailroom(buf));
7596 if (oop && !fragsz_oop) {
7597 buf_last_oop = buf_oop->next =
7598 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7599 buf_oop = buf_oop->next;
7600 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7601 0, rte_pktmbuf_tailroom(buf_oop));
7602 rte_pktmbuf_append(buf_oop, to_trn);
7605 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7608 memcpy(plaintext, tdata->plaintext.data + trn_data,
7611 if (trn_data == tdata->plaintext.len) {
7614 digest_mem = rte_pktmbuf_append(buf_oop,
7615 tdata->auth_tag.len);
7617 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
7618 tdata->auth_tag.len);
7622 uint64_t digest_phys = 0;
7624 ut_params->ibuf->nb_segs = segs;
7627 if (fragsz_oop && oop) {
7631 if (frag_size_oop == tdata->plaintext.len) {
7632 digest_mem = rte_pktmbuf_append(ut_params->obuf,
7633 tdata->auth_tag.len);
7635 digest_phys = rte_pktmbuf_mtophys_offset(
7637 tdata->plaintext.len + prepend_len);
7640 trn_data = frag_size_oop;
7641 while (trn_data < tdata->plaintext.len) {
7644 (tdata->plaintext.len - trn_data <
7646 (tdata->plaintext.len - trn_data) :
7649 to_trn_tbl[ecx++] = to_trn;
7651 buf_last_oop = buf_oop->next =
7652 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7653 buf_oop = buf_oop->next;
7654 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7655 0, rte_pktmbuf_tailroom(buf_oop));
7656 rte_pktmbuf_append(buf_oop, to_trn);
7660 if (trn_data == tdata->plaintext.len) {
7661 digest_mem = rte_pktmbuf_append(buf_oop,
7662 tdata->auth_tag.len);
7666 ut_params->obuf->nb_segs = segs;
7670 * Place digest at the end of the last buffer
7673 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
7674 if (oop && buf_last_oop)
7675 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
7677 if (!digest_mem && !oop) {
7678 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7679 + tdata->auth_tag.len);
7680 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
7681 tdata->plaintext.len);
7684 /* Create GCM opertaion */
7685 retval = create_gcm_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
7686 tdata, digest_mem, digest_phys);
7691 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7693 ut_params->op->sym->m_src = ut_params->ibuf;
7695 ut_params->op->sym->m_dst = ut_params->obuf;
7697 /* Process crypto operation */
7698 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7699 ut_params->op), "failed to process sym crypto op");
7701 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7702 "crypto op processing failed");
7705 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7706 uint8_t *, prepend_len);
7708 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7709 uint8_t *, prepend_len);
7713 fragsz = fragsz_oop;
7715 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7717 tdata->ciphertext.data,
7719 "GCM Ciphertext data not as expected");
7721 buf = ut_params->op->sym->m_src->next;
7723 buf = ut_params->op->sym->m_dst->next;
7725 unsigned int off = fragsz;
7729 ciphertext = rte_pktmbuf_mtod(buf,
7732 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7734 tdata->ciphertext.data + off,
7736 "GCM Ciphertext data not as expected");
7738 off += to_trn_tbl[ecx++];
7742 auth_tag = digest_mem;
7743 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7745 tdata->auth_tag.data,
7746 tdata->auth_tag.len,
7747 "GCM Generated auth tag not as expected");
7753 #define OUT_OF_PLACE 1
7756 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
7758 return test_AES_GCM_authenticated_encryption_SGL(
7759 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
7763 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
7765 return test_AES_GCM_authenticated_encryption_SGL(
7766 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
7770 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
7772 return test_AES_GCM_authenticated_encryption_SGL(
7773 &gcm_test_case_8, OUT_OF_PLACE, 400,
7774 gcm_test_case_8.plaintext.len);
7778 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
7781 return test_AES_GCM_authenticated_encryption_SGL(
7782 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
7786 test_authentication_verify_fail_when_data_corrupted(
7787 struct crypto_testsuite_params *ts_params,
7788 struct crypto_unittest_params *ut_params,
7789 const struct test_crypto_vector *reference)
7791 return test_authentication_verify_fail_when_data_corruption(
7792 ts_params, ut_params, reference, 1);
7796 test_authentication_verify_fail_when_tag_corrupted(
7797 struct crypto_testsuite_params *ts_params,
7798 struct crypto_unittest_params *ut_params,
7799 const struct test_crypto_vector *reference)
7801 return test_authentication_verify_fail_when_data_corruption(
7802 ts_params, ut_params, reference, 0);
7806 test_authentication_verify_GMAC_fail_when_data_corrupted(
7807 struct crypto_testsuite_params *ts_params,
7808 struct crypto_unittest_params *ut_params,
7809 const struct test_crypto_vector *reference)
7811 return test_authentication_verify_GMAC_fail_when_corruption(
7812 ts_params, ut_params, reference, 1);
7816 test_authentication_verify_GMAC_fail_when_tag_corrupted(
7817 struct crypto_testsuite_params *ts_params,
7818 struct crypto_unittest_params *ut_params,
7819 const struct test_crypto_vector *reference)
7821 return test_authentication_verify_GMAC_fail_when_corruption(
7822 ts_params, ut_params, reference, 0);
7826 test_authenticated_decryption_fail_when_data_corrupted(
7827 struct crypto_testsuite_params *ts_params,
7828 struct crypto_unittest_params *ut_params,
7829 const struct test_crypto_vector *reference)
7831 return test_authenticated_decryption_fail_when_corruption(
7832 ts_params, ut_params, reference, 1);
7836 test_authenticated_decryption_fail_when_tag_corrupted(
7837 struct crypto_testsuite_params *ts_params,
7838 struct crypto_unittest_params *ut_params,
7839 const struct test_crypto_vector *reference)
7841 return test_authenticated_decryption_fail_when_corruption(
7842 ts_params, ut_params, reference, 0);
7846 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
7848 return test_authentication_verify_fail_when_data_corrupted(
7849 &testsuite_params, &unittest_params,
7850 &hmac_sha1_test_crypto_vector);
7854 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
7856 return test_authentication_verify_fail_when_tag_corrupted(
7857 &testsuite_params, &unittest_params,
7858 &hmac_sha1_test_crypto_vector);
7862 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
7864 return test_authentication_verify_GMAC_fail_when_data_corrupted(
7865 &testsuite_params, &unittest_params,
7866 &aes128_gmac_test_vector);
7870 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
7872 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
7873 &testsuite_params, &unittest_params,
7874 &aes128_gmac_test_vector);
7878 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
7880 return test_authenticated_decryption_fail_when_data_corrupted(
7883 &aes128cbc_hmac_sha1_test_vector);
7887 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
7889 return test_authenticated_decryption_fail_when_tag_corrupted(
7892 &aes128cbc_hmac_sha1_test_vector);
7895 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
7897 /* global AESNI slave IDs for the scheduler test */
7898 uint8_t aesni_ids[2];
7901 test_scheduler_attach_slave_op(void)
7903 struct crypto_testsuite_params *ts_params = &testsuite_params;
7904 uint8_t sched_id = ts_params->valid_devs[0];
7905 uint32_t nb_devs, i, nb_devs_attached = 0;
7909 /* create 2 AESNI_MB if necessary */
7910 nb_devs = rte_cryptodev_device_count_by_driver(
7911 rte_cryptodev_driver_id_get(
7912 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
7914 for (i = nb_devs; i < 2; i++) {
7915 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
7916 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
7918 ret = rte_vdev_init(vdev_name, NULL);
7920 TEST_ASSERT(ret == 0,
7921 "Failed to create instance %u of"
7923 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7927 /* attach 2 AESNI_MB cdevs */
7928 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
7930 struct rte_cryptodev_info info;
7932 rte_cryptodev_info_get(i, &info);
7933 if (info.driver_id != rte_cryptodev_driver_id_get(
7934 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
7938 * Create the session mempool again, since now there are new devices
7939 * to use the mempool.
7941 if (ts_params->session_mpool) {
7942 rte_mempool_free(ts_params->session_mpool);
7943 ts_params->session_mpool = NULL;
7945 unsigned int session_size = rte_cryptodev_get_private_session_size(i);
7948 * Create mempool with maximum number of sessions * 2,
7949 * to include the session headers
7951 if (ts_params->session_mpool == NULL) {
7952 ts_params->session_mpool = rte_mempool_create(
7954 info.sym.max_nb_sessions * 2,
7956 0, 0, NULL, NULL, NULL,
7957 NULL, SOCKET_ID_ANY,
7960 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
7961 "session mempool allocation failed");
7964 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
7967 TEST_ASSERT(ret == 0,
7968 "Failed to attach device %u of pmd : %s", i,
7969 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7971 aesni_ids[nb_devs_attached] = (uint8_t)i;
7980 test_scheduler_detach_slave_op(void)
7982 struct crypto_testsuite_params *ts_params = &testsuite_params;
7983 uint8_t sched_id = ts_params->valid_devs[0];
7987 for (i = 0; i < 2; i++) {
7988 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
7990 TEST_ASSERT(ret == 0,
7991 "Failed to detach device %u", aesni_ids[i]);
7998 test_scheduler_mode_op(void)
8000 struct crypto_testsuite_params *ts_params = &testsuite_params;
8001 uint8_t sched_id = ts_params->valid_devs[0];
8002 struct rte_cryptodev_scheduler_ops op = {0};
8003 struct rte_cryptodev_scheduler dummy_scheduler = {
8004 .description = "dummy scheduler to test mode",
8005 .name = "dummy scheduler",
8006 .mode = CDEV_SCHED_MODE_USERDEFINED,
8011 /* set user defined mode */
8012 ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
8014 TEST_ASSERT(ret == 0,
8015 "Failed to set cdev %u to user defined mode", sched_id);
8017 /* set round robin mode */
8018 ret = rte_cryptodev_scheduler_mode_set(sched_id,
8019 CDEV_SCHED_MODE_ROUNDROBIN);
8020 TEST_ASSERT(ret == 0,
8021 "Failed to set cdev %u to round-robin mode", sched_id);
8022 TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) ==
8023 CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
8029 static struct unit_test_suite cryptodev_scheduler_testsuite = {
8030 .suite_name = "Crypto Device Scheduler Unit Test Suite",
8031 .setup = testsuite_setup,
8032 .teardown = testsuite_teardown,
8033 .unit_test_cases = {
8034 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
8035 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
8036 TEST_CASE_ST(ut_setup, ut_teardown,
8037 test_AES_chain_scheduler_all),
8038 TEST_CASE_ST(ut_setup, ut_teardown,
8039 test_AES_cipheronly_scheduler_all),
8040 TEST_CASE_ST(ut_setup, ut_teardown,
8041 test_authonly_scheduler_all),
8042 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8043 TEST_CASES_END() /**< NULL terminate unit test array */
8047 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
8049 static struct unit_test_suite cryptodev_qat_testsuite = {
8050 .suite_name = "Crypto QAT Unit Test Suite",
8051 .setup = testsuite_setup,
8052 .teardown = testsuite_teardown,
8053 .unit_test_cases = {
8054 TEST_CASE_ST(ut_setup, ut_teardown,
8055 test_device_configure_invalid_dev_id),
8056 TEST_CASE_ST(ut_setup, ut_teardown,
8057 test_device_configure_invalid_queue_pair_ids),
8058 TEST_CASE_ST(ut_setup, ut_teardown,
8059 test_queue_pair_descriptor_setup),
8060 TEST_CASE_ST(ut_setup, ut_teardown,
8061 test_multi_session),
8063 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
8064 TEST_CASE_ST(ut_setup, ut_teardown,
8065 test_AES_cipheronly_qat_all),
8066 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
8067 TEST_CASE_ST(ut_setup, ut_teardown,
8068 test_3DES_cipheronly_qat_all),
8069 TEST_CASE_ST(ut_setup, ut_teardown,
8070 test_DES_cipheronly_qat_all),
8071 TEST_CASE_ST(ut_setup, ut_teardown,
8072 test_AES_docsis_qat_all),
8073 TEST_CASE_ST(ut_setup, ut_teardown,
8074 test_DES_docsis_qat_all),
8075 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
8076 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
8078 /** AES GCM Authenticated Encryption */
8079 TEST_CASE_ST(ut_setup, ut_teardown,
8080 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
8081 TEST_CASE_ST(ut_setup, ut_teardown,
8082 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
8083 TEST_CASE_ST(ut_setup, ut_teardown,
8084 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
8085 TEST_CASE_ST(ut_setup, ut_teardown,
8086 test_AES_GCM_authenticated_encryption_test_case_1),
8087 TEST_CASE_ST(ut_setup, ut_teardown,
8088 test_AES_GCM_authenticated_encryption_test_case_2),
8089 TEST_CASE_ST(ut_setup, ut_teardown,
8090 test_AES_GCM_authenticated_encryption_test_case_3),
8091 TEST_CASE_ST(ut_setup, ut_teardown,
8092 test_AES_GCM_authenticated_encryption_test_case_4),
8093 TEST_CASE_ST(ut_setup, ut_teardown,
8094 test_AES_GCM_authenticated_encryption_test_case_5),
8095 TEST_CASE_ST(ut_setup, ut_teardown,
8096 test_AES_GCM_authenticated_encryption_test_case_6),
8097 TEST_CASE_ST(ut_setup, ut_teardown,
8098 test_AES_GCM_authenticated_encryption_test_case_7),
8100 /** AES GCM Authenticated Decryption */
8101 TEST_CASE_ST(ut_setup, ut_teardown,
8102 test_AES_GCM_authenticated_decryption_test_case_1),
8103 TEST_CASE_ST(ut_setup, ut_teardown,
8104 test_AES_GCM_authenticated_decryption_test_case_2),
8105 TEST_CASE_ST(ut_setup, ut_teardown,
8106 test_AES_GCM_authenticated_decryption_test_case_3),
8107 TEST_CASE_ST(ut_setup, ut_teardown,
8108 test_AES_GCM_authenticated_decryption_test_case_4),
8109 TEST_CASE_ST(ut_setup, ut_teardown,
8110 test_AES_GCM_authenticated_decryption_test_case_5),
8111 TEST_CASE_ST(ut_setup, ut_teardown,
8112 test_AES_GCM_authenticated_decryption_test_case_6),
8113 TEST_CASE_ST(ut_setup, ut_teardown,
8114 test_AES_GCM_authenticated_decryption_test_case_7),
8116 /** AES GCM Authenticated Encryption 192 bits key */
8117 TEST_CASE_ST(ut_setup, ut_teardown,
8118 test_AES_GCM_auth_encryption_test_case_192_1),
8119 TEST_CASE_ST(ut_setup, ut_teardown,
8120 test_AES_GCM_auth_encryption_test_case_192_2),
8121 TEST_CASE_ST(ut_setup, ut_teardown,
8122 test_AES_GCM_auth_encryption_test_case_192_3),
8123 TEST_CASE_ST(ut_setup, ut_teardown,
8124 test_AES_GCM_auth_encryption_test_case_192_4),
8125 TEST_CASE_ST(ut_setup, ut_teardown,
8126 test_AES_GCM_auth_encryption_test_case_192_5),
8127 TEST_CASE_ST(ut_setup, ut_teardown,
8128 test_AES_GCM_auth_encryption_test_case_192_6),
8129 TEST_CASE_ST(ut_setup, ut_teardown,
8130 test_AES_GCM_auth_encryption_test_case_192_7),
8132 /** AES GCM Authenticated Decryption 192 bits key */
8133 TEST_CASE_ST(ut_setup, ut_teardown,
8134 test_AES_GCM_auth_decryption_test_case_192_1),
8135 TEST_CASE_ST(ut_setup, ut_teardown,
8136 test_AES_GCM_auth_decryption_test_case_192_2),
8137 TEST_CASE_ST(ut_setup, ut_teardown,
8138 test_AES_GCM_auth_decryption_test_case_192_3),
8139 TEST_CASE_ST(ut_setup, ut_teardown,
8140 test_AES_GCM_auth_decryption_test_case_192_4),
8141 TEST_CASE_ST(ut_setup, ut_teardown,
8142 test_AES_GCM_auth_decryption_test_case_192_5),
8143 TEST_CASE_ST(ut_setup, ut_teardown,
8144 test_AES_GCM_auth_decryption_test_case_192_6),
8145 TEST_CASE_ST(ut_setup, ut_teardown,
8146 test_AES_GCM_auth_decryption_test_case_192_7),
8148 /** AES GCM Authenticated Encryption 256 bits key */
8149 TEST_CASE_ST(ut_setup, ut_teardown,
8150 test_AES_GCM_auth_encryption_test_case_256_1),
8151 TEST_CASE_ST(ut_setup, ut_teardown,
8152 test_AES_GCM_auth_encryption_test_case_256_2),
8153 TEST_CASE_ST(ut_setup, ut_teardown,
8154 test_AES_GCM_auth_encryption_test_case_256_3),
8155 TEST_CASE_ST(ut_setup, ut_teardown,
8156 test_AES_GCM_auth_encryption_test_case_256_4),
8157 TEST_CASE_ST(ut_setup, ut_teardown,
8158 test_AES_GCM_auth_encryption_test_case_256_5),
8159 TEST_CASE_ST(ut_setup, ut_teardown,
8160 test_AES_GCM_auth_encryption_test_case_256_6),
8161 TEST_CASE_ST(ut_setup, ut_teardown,
8162 test_AES_GCM_auth_encryption_test_case_256_7),
8164 /** AES GMAC Authentication */
8165 TEST_CASE_ST(ut_setup, ut_teardown,
8166 test_AES_GMAC_authentication_test_case_1),
8167 TEST_CASE_ST(ut_setup, ut_teardown,
8168 test_AES_GMAC_authentication_verify_test_case_1),
8169 TEST_CASE_ST(ut_setup, ut_teardown,
8170 test_AES_GMAC_authentication_test_case_2),
8171 TEST_CASE_ST(ut_setup, ut_teardown,
8172 test_AES_GMAC_authentication_verify_test_case_2),
8173 TEST_CASE_ST(ut_setup, ut_teardown,
8174 test_AES_GMAC_authentication_test_case_3),
8175 TEST_CASE_ST(ut_setup, ut_teardown,
8176 test_AES_GMAC_authentication_verify_test_case_3),
8178 /** SNOW 3G encrypt only (UEA2) */
8179 TEST_CASE_ST(ut_setup, ut_teardown,
8180 test_snow3g_encryption_test_case_1),
8181 TEST_CASE_ST(ut_setup, ut_teardown,
8182 test_snow3g_encryption_test_case_2),
8183 TEST_CASE_ST(ut_setup, ut_teardown,
8184 test_snow3g_encryption_test_case_3),
8185 TEST_CASE_ST(ut_setup, ut_teardown,
8186 test_snow3g_encryption_test_case_4),
8187 TEST_CASE_ST(ut_setup, ut_teardown,
8188 test_snow3g_encryption_test_case_5),
8190 TEST_CASE_ST(ut_setup, ut_teardown,
8191 test_snow3g_encryption_test_case_1_oop),
8192 TEST_CASE_ST(ut_setup, ut_teardown,
8193 test_snow3g_decryption_test_case_1_oop),
8195 /** SNOW 3G decrypt only (UEA2) */
8196 TEST_CASE_ST(ut_setup, ut_teardown,
8197 test_snow3g_decryption_test_case_1),
8198 TEST_CASE_ST(ut_setup, ut_teardown,
8199 test_snow3g_decryption_test_case_2),
8200 TEST_CASE_ST(ut_setup, ut_teardown,
8201 test_snow3g_decryption_test_case_3),
8202 TEST_CASE_ST(ut_setup, ut_teardown,
8203 test_snow3g_decryption_test_case_4),
8204 TEST_CASE_ST(ut_setup, ut_teardown,
8205 test_snow3g_decryption_test_case_5),
8206 TEST_CASE_ST(ut_setup, ut_teardown,
8207 test_snow3g_hash_generate_test_case_1),
8208 TEST_CASE_ST(ut_setup, ut_teardown,
8209 test_snow3g_hash_generate_test_case_2),
8210 TEST_CASE_ST(ut_setup, ut_teardown,
8211 test_snow3g_hash_generate_test_case_3),
8212 TEST_CASE_ST(ut_setup, ut_teardown,
8213 test_snow3g_hash_verify_test_case_1),
8214 TEST_CASE_ST(ut_setup, ut_teardown,
8215 test_snow3g_hash_verify_test_case_2),
8216 TEST_CASE_ST(ut_setup, ut_teardown,
8217 test_snow3g_hash_verify_test_case_3),
8218 TEST_CASE_ST(ut_setup, ut_teardown,
8219 test_snow3g_cipher_auth_test_case_1),
8220 TEST_CASE_ST(ut_setup, ut_teardown,
8221 test_snow3g_auth_cipher_test_case_1),
8223 /** ZUC encrypt only (EEA3) */
8224 TEST_CASE_ST(ut_setup, ut_teardown,
8225 test_zuc_encryption_test_case_1),
8226 TEST_CASE_ST(ut_setup, ut_teardown,
8227 test_zuc_encryption_test_case_2),
8228 TEST_CASE_ST(ut_setup, ut_teardown,
8229 test_zuc_encryption_test_case_3),
8230 TEST_CASE_ST(ut_setup, ut_teardown,
8231 test_zuc_encryption_test_case_4),
8232 TEST_CASE_ST(ut_setup, ut_teardown,
8233 test_zuc_encryption_test_case_5),
8235 /** ZUC authenticate (EIA3) */
8236 TEST_CASE_ST(ut_setup, ut_teardown,
8237 test_zuc_hash_generate_test_case_6),
8238 TEST_CASE_ST(ut_setup, ut_teardown,
8239 test_zuc_hash_generate_test_case_7),
8240 TEST_CASE_ST(ut_setup, ut_teardown,
8241 test_zuc_hash_generate_test_case_8),
8243 /** ZUC alg-chain (EEA3/EIA3) */
8244 TEST_CASE_ST(ut_setup, ut_teardown,
8245 test_zuc_cipher_auth_test_case_1),
8246 TEST_CASE_ST(ut_setup, ut_teardown,
8247 test_zuc_cipher_auth_test_case_2),
8249 /** HMAC_MD5 Authentication */
8250 TEST_CASE_ST(ut_setup, ut_teardown,
8251 test_MD5_HMAC_generate_case_1),
8252 TEST_CASE_ST(ut_setup, ut_teardown,
8253 test_MD5_HMAC_verify_case_1),
8254 TEST_CASE_ST(ut_setup, ut_teardown,
8255 test_MD5_HMAC_generate_case_2),
8256 TEST_CASE_ST(ut_setup, ut_teardown,
8257 test_MD5_HMAC_verify_case_2),
8260 TEST_CASE_ST(ut_setup, ut_teardown,
8261 test_null_auth_only_operation),
8262 TEST_CASE_ST(ut_setup, ut_teardown,
8263 test_null_cipher_only_operation),
8264 TEST_CASE_ST(ut_setup, ut_teardown,
8265 test_null_cipher_auth_operation),
8266 TEST_CASE_ST(ut_setup, ut_teardown,
8267 test_null_auth_cipher_operation),
8270 TEST_CASE_ST(ut_setup, ut_teardown,
8271 test_kasumi_hash_generate_test_case_1),
8272 TEST_CASE_ST(ut_setup, ut_teardown,
8273 test_kasumi_hash_generate_test_case_2),
8274 TEST_CASE_ST(ut_setup, ut_teardown,
8275 test_kasumi_hash_generate_test_case_3),
8276 TEST_CASE_ST(ut_setup, ut_teardown,
8277 test_kasumi_hash_generate_test_case_4),
8278 TEST_CASE_ST(ut_setup, ut_teardown,
8279 test_kasumi_hash_generate_test_case_5),
8280 TEST_CASE_ST(ut_setup, ut_teardown,
8281 test_kasumi_hash_generate_test_case_6),
8283 TEST_CASE_ST(ut_setup, ut_teardown,
8284 test_kasumi_hash_verify_test_case_1),
8285 TEST_CASE_ST(ut_setup, ut_teardown,
8286 test_kasumi_hash_verify_test_case_2),
8287 TEST_CASE_ST(ut_setup, ut_teardown,
8288 test_kasumi_hash_verify_test_case_3),
8289 TEST_CASE_ST(ut_setup, ut_teardown,
8290 test_kasumi_hash_verify_test_case_4),
8291 TEST_CASE_ST(ut_setup, ut_teardown,
8292 test_kasumi_hash_verify_test_case_5),
8294 TEST_CASE_ST(ut_setup, ut_teardown,
8295 test_kasumi_encryption_test_case_1),
8296 TEST_CASE_ST(ut_setup, ut_teardown,
8297 test_kasumi_encryption_test_case_3),
8298 TEST_CASE_ST(ut_setup, ut_teardown,
8299 test_kasumi_auth_cipher_test_case_1),
8300 TEST_CASE_ST(ut_setup, ut_teardown,
8301 test_kasumi_cipher_auth_test_case_1),
8303 /** Negative tests */
8304 TEST_CASE_ST(ut_setup, ut_teardown,
8305 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8306 TEST_CASE_ST(ut_setup, ut_teardown,
8307 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8308 TEST_CASE_ST(ut_setup, ut_teardown,
8309 authentication_verify_AES128_GMAC_fail_data_corrupt),
8310 TEST_CASE_ST(ut_setup, ut_teardown,
8311 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8312 TEST_CASE_ST(ut_setup, ut_teardown,
8313 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8314 TEST_CASE_ST(ut_setup, ut_teardown,
8315 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8317 TEST_CASES_END() /**< NULL terminate unit test array */
8321 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
8322 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
8323 .setup = testsuite_setup,
8324 .teardown = testsuite_teardown,
8325 .unit_test_cases = {
8326 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
8327 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
8328 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
8329 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
8330 TEST_CASE_ST(ut_setup, ut_teardown,
8331 test_DES_cipheronly_mb_all),
8332 TEST_CASE_ST(ut_setup, ut_teardown,
8333 test_DES_docsis_mb_all),
8335 TEST_CASES_END() /**< NULL terminate unit test array */
8339 static struct unit_test_suite cryptodev_openssl_testsuite = {
8340 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
8341 .setup = testsuite_setup,
8342 .teardown = testsuite_teardown,
8343 .unit_test_cases = {
8344 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
8345 TEST_CASE_ST(ut_setup, ut_teardown,
8346 test_multi_session_random_usage),
8347 TEST_CASE_ST(ut_setup, ut_teardown,
8348 test_AES_chain_openssl_all),
8349 TEST_CASE_ST(ut_setup, ut_teardown,
8350 test_AES_cipheronly_openssl_all),
8351 TEST_CASE_ST(ut_setup, ut_teardown,
8352 test_3DES_chain_openssl_all),
8353 TEST_CASE_ST(ut_setup, ut_teardown,
8354 test_3DES_cipheronly_openssl_all),
8355 TEST_CASE_ST(ut_setup, ut_teardown,
8356 test_DES_docsis_openssl_all),
8357 TEST_CASE_ST(ut_setup, ut_teardown,
8358 test_authonly_openssl_all),
8360 /** AES GCM Authenticated Encryption */
8361 TEST_CASE_ST(ut_setup, ut_teardown,
8362 test_AES_GCM_authenticated_encryption_test_case_1),
8363 TEST_CASE_ST(ut_setup, ut_teardown,
8364 test_AES_GCM_authenticated_encryption_test_case_2),
8365 TEST_CASE_ST(ut_setup, ut_teardown,
8366 test_AES_GCM_authenticated_encryption_test_case_3),
8367 TEST_CASE_ST(ut_setup, ut_teardown,
8368 test_AES_GCM_authenticated_encryption_test_case_4),
8369 TEST_CASE_ST(ut_setup, ut_teardown,
8370 test_AES_GCM_authenticated_encryption_test_case_5),
8371 TEST_CASE_ST(ut_setup, ut_teardown,
8372 test_AES_GCM_authenticated_encryption_test_case_6),
8373 TEST_CASE_ST(ut_setup, ut_teardown,
8374 test_AES_GCM_authenticated_encryption_test_case_7),
8376 /** AES GCM Authenticated Decryption */
8377 TEST_CASE_ST(ut_setup, ut_teardown,
8378 test_AES_GCM_authenticated_decryption_test_case_1),
8379 TEST_CASE_ST(ut_setup, ut_teardown,
8380 test_AES_GCM_authenticated_decryption_test_case_2),
8381 TEST_CASE_ST(ut_setup, ut_teardown,
8382 test_AES_GCM_authenticated_decryption_test_case_3),
8383 TEST_CASE_ST(ut_setup, ut_teardown,
8384 test_AES_GCM_authenticated_decryption_test_case_4),
8385 TEST_CASE_ST(ut_setup, ut_teardown,
8386 test_AES_GCM_authenticated_decryption_test_case_5),
8387 TEST_CASE_ST(ut_setup, ut_teardown,
8388 test_AES_GCM_authenticated_decryption_test_case_6),
8389 TEST_CASE_ST(ut_setup, ut_teardown,
8390 test_AES_GCM_authenticated_decryption_test_case_7),
8393 /** AES GCM Authenticated Encryption 192 bits key */
8394 TEST_CASE_ST(ut_setup, ut_teardown,
8395 test_AES_GCM_auth_encryption_test_case_192_1),
8396 TEST_CASE_ST(ut_setup, ut_teardown,
8397 test_AES_GCM_auth_encryption_test_case_192_2),
8398 TEST_CASE_ST(ut_setup, ut_teardown,
8399 test_AES_GCM_auth_encryption_test_case_192_3),
8400 TEST_CASE_ST(ut_setup, ut_teardown,
8401 test_AES_GCM_auth_encryption_test_case_192_4),
8402 TEST_CASE_ST(ut_setup, ut_teardown,
8403 test_AES_GCM_auth_encryption_test_case_192_5),
8404 TEST_CASE_ST(ut_setup, ut_teardown,
8405 test_AES_GCM_auth_encryption_test_case_192_6),
8406 TEST_CASE_ST(ut_setup, ut_teardown,
8407 test_AES_GCM_auth_encryption_test_case_192_7),
8409 /** AES GCM Authenticated Decryption 192 bits key */
8410 TEST_CASE_ST(ut_setup, ut_teardown,
8411 test_AES_GCM_auth_decryption_test_case_192_1),
8412 TEST_CASE_ST(ut_setup, ut_teardown,
8413 test_AES_GCM_auth_decryption_test_case_192_2),
8414 TEST_CASE_ST(ut_setup, ut_teardown,
8415 test_AES_GCM_auth_decryption_test_case_192_3),
8416 TEST_CASE_ST(ut_setup, ut_teardown,
8417 test_AES_GCM_auth_decryption_test_case_192_4),
8418 TEST_CASE_ST(ut_setup, ut_teardown,
8419 test_AES_GCM_auth_decryption_test_case_192_5),
8420 TEST_CASE_ST(ut_setup, ut_teardown,
8421 test_AES_GCM_auth_decryption_test_case_192_6),
8422 TEST_CASE_ST(ut_setup, ut_teardown,
8423 test_AES_GCM_auth_decryption_test_case_192_7),
8425 /** AES GCM Authenticated Encryption 256 bits key */
8426 TEST_CASE_ST(ut_setup, ut_teardown,
8427 test_AES_GCM_auth_encryption_test_case_256_1),
8428 TEST_CASE_ST(ut_setup, ut_teardown,
8429 test_AES_GCM_auth_encryption_test_case_256_2),
8430 TEST_CASE_ST(ut_setup, ut_teardown,
8431 test_AES_GCM_auth_encryption_test_case_256_3),
8432 TEST_CASE_ST(ut_setup, ut_teardown,
8433 test_AES_GCM_auth_encryption_test_case_256_4),
8434 TEST_CASE_ST(ut_setup, ut_teardown,
8435 test_AES_GCM_auth_encryption_test_case_256_5),
8436 TEST_CASE_ST(ut_setup, ut_teardown,
8437 test_AES_GCM_auth_encryption_test_case_256_6),
8438 TEST_CASE_ST(ut_setup, ut_teardown,
8439 test_AES_GCM_auth_encryption_test_case_256_7),
8441 /** AES GCM Authenticated Decryption 256 bits key */
8442 TEST_CASE_ST(ut_setup, ut_teardown,
8443 test_AES_GCM_auth_decryption_test_case_256_1),
8444 TEST_CASE_ST(ut_setup, ut_teardown,
8445 test_AES_GCM_auth_decryption_test_case_256_2),
8446 TEST_CASE_ST(ut_setup, ut_teardown,
8447 test_AES_GCM_auth_decryption_test_case_256_3),
8448 TEST_CASE_ST(ut_setup, ut_teardown,
8449 test_AES_GCM_auth_decryption_test_case_256_4),
8450 TEST_CASE_ST(ut_setup, ut_teardown,
8451 test_AES_GCM_auth_decryption_test_case_256_5),
8452 TEST_CASE_ST(ut_setup, ut_teardown,
8453 test_AES_GCM_auth_decryption_test_case_256_6),
8454 TEST_CASE_ST(ut_setup, ut_teardown,
8455 test_AES_GCM_auth_decryption_test_case_256_7),
8457 /** AES GMAC Authentication */
8458 TEST_CASE_ST(ut_setup, ut_teardown,
8459 test_AES_GMAC_authentication_test_case_1),
8460 TEST_CASE_ST(ut_setup, ut_teardown,
8461 test_AES_GMAC_authentication_verify_test_case_1),
8462 TEST_CASE_ST(ut_setup, ut_teardown,
8463 test_AES_GMAC_authentication_test_case_2),
8464 TEST_CASE_ST(ut_setup, ut_teardown,
8465 test_AES_GMAC_authentication_verify_test_case_2),
8466 TEST_CASE_ST(ut_setup, ut_teardown,
8467 test_AES_GMAC_authentication_test_case_3),
8468 TEST_CASE_ST(ut_setup, ut_teardown,
8469 test_AES_GMAC_authentication_verify_test_case_3),
8470 TEST_CASE_ST(ut_setup, ut_teardown,
8471 test_AES_GMAC_authentication_test_case_4),
8472 TEST_CASE_ST(ut_setup, ut_teardown,
8473 test_AES_GMAC_authentication_verify_test_case_4),
8475 /** Scatter-Gather */
8476 TEST_CASE_ST(ut_setup, ut_teardown,
8477 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8479 /** Negative tests */
8480 TEST_CASE_ST(ut_setup, ut_teardown,
8481 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8482 TEST_CASE_ST(ut_setup, ut_teardown,
8483 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8484 TEST_CASE_ST(ut_setup, ut_teardown,
8485 authentication_verify_AES128_GMAC_fail_data_corrupt),
8486 TEST_CASE_ST(ut_setup, ut_teardown,
8487 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8488 TEST_CASE_ST(ut_setup, ut_teardown,
8489 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8490 TEST_CASE_ST(ut_setup, ut_teardown,
8491 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8493 TEST_CASES_END() /**< NULL terminate unit test array */
8497 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
8498 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
8499 .setup = testsuite_setup,
8500 .teardown = testsuite_teardown,
8501 .unit_test_cases = {
8502 /** AES GCM Authenticated Encryption */
8503 TEST_CASE_ST(ut_setup, ut_teardown,
8504 test_AES_GCM_authenticated_encryption_test_case_1),
8505 TEST_CASE_ST(ut_setup, ut_teardown,
8506 test_AES_GCM_authenticated_encryption_test_case_2),
8507 TEST_CASE_ST(ut_setup, ut_teardown,
8508 test_AES_GCM_authenticated_encryption_test_case_3),
8509 TEST_CASE_ST(ut_setup, ut_teardown,
8510 test_AES_GCM_authenticated_encryption_test_case_4),
8511 TEST_CASE_ST(ut_setup, ut_teardown,
8512 test_AES_GCM_authenticated_encryption_test_case_5),
8513 TEST_CASE_ST(ut_setup, ut_teardown,
8514 test_AES_GCM_authenticated_encryption_test_case_6),
8515 TEST_CASE_ST(ut_setup, ut_teardown,
8516 test_AES_GCM_authenticated_encryption_test_case_7),
8518 /** AES GCM Authenticated Decryption */
8519 TEST_CASE_ST(ut_setup, ut_teardown,
8520 test_AES_GCM_authenticated_decryption_test_case_1),
8521 TEST_CASE_ST(ut_setup, ut_teardown,
8522 test_AES_GCM_authenticated_decryption_test_case_2),
8523 TEST_CASE_ST(ut_setup, ut_teardown,
8524 test_AES_GCM_authenticated_decryption_test_case_3),
8525 TEST_CASE_ST(ut_setup, ut_teardown,
8526 test_AES_GCM_authenticated_decryption_test_case_4),
8527 TEST_CASE_ST(ut_setup, ut_teardown,
8528 test_AES_GCM_authenticated_decryption_test_case_5),
8529 TEST_CASE_ST(ut_setup, ut_teardown,
8530 test_AES_GCM_authenticated_decryption_test_case_6),
8531 TEST_CASE_ST(ut_setup, ut_teardown,
8532 test_AES_GCM_authenticated_decryption_test_case_7),
8534 /** AES GCM Authenticated Encryption 192 bits key */
8535 TEST_CASE_ST(ut_setup, ut_teardown,
8536 test_AES_GCM_auth_encryption_test_case_192_1),
8537 TEST_CASE_ST(ut_setup, ut_teardown,
8538 test_AES_GCM_auth_encryption_test_case_192_2),
8539 TEST_CASE_ST(ut_setup, ut_teardown,
8540 test_AES_GCM_auth_encryption_test_case_192_3),
8541 TEST_CASE_ST(ut_setup, ut_teardown,
8542 test_AES_GCM_auth_encryption_test_case_192_4),
8543 TEST_CASE_ST(ut_setup, ut_teardown,
8544 test_AES_GCM_auth_encryption_test_case_192_5),
8545 TEST_CASE_ST(ut_setup, ut_teardown,
8546 test_AES_GCM_auth_encryption_test_case_192_6),
8547 TEST_CASE_ST(ut_setup, ut_teardown,
8548 test_AES_GCM_auth_encryption_test_case_192_7),
8550 /** AES GCM Authenticated Decryption 192 bits key */
8551 TEST_CASE_ST(ut_setup, ut_teardown,
8552 test_AES_GCM_auth_decryption_test_case_192_1),
8553 TEST_CASE_ST(ut_setup, ut_teardown,
8554 test_AES_GCM_auth_decryption_test_case_192_2),
8555 TEST_CASE_ST(ut_setup, ut_teardown,
8556 test_AES_GCM_auth_decryption_test_case_192_3),
8557 TEST_CASE_ST(ut_setup, ut_teardown,
8558 test_AES_GCM_auth_decryption_test_case_192_4),
8559 TEST_CASE_ST(ut_setup, ut_teardown,
8560 test_AES_GCM_auth_decryption_test_case_192_5),
8561 TEST_CASE_ST(ut_setup, ut_teardown,
8562 test_AES_GCM_auth_decryption_test_case_192_6),
8563 TEST_CASE_ST(ut_setup, ut_teardown,
8564 test_AES_GCM_auth_decryption_test_case_192_7),
8566 /** AES GCM Authenticated Encryption 256 bits key */
8567 TEST_CASE_ST(ut_setup, ut_teardown,
8568 test_AES_GCM_auth_encryption_test_case_256_1),
8569 TEST_CASE_ST(ut_setup, ut_teardown,
8570 test_AES_GCM_auth_encryption_test_case_256_2),
8571 TEST_CASE_ST(ut_setup, ut_teardown,
8572 test_AES_GCM_auth_encryption_test_case_256_3),
8573 TEST_CASE_ST(ut_setup, ut_teardown,
8574 test_AES_GCM_auth_encryption_test_case_256_4),
8575 TEST_CASE_ST(ut_setup, ut_teardown,
8576 test_AES_GCM_auth_encryption_test_case_256_5),
8577 TEST_CASE_ST(ut_setup, ut_teardown,
8578 test_AES_GCM_auth_encryption_test_case_256_6),
8579 TEST_CASE_ST(ut_setup, ut_teardown,
8580 test_AES_GCM_auth_encryption_test_case_256_7),
8582 /** AES GCM Authenticated Decryption 256 bits key */
8583 TEST_CASE_ST(ut_setup, ut_teardown,
8584 test_AES_GCM_auth_decryption_test_case_256_1),
8585 TEST_CASE_ST(ut_setup, ut_teardown,
8586 test_AES_GCM_auth_decryption_test_case_256_2),
8587 TEST_CASE_ST(ut_setup, ut_teardown,
8588 test_AES_GCM_auth_decryption_test_case_256_3),
8589 TEST_CASE_ST(ut_setup, ut_teardown,
8590 test_AES_GCM_auth_decryption_test_case_256_4),
8591 TEST_CASE_ST(ut_setup, ut_teardown,
8592 test_AES_GCM_auth_decryption_test_case_256_5),
8593 TEST_CASE_ST(ut_setup, ut_teardown,
8594 test_AES_GCM_auth_decryption_test_case_256_6),
8595 TEST_CASE_ST(ut_setup, ut_teardown,
8596 test_AES_GCM_auth_decryption_test_case_256_7),
8598 /** AES GCM Authenticated Encryption big aad size */
8599 TEST_CASE_ST(ut_setup, ut_teardown,
8600 test_AES_GCM_auth_encryption_test_case_aad_1),
8601 TEST_CASE_ST(ut_setup, ut_teardown,
8602 test_AES_GCM_auth_encryption_test_case_aad_2),
8604 /** AES GCM Authenticated Decryption big aad size */
8605 TEST_CASE_ST(ut_setup, ut_teardown,
8606 test_AES_GCM_auth_decryption_test_case_aad_1),
8607 TEST_CASE_ST(ut_setup, ut_teardown,
8608 test_AES_GCM_auth_decryption_test_case_aad_2),
8610 /** AES GMAC Authentication */
8611 TEST_CASE_ST(ut_setup, ut_teardown,
8612 test_AES_GMAC_authentication_test_case_1),
8613 TEST_CASE_ST(ut_setup, ut_teardown,
8614 test_AES_GMAC_authentication_verify_test_case_1),
8615 TEST_CASE_ST(ut_setup, ut_teardown,
8616 test_AES_GMAC_authentication_test_case_3),
8617 TEST_CASE_ST(ut_setup, ut_teardown,
8618 test_AES_GMAC_authentication_verify_test_case_3),
8619 TEST_CASE_ST(ut_setup, ut_teardown,
8620 test_AES_GMAC_authentication_test_case_4),
8621 TEST_CASE_ST(ut_setup, ut_teardown,
8622 test_AES_GMAC_authentication_verify_test_case_4),
8624 /** Negative tests */
8625 TEST_CASE_ST(ut_setup, ut_teardown,
8626 authentication_verify_AES128_GMAC_fail_data_corrupt),
8627 TEST_CASE_ST(ut_setup, ut_teardown,
8628 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8630 /** Out of place tests */
8631 TEST_CASE_ST(ut_setup, ut_teardown,
8632 test_AES_GCM_authenticated_encryption_oop_test_case_1),
8633 TEST_CASE_ST(ut_setup, ut_teardown,
8634 test_AES_GCM_authenticated_decryption_oop_test_case_1),
8636 /** Session-less tests */
8637 TEST_CASE_ST(ut_setup, ut_teardown,
8638 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
8639 TEST_CASE_ST(ut_setup, ut_teardown,
8640 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
8642 /** Scatter-Gather */
8643 TEST_CASE_ST(ut_setup, ut_teardown,
8644 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8646 TEST_CASES_END() /**< NULL terminate unit test array */
8650 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
8651 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
8652 .setup = testsuite_setup,
8653 .teardown = testsuite_teardown,
8654 .unit_test_cases = {
8655 /** KASUMI encrypt only (UEA1) */
8656 TEST_CASE_ST(ut_setup, ut_teardown,
8657 test_kasumi_encryption_test_case_1),
8658 TEST_CASE_ST(ut_setup, ut_teardown,
8659 test_kasumi_encryption_test_case_1_sgl),
8660 TEST_CASE_ST(ut_setup, ut_teardown,
8661 test_kasumi_encryption_test_case_2),
8662 TEST_CASE_ST(ut_setup, ut_teardown,
8663 test_kasumi_encryption_test_case_3),
8664 TEST_CASE_ST(ut_setup, ut_teardown,
8665 test_kasumi_encryption_test_case_4),
8666 TEST_CASE_ST(ut_setup, ut_teardown,
8667 test_kasumi_encryption_test_case_5),
8668 /** KASUMI decrypt only (UEA1) */
8669 TEST_CASE_ST(ut_setup, ut_teardown,
8670 test_kasumi_decryption_test_case_1),
8671 TEST_CASE_ST(ut_setup, ut_teardown,
8672 test_kasumi_decryption_test_case_2),
8673 TEST_CASE_ST(ut_setup, ut_teardown,
8674 test_kasumi_decryption_test_case_3),
8675 TEST_CASE_ST(ut_setup, ut_teardown,
8676 test_kasumi_decryption_test_case_4),
8677 TEST_CASE_ST(ut_setup, ut_teardown,
8678 test_kasumi_decryption_test_case_5),
8680 TEST_CASE_ST(ut_setup, ut_teardown,
8681 test_kasumi_encryption_test_case_1_oop),
8682 TEST_CASE_ST(ut_setup, ut_teardown,
8683 test_kasumi_encryption_test_case_1_oop_sgl),
8686 TEST_CASE_ST(ut_setup, ut_teardown,
8687 test_kasumi_decryption_test_case_1_oop),
8689 /** KASUMI hash only (UIA1) */
8690 TEST_CASE_ST(ut_setup, ut_teardown,
8691 test_kasumi_hash_generate_test_case_1),
8692 TEST_CASE_ST(ut_setup, ut_teardown,
8693 test_kasumi_hash_generate_test_case_2),
8694 TEST_CASE_ST(ut_setup, ut_teardown,
8695 test_kasumi_hash_generate_test_case_3),
8696 TEST_CASE_ST(ut_setup, ut_teardown,
8697 test_kasumi_hash_generate_test_case_4),
8698 TEST_CASE_ST(ut_setup, ut_teardown,
8699 test_kasumi_hash_generate_test_case_5),
8700 TEST_CASE_ST(ut_setup, ut_teardown,
8701 test_kasumi_hash_generate_test_case_6),
8702 TEST_CASE_ST(ut_setup, ut_teardown,
8703 test_kasumi_hash_verify_test_case_1),
8704 TEST_CASE_ST(ut_setup, ut_teardown,
8705 test_kasumi_hash_verify_test_case_2),
8706 TEST_CASE_ST(ut_setup, ut_teardown,
8707 test_kasumi_hash_verify_test_case_3),
8708 TEST_CASE_ST(ut_setup, ut_teardown,
8709 test_kasumi_hash_verify_test_case_4),
8710 TEST_CASE_ST(ut_setup, ut_teardown,
8711 test_kasumi_hash_verify_test_case_5),
8712 TEST_CASE_ST(ut_setup, ut_teardown,
8713 test_kasumi_auth_cipher_test_case_1),
8714 TEST_CASE_ST(ut_setup, ut_teardown,
8715 test_kasumi_cipher_auth_test_case_1),
8716 TEST_CASES_END() /**< NULL terminate unit test array */
8719 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
8720 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
8721 .setup = testsuite_setup,
8722 .teardown = testsuite_teardown,
8723 .unit_test_cases = {
8724 /** SNOW 3G encrypt only (UEA2) */
8725 TEST_CASE_ST(ut_setup, ut_teardown,
8726 test_snow3g_encryption_test_case_1),
8727 TEST_CASE_ST(ut_setup, ut_teardown,
8728 test_snow3g_encryption_test_case_2),
8729 TEST_CASE_ST(ut_setup, ut_teardown,
8730 test_snow3g_encryption_test_case_3),
8731 TEST_CASE_ST(ut_setup, ut_teardown,
8732 test_snow3g_encryption_test_case_4),
8733 TEST_CASE_ST(ut_setup, ut_teardown,
8734 test_snow3g_encryption_test_case_5),
8736 TEST_CASE_ST(ut_setup, ut_teardown,
8737 test_snow3g_encryption_test_case_1_oop),
8738 TEST_CASE_ST(ut_setup, ut_teardown,
8739 test_snow3g_encryption_test_case_1_oop_sgl),
8740 TEST_CASE_ST(ut_setup, ut_teardown,
8741 test_snow3g_decryption_test_case_1_oop),
8743 TEST_CASE_ST(ut_setup, ut_teardown,
8744 test_snow3g_encryption_test_case_1_offset_oop),
8746 /** SNOW 3G decrypt only (UEA2) */
8747 TEST_CASE_ST(ut_setup, ut_teardown,
8748 test_snow3g_decryption_test_case_1),
8749 TEST_CASE_ST(ut_setup, ut_teardown,
8750 test_snow3g_decryption_test_case_2),
8751 TEST_CASE_ST(ut_setup, ut_teardown,
8752 test_snow3g_decryption_test_case_3),
8753 TEST_CASE_ST(ut_setup, ut_teardown,
8754 test_snow3g_decryption_test_case_4),
8755 TEST_CASE_ST(ut_setup, ut_teardown,
8756 test_snow3g_decryption_test_case_5),
8757 TEST_CASE_ST(ut_setup, ut_teardown,
8758 test_snow3g_hash_generate_test_case_1),
8759 TEST_CASE_ST(ut_setup, ut_teardown,
8760 test_snow3g_hash_generate_test_case_2),
8761 TEST_CASE_ST(ut_setup, ut_teardown,
8762 test_snow3g_hash_generate_test_case_3),
8763 /* Tests with buffers which length is not byte-aligned */
8764 TEST_CASE_ST(ut_setup, ut_teardown,
8765 test_snow3g_hash_generate_test_case_4),
8766 TEST_CASE_ST(ut_setup, ut_teardown,
8767 test_snow3g_hash_generate_test_case_5),
8768 TEST_CASE_ST(ut_setup, ut_teardown,
8769 test_snow3g_hash_generate_test_case_6),
8770 TEST_CASE_ST(ut_setup, ut_teardown,
8771 test_snow3g_hash_verify_test_case_1),
8772 TEST_CASE_ST(ut_setup, ut_teardown,
8773 test_snow3g_hash_verify_test_case_2),
8774 TEST_CASE_ST(ut_setup, ut_teardown,
8775 test_snow3g_hash_verify_test_case_3),
8776 /* Tests with buffers which length is not byte-aligned */
8777 TEST_CASE_ST(ut_setup, ut_teardown,
8778 test_snow3g_hash_verify_test_case_4),
8779 TEST_CASE_ST(ut_setup, ut_teardown,
8780 test_snow3g_hash_verify_test_case_5),
8781 TEST_CASE_ST(ut_setup, ut_teardown,
8782 test_snow3g_hash_verify_test_case_6),
8783 TEST_CASE_ST(ut_setup, ut_teardown,
8784 test_snow3g_cipher_auth_test_case_1),
8785 TEST_CASE_ST(ut_setup, ut_teardown,
8786 test_snow3g_auth_cipher_test_case_1),
8788 TEST_CASES_END() /**< NULL terminate unit test array */
8792 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
8793 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
8794 .setup = testsuite_setup,
8795 .teardown = testsuite_teardown,
8796 .unit_test_cases = {
8797 /** ZUC encrypt only (EEA3) */
8798 TEST_CASE_ST(ut_setup, ut_teardown,
8799 test_zuc_encryption_test_case_1),
8800 TEST_CASE_ST(ut_setup, ut_teardown,
8801 test_zuc_encryption_test_case_2),
8802 TEST_CASE_ST(ut_setup, ut_teardown,
8803 test_zuc_encryption_test_case_3),
8804 TEST_CASE_ST(ut_setup, ut_teardown,
8805 test_zuc_encryption_test_case_4),
8806 TEST_CASE_ST(ut_setup, ut_teardown,
8807 test_zuc_encryption_test_case_5),
8808 TEST_CASE_ST(ut_setup, ut_teardown,
8809 test_zuc_hash_generate_test_case_1),
8810 TEST_CASE_ST(ut_setup, ut_teardown,
8811 test_zuc_hash_generate_test_case_2),
8812 TEST_CASE_ST(ut_setup, ut_teardown,
8813 test_zuc_hash_generate_test_case_3),
8814 TEST_CASE_ST(ut_setup, ut_teardown,
8815 test_zuc_hash_generate_test_case_4),
8816 TEST_CASE_ST(ut_setup, ut_teardown,
8817 test_zuc_hash_generate_test_case_5),
8818 TEST_CASE_ST(ut_setup, ut_teardown,
8819 test_zuc_encryption_test_case_6_sgl),
8820 TEST_CASES_END() /**< NULL terminate unit test array */
8824 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
8825 .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
8826 .setup = testsuite_setup,
8827 .teardown = testsuite_teardown,
8828 .unit_test_cases = {
8829 TEST_CASE_ST(ut_setup, ut_teardown,
8830 test_device_configure_invalid_dev_id),
8831 TEST_CASE_ST(ut_setup, ut_teardown,
8832 test_multi_session),
8834 TEST_CASE_ST(ut_setup, ut_teardown,
8835 test_AES_chain_dpaa2_sec_all),
8836 TEST_CASE_ST(ut_setup, ut_teardown,
8837 test_3DES_chain_dpaa2_sec_all),
8838 TEST_CASE_ST(ut_setup, ut_teardown,
8839 test_AES_cipheronly_dpaa2_sec_all),
8840 TEST_CASE_ST(ut_setup, ut_teardown,
8841 test_3DES_cipheronly_dpaa2_sec_all),
8842 TEST_CASE_ST(ut_setup, ut_teardown,
8843 test_authonly_dpaa2_sec_all),
8845 /** AES GCM Authenticated Encryption */
8846 TEST_CASE_ST(ut_setup, ut_teardown,
8847 test_AES_GCM_authenticated_encryption_test_case_1),
8848 TEST_CASE_ST(ut_setup, ut_teardown,
8849 test_AES_GCM_authenticated_encryption_test_case_2),
8850 TEST_CASE_ST(ut_setup, ut_teardown,
8851 test_AES_GCM_authenticated_encryption_test_case_3),
8852 TEST_CASE_ST(ut_setup, ut_teardown,
8853 test_AES_GCM_authenticated_encryption_test_case_4),
8854 TEST_CASE_ST(ut_setup, ut_teardown,
8855 test_AES_GCM_authenticated_encryption_test_case_5),
8856 TEST_CASE_ST(ut_setup, ut_teardown,
8857 test_AES_GCM_authenticated_encryption_test_case_6),
8858 TEST_CASE_ST(ut_setup, ut_teardown,
8859 test_AES_GCM_authenticated_encryption_test_case_7),
8861 /** AES GCM Authenticated Decryption */
8862 TEST_CASE_ST(ut_setup, ut_teardown,
8863 test_AES_GCM_authenticated_decryption_test_case_1),
8864 TEST_CASE_ST(ut_setup, ut_teardown,
8865 test_AES_GCM_authenticated_decryption_test_case_2),
8866 TEST_CASE_ST(ut_setup, ut_teardown,
8867 test_AES_GCM_authenticated_decryption_test_case_3),
8868 TEST_CASE_ST(ut_setup, ut_teardown,
8869 test_AES_GCM_authenticated_decryption_test_case_4),
8870 TEST_CASE_ST(ut_setup, ut_teardown,
8871 test_AES_GCM_authenticated_decryption_test_case_5),
8872 TEST_CASE_ST(ut_setup, ut_teardown,
8873 test_AES_GCM_authenticated_decryption_test_case_6),
8874 TEST_CASE_ST(ut_setup, ut_teardown,
8875 test_AES_GCM_authenticated_decryption_test_case_7),
8877 /** AES GCM Authenticated Encryption 192 bits key */
8878 TEST_CASE_ST(ut_setup, ut_teardown,
8879 test_AES_GCM_auth_encryption_test_case_192_1),
8880 TEST_CASE_ST(ut_setup, ut_teardown,
8881 test_AES_GCM_auth_encryption_test_case_192_2),
8882 TEST_CASE_ST(ut_setup, ut_teardown,
8883 test_AES_GCM_auth_encryption_test_case_192_3),
8884 TEST_CASE_ST(ut_setup, ut_teardown,
8885 test_AES_GCM_auth_encryption_test_case_192_4),
8886 TEST_CASE_ST(ut_setup, ut_teardown,
8887 test_AES_GCM_auth_encryption_test_case_192_5),
8888 TEST_CASE_ST(ut_setup, ut_teardown,
8889 test_AES_GCM_auth_encryption_test_case_192_6),
8890 TEST_CASE_ST(ut_setup, ut_teardown,
8891 test_AES_GCM_auth_encryption_test_case_192_7),
8893 /** AES GCM Authenticated Decryption 192 bits key */
8894 TEST_CASE_ST(ut_setup, ut_teardown,
8895 test_AES_GCM_auth_decryption_test_case_192_1),
8896 TEST_CASE_ST(ut_setup, ut_teardown,
8897 test_AES_GCM_auth_decryption_test_case_192_2),
8898 TEST_CASE_ST(ut_setup, ut_teardown,
8899 test_AES_GCM_auth_decryption_test_case_192_3),
8900 TEST_CASE_ST(ut_setup, ut_teardown,
8901 test_AES_GCM_auth_decryption_test_case_192_4),
8902 TEST_CASE_ST(ut_setup, ut_teardown,
8903 test_AES_GCM_auth_decryption_test_case_192_5),
8904 TEST_CASE_ST(ut_setup, ut_teardown,
8905 test_AES_GCM_auth_decryption_test_case_192_6),
8906 TEST_CASE_ST(ut_setup, ut_teardown,
8907 test_AES_GCM_auth_decryption_test_case_192_7),
8909 /** AES GCM Authenticated Encryption 256 bits key */
8910 TEST_CASE_ST(ut_setup, ut_teardown,
8911 test_AES_GCM_auth_encryption_test_case_256_1),
8912 TEST_CASE_ST(ut_setup, ut_teardown,
8913 test_AES_GCM_auth_encryption_test_case_256_2),
8914 TEST_CASE_ST(ut_setup, ut_teardown,
8915 test_AES_GCM_auth_encryption_test_case_256_3),
8916 TEST_CASE_ST(ut_setup, ut_teardown,
8917 test_AES_GCM_auth_encryption_test_case_256_4),
8918 TEST_CASE_ST(ut_setup, ut_teardown,
8919 test_AES_GCM_auth_encryption_test_case_256_5),
8920 TEST_CASE_ST(ut_setup, ut_teardown,
8921 test_AES_GCM_auth_encryption_test_case_256_6),
8922 TEST_CASE_ST(ut_setup, ut_teardown,
8923 test_AES_GCM_auth_encryption_test_case_256_7),
8925 /** AES GCM Authenticated Decryption 256 bits key */
8926 TEST_CASE_ST(ut_setup, ut_teardown,
8927 test_AES_GCM_auth_decryption_test_case_256_1),
8928 TEST_CASE_ST(ut_setup, ut_teardown,
8929 test_AES_GCM_auth_decryption_test_case_256_2),
8930 TEST_CASE_ST(ut_setup, ut_teardown,
8931 test_AES_GCM_auth_decryption_test_case_256_3),
8932 TEST_CASE_ST(ut_setup, ut_teardown,
8933 test_AES_GCM_auth_decryption_test_case_256_4),
8934 TEST_CASE_ST(ut_setup, ut_teardown,
8935 test_AES_GCM_auth_decryption_test_case_256_5),
8936 TEST_CASE_ST(ut_setup, ut_teardown,
8937 test_AES_GCM_auth_decryption_test_case_256_6),
8938 TEST_CASE_ST(ut_setup, ut_teardown,
8939 test_AES_GCM_auth_decryption_test_case_256_7),
8941 TEST_CASES_END() /**< NULL terminate unit test array */
8945 static struct unit_test_suite cryptodev_null_testsuite = {
8946 .suite_name = "Crypto Device NULL Unit Test Suite",
8947 .setup = testsuite_setup,
8948 .teardown = testsuite_teardown,
8949 .unit_test_cases = {
8950 TEST_CASE_ST(ut_setup, ut_teardown,
8951 test_null_auth_only_operation),
8952 TEST_CASE_ST(ut_setup, ut_teardown,
8953 test_null_cipher_only_operation),
8954 TEST_CASE_ST(ut_setup, ut_teardown,
8955 test_null_cipher_auth_operation),
8956 TEST_CASE_ST(ut_setup, ut_teardown,
8957 test_null_auth_cipher_operation),
8958 TEST_CASE_ST(ut_setup, ut_teardown,
8959 test_null_invalid_operation),
8960 TEST_CASE_ST(ut_setup, ut_teardown,
8961 test_null_burst_operation),
8963 TEST_CASES_END() /**< NULL terminate unit test array */
8967 static struct unit_test_suite cryptodev_armv8_testsuite = {
8968 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
8969 .setup = testsuite_setup,
8970 .teardown = testsuite_teardown,
8971 .unit_test_cases = {
8972 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
8974 /** Negative tests */
8975 TEST_CASE_ST(ut_setup, ut_teardown,
8976 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8977 TEST_CASE_ST(ut_setup, ut_teardown,
8978 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8980 TEST_CASES_END() /**< NULL terminate unit test array */
8985 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
8987 gbl_driver_id = rte_cryptodev_driver_id_get(
8988 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
8990 if (gbl_driver_id == -1) {
8991 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
8992 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
8993 "in config file to run this testsuite.\n");
8997 return unit_test_suite_runner(&cryptodev_qat_testsuite);
9001 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
9003 gbl_driver_id = rte_cryptodev_driver_id_get(
9004 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
9006 if (gbl_driver_id == -1) {
9007 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
9008 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
9009 "in config file to run this testsuite.\n");
9013 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
9017 test_cryptodev_openssl(void)
9019 gbl_driver_id = rte_cryptodev_driver_id_get(
9020 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
9022 if (gbl_driver_id == -1) {
9023 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
9024 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
9025 "in config file to run this testsuite.\n");
9029 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
9033 test_cryptodev_aesni_gcm(void)
9035 gbl_driver_id = rte_cryptodev_driver_id_get(
9036 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
9038 if (gbl_driver_id == -1) {
9039 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
9040 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
9041 "in config file to run this testsuite.\n");
9045 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
9049 test_cryptodev_null(void)
9051 gbl_driver_id = rte_cryptodev_driver_id_get(
9052 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
9054 if (gbl_driver_id == -1) {
9055 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
9056 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
9057 "in config file to run this testsuite.\n");
9061 return unit_test_suite_runner(&cryptodev_null_testsuite);
9065 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
9067 gbl_driver_id = rte_cryptodev_driver_id_get(
9068 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
9070 if (gbl_driver_id == -1) {
9071 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
9072 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
9073 "in config file to run this testsuite.\n");
9077 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
9081 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
9083 gbl_driver_id = rte_cryptodev_driver_id_get(
9084 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
9086 if (gbl_driver_id == -1) {
9087 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
9088 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
9089 "in config file to run this testsuite.\n");
9093 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
9097 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
9099 gbl_driver_id = rte_cryptodev_driver_id_get(
9100 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
9102 if (gbl_driver_id == -1) {
9103 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
9104 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
9105 "in config file to run this testsuite.\n");
9109 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
9113 test_cryptodev_armv8(void)
9115 gbl_driver_id = rte_cryptodev_driver_id_get(
9116 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
9118 if (gbl_driver_id == -1) {
9119 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
9120 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
9121 "in config file to run this testsuite.\n");
9125 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
9128 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
9131 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
9133 gbl_driver_id = rte_cryptodev_driver_id_get(
9134 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
9136 if (gbl_driver_id == -1) {
9137 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
9138 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
9139 "in config file to run this testsuite.\n");
9143 if (rte_cryptodev_driver_id_get(
9144 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
9145 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
9146 " enabled in config file to run this testsuite.\n");
9149 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
9152 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
9157 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
9159 gbl_driver_id = rte_cryptodev_driver_id_get(
9160 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
9162 if (gbl_driver_id == -1) {
9163 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
9164 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
9165 "in config file to run this testsuite.\n");
9169 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
9172 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
9173 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
9174 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
9175 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
9176 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
9177 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
9178 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
9179 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
9180 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
9181 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);