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(RTE_CRYPTODEV_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_3DES_chain_dpaa2_sec_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_DPAA2_SEC_PMD)),
4705 BLKCIPHER_3DES_CHAIN_TYPE);
4707 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4709 return TEST_SUCCESS;
4713 test_3DES_cipheronly_dpaa2_sec_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_DPAA2_SEC_PMD)),
4724 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4726 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4728 return TEST_SUCCESS;
4732 test_3DES_cipheronly_qat_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_QAT_SYM_PMD)),
4743 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4745 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4747 return TEST_SUCCESS;
4751 test_3DES_chain_openssl_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_OPENSSL_PMD)),
4762 BLKCIPHER_3DES_CHAIN_TYPE);
4764 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4766 return TEST_SUCCESS;
4770 test_3DES_cipheronly_openssl_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_OPENSSL_PMD)),
4781 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4783 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4785 return TEST_SUCCESS;
4788 /* ***** AES-GCM Tests ***** */
4791 create_gcm_session(uint8_t dev_id, enum rte_crypto_aead_operation op,
4792 const uint8_t *key, const uint8_t key_len,
4793 const uint16_t aad_len, const uint8_t auth_len,
4796 uint8_t aead_key[key_len];
4798 struct crypto_testsuite_params *ts_params = &testsuite_params;
4799 struct crypto_unittest_params *ut_params = &unittest_params;
4801 memcpy(aead_key, key, key_len);
4803 /* Setup AEAD Parameters */
4804 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
4805 ut_params->aead_xform.next = NULL;
4806 ut_params->aead_xform.aead.algo = RTE_CRYPTO_AEAD_AES_GCM;
4807 ut_params->aead_xform.aead.op = op;
4808 ut_params->aead_xform.aead.key.data = aead_key;
4809 ut_params->aead_xform.aead.key.length = key_len;
4810 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
4811 ut_params->aead_xform.aead.iv.length = iv_len;
4812 ut_params->aead_xform.aead.digest_length = auth_len;
4813 ut_params->aead_xform.aead.aad_length = aad_len;
4815 TEST_HEXDUMP(stdout, "key:", key, key_len);
4817 /* Create Crypto session*/
4818 ut_params->sess = rte_cryptodev_sym_session_create(
4819 ts_params->session_mpool);
4821 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
4822 &ut_params->aead_xform, ts_params->session_mpool);
4824 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4830 create_gcm_xforms(struct rte_crypto_op *op,
4831 enum rte_crypto_aead_operation aead_op,
4832 uint8_t *key, const uint8_t key_len,
4833 const uint8_t aad_len, const uint8_t auth_len,
4836 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
4837 "failed to allocate space for crypto transform");
4839 struct rte_crypto_sym_op *sym_op = op->sym;
4841 /* Setup AEAD Parameters */
4842 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
4843 sym_op->xform->next = NULL;
4844 sym_op->xform->aead.algo = RTE_CRYPTO_AEAD_AES_GCM;
4845 sym_op->xform->aead.op = aead_op;
4846 sym_op->xform->aead.key.data = key;
4847 sym_op->xform->aead.key.length = key_len;
4848 sym_op->xform->aead.iv.offset = IV_OFFSET;
4849 sym_op->xform->aead.iv.length = iv_len;
4850 sym_op->xform->aead.digest_length = auth_len;
4851 sym_op->xform->aead.aad_length = aad_len;
4853 TEST_HEXDUMP(stdout, "key:", key, key_len);
4859 create_gcm_operation(enum rte_crypto_aead_operation op,
4860 const struct gcm_test_data *tdata)
4862 struct crypto_testsuite_params *ts_params = &testsuite_params;
4863 struct crypto_unittest_params *ut_params = &unittest_params;
4865 uint8_t *plaintext, *ciphertext;
4866 unsigned int aad_pad_len, plaintext_pad_len;
4868 /* Generate Crypto op data structure */
4869 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4870 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4871 TEST_ASSERT_NOT_NULL(ut_params->op,
4872 "Failed to allocate symmetric crypto operation struct");
4874 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4876 /* Append aad data */
4877 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
4878 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4880 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
4881 "no room to append aad");
4883 sym_op->aead.aad.phys_addr =
4884 rte_pktmbuf_mtophys(ut_params->ibuf);
4885 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
4886 TEST_HEXDUMP(stdout, "aad:", sym_op->aead.aad.data,
4889 /* Append IV at the end of the crypto operation*/
4890 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
4891 uint8_t *, IV_OFFSET);
4893 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
4894 TEST_HEXDUMP(stdout, "iv:", iv_ptr,
4897 /* Append plaintext/ciphertext */
4898 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
4899 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4900 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4902 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
4904 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4905 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
4906 tdata->plaintext.len);
4908 if (ut_params->obuf) {
4909 ciphertext = (uint8_t *)rte_pktmbuf_append(
4911 plaintext_pad_len + aad_pad_len);
4912 TEST_ASSERT_NOT_NULL(ciphertext,
4913 "no room to append ciphertext");
4915 memset(ciphertext + aad_pad_len, 0,
4916 tdata->ciphertext.len);
4919 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4920 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4922 TEST_ASSERT_NOT_NULL(ciphertext,
4923 "no room to append ciphertext");
4925 memcpy(ciphertext, tdata->ciphertext.data,
4926 tdata->ciphertext.len);
4927 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
4928 tdata->ciphertext.len);
4930 if (ut_params->obuf) {
4931 plaintext = (uint8_t *)rte_pktmbuf_append(
4933 plaintext_pad_len + aad_pad_len);
4934 TEST_ASSERT_NOT_NULL(plaintext,
4935 "no room to append plaintext");
4937 memset(plaintext + aad_pad_len, 0,
4938 tdata->plaintext.len);
4942 /* Append digest data */
4943 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
4944 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
4945 ut_params->obuf ? ut_params->obuf :
4947 tdata->auth_tag.len);
4948 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
4949 "no room to append digest");
4950 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
4951 sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4952 ut_params->obuf ? ut_params->obuf :
4957 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
4958 ut_params->ibuf, tdata->auth_tag.len);
4959 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
4960 "no room to append digest");
4961 sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4963 plaintext_pad_len + aad_pad_len);
4965 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
4966 tdata->auth_tag.len);
4967 TEST_HEXDUMP(stdout, "digest:",
4968 sym_op->aead.digest.data,
4969 tdata->auth_tag.len);
4972 sym_op->aead.data.length = tdata->plaintext.len;
4973 sym_op->aead.data.offset = aad_pad_len;
4979 test_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
4981 struct crypto_testsuite_params *ts_params = &testsuite_params;
4982 struct crypto_unittest_params *ut_params = &unittest_params;
4985 uint8_t *ciphertext, *auth_tag;
4986 uint16_t plaintext_pad_len;
4989 /* Create GCM session */
4990 retval = create_gcm_session(ts_params->valid_devs[0],
4991 RTE_CRYPTO_AEAD_OP_ENCRYPT,
4992 tdata->key.data, tdata->key.len,
4993 tdata->aad.len, tdata->auth_tag.len,
4998 if (tdata->aad.len > MBUF_SIZE) {
4999 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5000 /* Populate full size of add data */
5001 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5002 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5004 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5006 /* clear mbuf payload */
5007 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5008 rte_pktmbuf_tailroom(ut_params->ibuf));
5010 /* Create GCM operation */
5011 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5015 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5017 ut_params->op->sym->m_src = ut_params->ibuf;
5019 /* Process crypto operation */
5020 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5021 ut_params->op), "failed to process sym crypto op");
5023 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5024 "crypto op processing failed");
5026 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5028 if (ut_params->op->sym->m_dst) {
5029 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5031 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5032 uint8_t *, plaintext_pad_len);
5034 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5036 ut_params->op->sym->cipher.data.offset);
5037 auth_tag = ciphertext + plaintext_pad_len;
5040 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5041 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5044 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5046 tdata->ciphertext.data,
5047 tdata->ciphertext.len,
5048 "GCM Ciphertext data not as expected");
5050 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5052 tdata->auth_tag.data,
5053 tdata->auth_tag.len,
5054 "GCM Generated auth tag not as expected");
5061 test_AES_GCM_authenticated_encryption_test_case_1(void)
5063 return test_AES_GCM_authenticated_encryption(&gcm_test_case_1);
5067 test_AES_GCM_authenticated_encryption_test_case_2(void)
5069 return test_AES_GCM_authenticated_encryption(&gcm_test_case_2);
5073 test_AES_GCM_authenticated_encryption_test_case_3(void)
5075 return test_AES_GCM_authenticated_encryption(&gcm_test_case_3);
5079 test_AES_GCM_authenticated_encryption_test_case_4(void)
5081 return test_AES_GCM_authenticated_encryption(&gcm_test_case_4);
5085 test_AES_GCM_authenticated_encryption_test_case_5(void)
5087 return test_AES_GCM_authenticated_encryption(&gcm_test_case_5);
5091 test_AES_GCM_authenticated_encryption_test_case_6(void)
5093 return test_AES_GCM_authenticated_encryption(&gcm_test_case_6);
5097 test_AES_GCM_authenticated_encryption_test_case_7(void)
5099 return test_AES_GCM_authenticated_encryption(&gcm_test_case_7);
5103 test_AES_GCM_auth_encryption_test_case_192_1(void)
5105 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_1);
5109 test_AES_GCM_auth_encryption_test_case_192_2(void)
5111 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_2);
5115 test_AES_GCM_auth_encryption_test_case_192_3(void)
5117 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_3);
5121 test_AES_GCM_auth_encryption_test_case_192_4(void)
5123 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_4);
5127 test_AES_GCM_auth_encryption_test_case_192_5(void)
5129 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_5);
5133 test_AES_GCM_auth_encryption_test_case_192_6(void)
5135 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_6);
5139 test_AES_GCM_auth_encryption_test_case_192_7(void)
5141 return test_AES_GCM_authenticated_encryption(&gcm_test_case_192_7);
5145 test_AES_GCM_auth_encryption_test_case_256_1(void)
5147 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
5151 test_AES_GCM_auth_encryption_test_case_256_2(void)
5153 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
5157 test_AES_GCM_auth_encryption_test_case_256_3(void)
5159 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
5163 test_AES_GCM_auth_encryption_test_case_256_4(void)
5165 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
5169 test_AES_GCM_auth_encryption_test_case_256_5(void)
5171 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
5175 test_AES_GCM_auth_encryption_test_case_256_6(void)
5177 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
5181 test_AES_GCM_auth_encryption_test_case_256_7(void)
5183 return test_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
5187 test_AES_GCM_auth_encryption_test_case_aad_1(void)
5189 return test_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
5193 test_AES_GCM_auth_encryption_test_case_aad_2(void)
5195 return test_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
5199 test_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
5201 struct crypto_testsuite_params *ts_params = &testsuite_params;
5202 struct crypto_unittest_params *ut_params = &unittest_params;
5208 /* Create GCM session */
5209 retval = create_gcm_session(ts_params->valid_devs[0],
5210 RTE_CRYPTO_AEAD_OP_DECRYPT,
5211 tdata->key.data, tdata->key.len,
5212 tdata->aad.len, tdata->auth_tag.len,
5217 /* alloc mbuf and set payload */
5218 if (tdata->aad.len > MBUF_SIZE) {
5219 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5220 /* Populate full size of add data */
5221 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5222 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5224 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5226 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5227 rte_pktmbuf_tailroom(ut_params->ibuf));
5229 /* Create GCM operation */
5230 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5234 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5236 ut_params->op->sym->m_src = ut_params->ibuf;
5238 /* Process crypto operation */
5239 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5240 ut_params->op), "failed to process sym crypto op");
5242 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5243 "crypto op processing failed");
5245 if (ut_params->op->sym->m_dst)
5246 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5249 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5251 ut_params->op->sym->cipher.data.offset);
5253 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5256 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5258 tdata->plaintext.data,
5259 tdata->plaintext.len,
5260 "GCM plaintext data not as expected");
5262 TEST_ASSERT_EQUAL(ut_params->op->status,
5263 RTE_CRYPTO_OP_STATUS_SUCCESS,
5264 "GCM authentication failed");
5269 test_AES_GCM_authenticated_decryption_test_case_1(void)
5271 return test_AES_GCM_authenticated_decryption(&gcm_test_case_1);
5275 test_AES_GCM_authenticated_decryption_test_case_2(void)
5277 return test_AES_GCM_authenticated_decryption(&gcm_test_case_2);
5281 test_AES_GCM_authenticated_decryption_test_case_3(void)
5283 return test_AES_GCM_authenticated_decryption(&gcm_test_case_3);
5287 test_AES_GCM_authenticated_decryption_test_case_4(void)
5289 return test_AES_GCM_authenticated_decryption(&gcm_test_case_4);
5293 test_AES_GCM_authenticated_decryption_test_case_5(void)
5295 return test_AES_GCM_authenticated_decryption(&gcm_test_case_5);
5299 test_AES_GCM_authenticated_decryption_test_case_6(void)
5301 return test_AES_GCM_authenticated_decryption(&gcm_test_case_6);
5305 test_AES_GCM_authenticated_decryption_test_case_7(void)
5307 return test_AES_GCM_authenticated_decryption(&gcm_test_case_7);
5311 test_AES_GCM_auth_decryption_test_case_192_1(void)
5313 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_1);
5317 test_AES_GCM_auth_decryption_test_case_192_2(void)
5319 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_2);
5323 test_AES_GCM_auth_decryption_test_case_192_3(void)
5325 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_3);
5329 test_AES_GCM_auth_decryption_test_case_192_4(void)
5331 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_4);
5335 test_AES_GCM_auth_decryption_test_case_192_5(void)
5337 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_5);
5341 test_AES_GCM_auth_decryption_test_case_192_6(void)
5343 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_6);
5347 test_AES_GCM_auth_decryption_test_case_192_7(void)
5349 return test_AES_GCM_authenticated_decryption(&gcm_test_case_192_7);
5353 test_AES_GCM_auth_decryption_test_case_256_1(void)
5355 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
5359 test_AES_GCM_auth_decryption_test_case_256_2(void)
5361 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
5365 test_AES_GCM_auth_decryption_test_case_256_3(void)
5367 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
5371 test_AES_GCM_auth_decryption_test_case_256_4(void)
5373 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
5377 test_AES_GCM_auth_decryption_test_case_256_5(void)
5379 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
5383 test_AES_GCM_auth_decryption_test_case_256_6(void)
5385 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
5389 test_AES_GCM_auth_decryption_test_case_256_7(void)
5391 return test_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
5395 test_AES_GCM_auth_decryption_test_case_aad_1(void)
5397 return test_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
5401 test_AES_GCM_auth_decryption_test_case_aad_2(void)
5403 return test_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
5407 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
5409 struct crypto_testsuite_params *ts_params = &testsuite_params;
5410 struct crypto_unittest_params *ut_params = &unittest_params;
5413 uint8_t *ciphertext, *auth_tag;
5414 uint16_t plaintext_pad_len;
5416 /* Create GCM session */
5417 retval = create_gcm_session(ts_params->valid_devs[0],
5418 RTE_CRYPTO_AEAD_OP_ENCRYPT,
5419 tdata->key.data, tdata->key.len,
5420 tdata->aad.len, tdata->auth_tag.len,
5425 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5426 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5428 /* clear mbuf payload */
5429 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5430 rte_pktmbuf_tailroom(ut_params->ibuf));
5431 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5432 rte_pktmbuf_tailroom(ut_params->obuf));
5434 /* Create GCM operation */
5435 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5439 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5441 ut_params->op->sym->m_src = ut_params->ibuf;
5442 ut_params->op->sym->m_dst = ut_params->obuf;
5444 /* Process crypto operation */
5445 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5446 ut_params->op), "failed to process sym crypto op");
5448 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5449 "crypto op processing failed");
5451 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5453 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5454 ut_params->op->sym->cipher.data.offset);
5455 auth_tag = ciphertext + plaintext_pad_len;
5457 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5458 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5461 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5463 tdata->ciphertext.data,
5464 tdata->ciphertext.len,
5465 "GCM Ciphertext data not as expected");
5467 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5469 tdata->auth_tag.data,
5470 tdata->auth_tag.len,
5471 "GCM Generated auth tag not as expected");
5478 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
5480 return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
5484 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
5486 struct crypto_testsuite_params *ts_params = &testsuite_params;
5487 struct crypto_unittest_params *ut_params = &unittest_params;
5492 /* Create GCM session */
5493 retval = create_gcm_session(ts_params->valid_devs[0],
5494 RTE_CRYPTO_AEAD_OP_DECRYPT,
5495 tdata->key.data, tdata->key.len,
5496 tdata->aad.len, tdata->auth_tag.len,
5501 /* alloc mbuf and set payload */
5502 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5503 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5505 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5506 rte_pktmbuf_tailroom(ut_params->ibuf));
5507 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5508 rte_pktmbuf_tailroom(ut_params->obuf));
5510 /* Create GCM operation */
5511 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5515 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5517 ut_params->op->sym->m_src = ut_params->ibuf;
5518 ut_params->op->sym->m_dst = ut_params->obuf;
5520 /* Process crypto operation */
5521 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5522 ut_params->op), "failed to process sym crypto op");
5524 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5525 "crypto op processing failed");
5527 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5528 ut_params->op->sym->cipher.data.offset);
5530 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5533 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5535 tdata->plaintext.data,
5536 tdata->plaintext.len,
5537 "GCM plaintext data not as expected");
5539 TEST_ASSERT_EQUAL(ut_params->op->status,
5540 RTE_CRYPTO_OP_STATUS_SUCCESS,
5541 "GCM authentication failed");
5546 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
5548 return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
5552 test_AES_GCM_authenticated_encryption_sessionless(
5553 const struct gcm_test_data *tdata)
5555 struct crypto_testsuite_params *ts_params = &testsuite_params;
5556 struct crypto_unittest_params *ut_params = &unittest_params;
5559 uint8_t *ciphertext, *auth_tag;
5560 uint16_t plaintext_pad_len;
5561 uint8_t key[tdata->key.len + 1];
5563 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5565 /* clear mbuf payload */
5566 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5567 rte_pktmbuf_tailroom(ut_params->ibuf));
5569 /* Create GCM operation */
5570 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5574 /* Create GCM xforms */
5575 memcpy(key, tdata->key.data, tdata->key.len);
5576 retval = create_gcm_xforms(ut_params->op,
5577 RTE_CRYPTO_AEAD_OP_ENCRYPT,
5578 key, tdata->key.len,
5579 tdata->aad.len, tdata->auth_tag.len,
5584 ut_params->op->sym->m_src = ut_params->ibuf;
5586 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
5587 RTE_CRYPTO_OP_SESSIONLESS,
5588 "crypto op session type not sessionless");
5590 /* Process crypto operation */
5591 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5592 ut_params->op), "failed to process sym crypto op");
5594 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5596 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5597 "crypto op status not success");
5599 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5601 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5602 ut_params->op->sym->cipher.data.offset);
5603 auth_tag = ciphertext + plaintext_pad_len;
5605 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5606 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5609 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5611 tdata->ciphertext.data,
5612 tdata->ciphertext.len,
5613 "GCM Ciphertext data not as expected");
5615 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5617 tdata->auth_tag.data,
5618 tdata->auth_tag.len,
5619 "GCM Generated auth tag not as expected");
5626 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
5628 return test_AES_GCM_authenticated_encryption_sessionless(
5633 test_AES_GCM_authenticated_decryption_sessionless(
5634 const struct gcm_test_data *tdata)
5636 struct crypto_testsuite_params *ts_params = &testsuite_params;
5637 struct crypto_unittest_params *ut_params = &unittest_params;
5641 uint8_t key[tdata->key.len + 1];
5643 /* alloc mbuf and set payload */
5644 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5646 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5647 rte_pktmbuf_tailroom(ut_params->ibuf));
5649 /* Create GCM operation */
5650 retval = create_gcm_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5654 /* Create GCM xforms */
5655 memcpy(key, tdata->key.data, tdata->key.len);
5656 retval = create_gcm_xforms(ut_params->op,
5657 RTE_CRYPTO_AEAD_OP_DECRYPT,
5658 key, tdata->key.len,
5659 tdata->aad.len, tdata->auth_tag.len,
5664 ut_params->op->sym->m_src = ut_params->ibuf;
5666 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
5667 RTE_CRYPTO_OP_SESSIONLESS,
5668 "crypto op session type not sessionless");
5670 /* Process crypto operation */
5671 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5672 ut_params->op), "failed to process sym crypto op");
5674 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5676 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5677 "crypto op status not success");
5679 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5680 ut_params->op->sym->cipher.data.offset);
5682 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5685 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5687 tdata->plaintext.data,
5688 tdata->plaintext.len,
5689 "GCM plaintext data not as expected");
5691 TEST_ASSERT_EQUAL(ut_params->op->status,
5692 RTE_CRYPTO_OP_STATUS_SUCCESS,
5693 "GCM authentication failed");
5698 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
5700 return test_AES_GCM_authenticated_decryption_sessionless(
5707 struct crypto_testsuite_params *ts_params = &testsuite_params;
5708 struct rte_cryptodev_stats stats;
5709 struct rte_cryptodev *dev;
5710 cryptodev_stats_get_t temp_pfn;
5712 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5713 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
5714 &stats) == -ENODEV),
5715 "rte_cryptodev_stats_get invalid dev failed");
5716 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
5717 "rte_cryptodev_stats_get invalid Param failed");
5718 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
5719 temp_pfn = dev->dev_ops->stats_get;
5720 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
5721 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
5723 "rte_cryptodev_stats_get invalid Param failed");
5724 dev->dev_ops->stats_get = temp_pfn;
5726 /* Test expected values */
5728 test_AES_CBC_HMAC_SHA1_encrypt_digest();
5730 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5732 "rte_cryptodev_stats_get failed");
5733 TEST_ASSERT((stats.enqueued_count == 1),
5734 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5735 TEST_ASSERT((stats.dequeued_count == 1),
5736 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5737 TEST_ASSERT((stats.enqueue_err_count == 0),
5738 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5739 TEST_ASSERT((stats.dequeue_err_count == 0),
5740 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5742 /* invalid device but should ignore and not reset device stats*/
5743 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
5744 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5746 "rte_cryptodev_stats_get failed");
5747 TEST_ASSERT((stats.enqueued_count == 1),
5748 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5750 /* check that a valid reset clears stats */
5751 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5752 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5754 "rte_cryptodev_stats_get failed");
5755 TEST_ASSERT((stats.enqueued_count == 0),
5756 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5757 TEST_ASSERT((stats.dequeued_count == 0),
5758 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5760 return TEST_SUCCESS;
5763 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
5764 struct crypto_unittest_params *ut_params,
5765 enum rte_crypto_auth_operation op,
5766 const struct HMAC_MD5_vector *test_case)
5770 memcpy(key, test_case->key.data, test_case->key.len);
5772 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5773 ut_params->auth_xform.next = NULL;
5774 ut_params->auth_xform.auth.op = op;
5776 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
5778 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
5779 ut_params->auth_xform.auth.key.length = test_case->key.len;
5780 ut_params->auth_xform.auth.key.data = key;
5782 ut_params->sess = rte_cryptodev_sym_session_create(
5783 ts_params->session_mpool);
5785 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
5786 ut_params->sess, &ut_params->auth_xform,
5787 ts_params->session_mpool);
5789 if (ut_params->sess == NULL)
5792 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5794 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5795 rte_pktmbuf_tailroom(ut_params->ibuf));
5800 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
5801 const struct HMAC_MD5_vector *test_case,
5802 uint8_t **plaintext)
5804 uint16_t plaintext_pad_len;
5806 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5808 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5811 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5813 memcpy(*plaintext, test_case->plaintext.data,
5814 test_case->plaintext.len);
5816 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5817 ut_params->ibuf, MD5_DIGEST_LEN);
5818 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5819 "no room to append digest");
5820 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5821 ut_params->ibuf, plaintext_pad_len);
5823 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5824 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
5825 test_case->auth_tag.len);
5828 sym_op->auth.data.offset = 0;
5829 sym_op->auth.data.length = test_case->plaintext.len;
5831 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5832 ut_params->op->sym->m_src = ut_params->ibuf;
5838 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
5840 uint16_t plaintext_pad_len;
5841 uint8_t *plaintext, *auth_tag;
5843 struct crypto_testsuite_params *ts_params = &testsuite_params;
5844 struct crypto_unittest_params *ut_params = &unittest_params;
5846 if (MD5_HMAC_create_session(ts_params, ut_params,
5847 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
5850 /* Generate Crypto op data structure */
5851 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5852 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5853 TEST_ASSERT_NOT_NULL(ut_params->op,
5854 "Failed to allocate symmetric crypto operation struct");
5856 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5859 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5862 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5863 ut_params->op), "failed to process sym crypto op");
5865 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5866 "crypto op processing failed");
5868 if (ut_params->op->sym->m_dst) {
5869 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5870 uint8_t *, plaintext_pad_len);
5872 auth_tag = plaintext + plaintext_pad_len;
5875 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5877 test_case->auth_tag.data,
5878 test_case->auth_tag.len,
5879 "HMAC_MD5 generated tag not as expected");
5881 return TEST_SUCCESS;
5885 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
5889 struct crypto_testsuite_params *ts_params = &testsuite_params;
5890 struct crypto_unittest_params *ut_params = &unittest_params;
5892 if (MD5_HMAC_create_session(ts_params, ut_params,
5893 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
5897 /* Generate Crypto op data structure */
5898 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5899 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5900 TEST_ASSERT_NOT_NULL(ut_params->op,
5901 "Failed to allocate symmetric crypto operation struct");
5903 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5906 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5907 ut_params->op), "failed to process sym crypto op");
5909 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5910 "HMAC_MD5 crypto op processing failed");
5912 return TEST_SUCCESS;
5916 test_MD5_HMAC_generate_case_1(void)
5918 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
5922 test_MD5_HMAC_verify_case_1(void)
5924 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
5928 test_MD5_HMAC_generate_case_2(void)
5930 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
5934 test_MD5_HMAC_verify_case_2(void)
5936 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
5940 test_multi_session(void)
5942 struct crypto_testsuite_params *ts_params = &testsuite_params;
5943 struct crypto_unittest_params *ut_params = &unittest_params;
5945 struct rte_cryptodev_info dev_info;
5946 struct rte_cryptodev_sym_session **sessions;
5950 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
5951 aes_cbc_key, hmac_sha512_key);
5954 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5956 sessions = rte_malloc(NULL,
5957 (sizeof(struct rte_cryptodev_sym_session *) *
5958 dev_info.sym.max_nb_sessions) + 1, 0);
5960 /* Create multiple crypto sessions*/
5961 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
5963 sessions[i] = rte_cryptodev_sym_session_create(
5964 ts_params->session_mpool);
5966 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
5967 sessions[i], &ut_params->auth_xform,
5968 ts_params->session_mpool);
5969 TEST_ASSERT_NOT_NULL(sessions[i],
5970 "Session creation failed at session number %u",
5973 /* Attempt to send a request on each session */
5974 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
5978 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
5979 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
5981 "Failed to perform decrypt on request number %u.", i);
5982 /* free crypto operation structure */
5984 rte_crypto_op_free(ut_params->op);
5987 * free mbuf - both obuf and ibuf are usually the same,
5988 * so check if they point at the same address is necessary,
5989 * to avoid freeing the mbuf twice.
5991 if (ut_params->obuf) {
5992 rte_pktmbuf_free(ut_params->obuf);
5993 if (ut_params->ibuf == ut_params->obuf)
5994 ut_params->ibuf = 0;
5995 ut_params->obuf = 0;
5997 if (ut_params->ibuf) {
5998 rte_pktmbuf_free(ut_params->ibuf);
5999 ut_params->ibuf = 0;
6003 /* Next session create should fail */
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_NULL(sessions[i],
6008 "Session creation succeeded unexpectedly!");
6010 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
6011 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6013 rte_cryptodev_sym_session_free(sessions[i]);
6018 return TEST_SUCCESS;
6021 struct multi_session_params {
6022 struct crypto_unittest_params ut_params;
6023 uint8_t *cipher_key;
6025 const uint8_t *cipher;
6026 const uint8_t *digest;
6030 #define MB_SESSION_NUMBER 3
6033 test_multi_session_random_usage(void)
6035 struct crypto_testsuite_params *ts_params = &testsuite_params;
6036 struct rte_cryptodev_info dev_info;
6037 struct rte_cryptodev_sym_session **sessions;
6039 struct multi_session_params ut_paramz[] = {
6042 .cipher_key = ms_aes_cbc_key0,
6043 .hmac_key = ms_hmac_key0,
6044 .cipher = ms_aes_cbc_cipher0,
6045 .digest = ms_hmac_digest0,
6046 .iv = ms_aes_cbc_iv0
6049 .cipher_key = ms_aes_cbc_key1,
6050 .hmac_key = ms_hmac_key1,
6051 .cipher = ms_aes_cbc_cipher1,
6052 .digest = ms_hmac_digest1,
6053 .iv = ms_aes_cbc_iv1
6056 .cipher_key = ms_aes_cbc_key2,
6057 .hmac_key = ms_hmac_key2,
6058 .cipher = ms_aes_cbc_cipher2,
6059 .digest = ms_hmac_digest2,
6060 .iv = ms_aes_cbc_iv2
6065 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6067 sessions = rte_malloc(NULL,
6068 (sizeof(struct rte_cryptodev_sym_session *)
6069 * dev_info.sym.max_nb_sessions) + 1, 0);
6071 for (i = 0; i < MB_SESSION_NUMBER; i++) {
6072 sessions[i] = rte_cryptodev_sym_session_create(
6073 ts_params->session_mpool);
6075 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
6076 sizeof(struct crypto_unittest_params));
6078 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
6079 &ut_paramz[i].ut_params,
6080 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
6082 /* Create multiple crypto sessions*/
6083 rte_cryptodev_sym_session_init(
6084 ts_params->valid_devs[0],
6086 &ut_paramz[i].ut_params.auth_xform,
6087 ts_params->session_mpool);
6089 TEST_ASSERT_NOT_NULL(sessions[i],
6090 "Session creation failed at session number %u",
6096 for (i = 0; i < 40000; i++) {
6098 j = rand() % MB_SESSION_NUMBER;
6100 TEST_ASSERT_SUCCESS(
6101 test_AES_CBC_HMAC_SHA512_decrypt_perform(
6103 &ut_paramz[j].ut_params,
6104 ts_params, ut_paramz[j].cipher,
6105 ut_paramz[j].digest,
6107 "Failed to perform decrypt on request number %u.", i);
6109 if (ut_paramz[j].ut_params.op)
6110 rte_crypto_op_free(ut_paramz[j].ut_params.op);
6113 * free mbuf - both obuf and ibuf are usually the same,
6114 * so check if they point at the same address is necessary,
6115 * to avoid freeing the mbuf twice.
6117 if (ut_paramz[j].ut_params.obuf) {
6118 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
6119 if (ut_paramz[j].ut_params.ibuf
6120 == ut_paramz[j].ut_params.obuf)
6121 ut_paramz[j].ut_params.ibuf = 0;
6122 ut_paramz[j].ut_params.obuf = 0;
6124 if (ut_paramz[j].ut_params.ibuf) {
6125 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
6126 ut_paramz[j].ut_params.ibuf = 0;
6130 for (i = 0; i < MB_SESSION_NUMBER; i++) {
6131 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6133 rte_cryptodev_sym_session_free(sessions[i]);
6138 return TEST_SUCCESS;
6142 test_null_cipher_only_operation(void)
6144 struct crypto_testsuite_params *ts_params = &testsuite_params;
6145 struct crypto_unittest_params *ut_params = &unittest_params;
6147 /* Generate test mbuf data and space for digest */
6148 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6149 catch_22_quote, QUOTE_512_BYTES, 0);
6151 /* Setup Cipher Parameters */
6152 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6153 ut_params->cipher_xform.next = NULL;
6155 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6156 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6158 ut_params->sess = rte_cryptodev_sym_session_create(
6159 ts_params->session_mpool);
6161 /* Create Crypto session*/
6162 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6164 &ut_params->cipher_xform,
6165 ts_params->session_mpool);
6166 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6168 /* Generate Crypto op data structure */
6169 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6170 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6171 TEST_ASSERT_NOT_NULL(ut_params->op,
6172 "Failed to allocate symmetric crypto operation struct");
6174 /* Set crypto operation data parameters */
6175 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6177 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6179 /* set crypto operation source mbuf */
6180 sym_op->m_src = ut_params->ibuf;
6182 sym_op->cipher.data.offset = 0;
6183 sym_op->cipher.data.length = QUOTE_512_BYTES;
6185 /* Process crypto operation */
6186 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6188 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6190 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6191 "crypto operation processing failed");
6194 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6195 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6198 "Ciphertext data not as expected");
6200 return TEST_SUCCESS;
6204 test_null_auth_only_operation(void)
6206 struct crypto_testsuite_params *ts_params = &testsuite_params;
6207 struct crypto_unittest_params *ut_params = &unittest_params;
6209 /* Generate test mbuf data and space for digest */
6210 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6211 catch_22_quote, QUOTE_512_BYTES, 0);
6213 /* Setup HMAC Parameters */
6214 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6215 ut_params->auth_xform.next = NULL;
6217 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6218 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6220 ut_params->sess = rte_cryptodev_sym_session_create(
6221 ts_params->session_mpool);
6223 /* Create Crypto session*/
6224 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6225 ut_params->sess, &ut_params->auth_xform,
6226 ts_params->session_mpool);
6227 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6229 /* Generate Crypto op data structure */
6230 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6231 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6232 TEST_ASSERT_NOT_NULL(ut_params->op,
6233 "Failed to allocate symmetric crypto operation struct");
6235 /* Set crypto operation data parameters */
6236 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6238 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6240 sym_op->m_src = ut_params->ibuf;
6242 sym_op->auth.data.offset = 0;
6243 sym_op->auth.data.length = QUOTE_512_BYTES;
6245 /* Process crypto operation */
6246 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6248 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6250 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6251 "crypto operation processing failed");
6253 return TEST_SUCCESS;
6257 test_null_cipher_auth_operation(void)
6259 struct crypto_testsuite_params *ts_params = &testsuite_params;
6260 struct crypto_unittest_params *ut_params = &unittest_params;
6262 /* Generate test mbuf data and space for digest */
6263 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6264 catch_22_quote, QUOTE_512_BYTES, 0);
6266 /* Setup Cipher Parameters */
6267 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6268 ut_params->cipher_xform.next = &ut_params->auth_xform;
6270 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6271 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6273 /* Setup HMAC Parameters */
6274 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6275 ut_params->auth_xform.next = NULL;
6277 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6278 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6280 ut_params->sess = rte_cryptodev_sym_session_create(
6281 ts_params->session_mpool);
6283 /* Create Crypto session*/
6284 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6285 ut_params->sess, &ut_params->cipher_xform,
6286 ts_params->session_mpool);
6287 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6289 /* Generate Crypto op data structure */
6290 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6291 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6292 TEST_ASSERT_NOT_NULL(ut_params->op,
6293 "Failed to allocate symmetric crypto operation struct");
6295 /* Set crypto operation data parameters */
6296 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6298 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6300 sym_op->m_src = ut_params->ibuf;
6302 sym_op->cipher.data.offset = 0;
6303 sym_op->cipher.data.length = QUOTE_512_BYTES;
6305 sym_op->auth.data.offset = 0;
6306 sym_op->auth.data.length = QUOTE_512_BYTES;
6308 /* Process crypto operation */
6309 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6311 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6313 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6314 "crypto operation processing failed");
6317 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6318 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6321 "Ciphertext data not as expected");
6323 return TEST_SUCCESS;
6327 test_null_auth_cipher_operation(void)
6329 struct crypto_testsuite_params *ts_params = &testsuite_params;
6330 struct crypto_unittest_params *ut_params = &unittest_params;
6332 /* Generate test mbuf data and space for digest */
6333 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6334 catch_22_quote, QUOTE_512_BYTES, 0);
6336 /* Setup Cipher Parameters */
6337 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6338 ut_params->cipher_xform.next = NULL;
6340 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6341 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6343 /* Setup HMAC Parameters */
6344 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6345 ut_params->auth_xform.next = &ut_params->cipher_xform;
6347 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6348 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6350 ut_params->sess = rte_cryptodev_sym_session_create(
6351 ts_params->session_mpool);
6353 /* Create Crypto session*/
6354 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6355 ut_params->sess, &ut_params->cipher_xform,
6356 ts_params->session_mpool);
6357 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6359 /* Generate Crypto op data structure */
6360 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6361 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6362 TEST_ASSERT_NOT_NULL(ut_params->op,
6363 "Failed to allocate symmetric crypto operation struct");
6365 /* Set crypto operation data parameters */
6366 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6368 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6370 sym_op->m_src = ut_params->ibuf;
6372 sym_op->cipher.data.offset = 0;
6373 sym_op->cipher.data.length = QUOTE_512_BYTES;
6375 sym_op->auth.data.offset = 0;
6376 sym_op->auth.data.length = QUOTE_512_BYTES;
6378 /* Process crypto operation */
6379 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6381 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6383 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6384 "crypto operation processing failed");
6387 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6388 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6391 "Ciphertext data not as expected");
6393 return TEST_SUCCESS;
6398 test_null_invalid_operation(void)
6400 struct crypto_testsuite_params *ts_params = &testsuite_params;
6401 struct crypto_unittest_params *ut_params = &unittest_params;
6404 /* Setup Cipher Parameters */
6405 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6406 ut_params->cipher_xform.next = NULL;
6408 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
6409 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6411 ut_params->sess = rte_cryptodev_sym_session_create(
6412 ts_params->session_mpool);
6414 /* Create Crypto session*/
6415 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6416 ut_params->sess, &ut_params->cipher_xform,
6417 ts_params->session_mpool);
6418 TEST_ASSERT(ret < 0,
6419 "Session creation succeeded unexpectedly");
6422 /* Setup HMAC Parameters */
6423 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6424 ut_params->auth_xform.next = NULL;
6426 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
6427 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6429 ut_params->sess = rte_cryptodev_sym_session_create(
6430 ts_params->session_mpool);
6432 /* Create Crypto session*/
6433 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6434 ut_params->sess, &ut_params->auth_xform,
6435 ts_params->session_mpool);
6436 TEST_ASSERT(ret < 0,
6437 "Session creation succeeded unexpectedly");
6439 return TEST_SUCCESS;
6443 #define NULL_BURST_LENGTH (32)
6446 test_null_burst_operation(void)
6448 struct crypto_testsuite_params *ts_params = &testsuite_params;
6449 struct crypto_unittest_params *ut_params = &unittest_params;
6451 unsigned i, burst_len = NULL_BURST_LENGTH;
6453 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
6454 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
6456 /* Setup Cipher Parameters */
6457 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6458 ut_params->cipher_xform.next = &ut_params->auth_xform;
6460 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6461 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6463 /* Setup HMAC Parameters */
6464 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6465 ut_params->auth_xform.next = NULL;
6467 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6468 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6470 ut_params->sess = rte_cryptodev_sym_session_create(
6471 ts_params->session_mpool);
6473 /* Create Crypto session*/
6474 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6475 ut_params->sess, &ut_params->cipher_xform,
6476 ts_params->session_mpool);
6477 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6479 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
6480 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
6481 burst_len, "failed to generate burst of crypto ops");
6483 /* Generate an operation for each mbuf in burst */
6484 for (i = 0; i < burst_len; i++) {
6485 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6487 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
6489 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
6493 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
6495 burst[i]->sym->m_src = m;
6498 /* Process crypto operation */
6499 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
6500 0, burst, burst_len),
6502 "Error enqueuing burst");
6504 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
6505 0, burst_dequeued, burst_len),
6507 "Error dequeuing burst");
6510 for (i = 0; i < burst_len; i++) {
6512 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
6513 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
6515 "data not as expected");
6517 rte_pktmbuf_free(burst[i]->sym->m_src);
6518 rte_crypto_op_free(burst[i]);
6521 return TEST_SUCCESS;
6525 generate_gmac_large_plaintext(uint8_t *data)
6529 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
6530 memcpy(&data[i], &data[0], 32);
6534 create_gmac_operation(enum rte_crypto_auth_operation op,
6535 const struct gmac_test_data *tdata)
6537 struct crypto_testsuite_params *ts_params = &testsuite_params;
6538 struct crypto_unittest_params *ut_params = &unittest_params;
6539 struct rte_crypto_sym_op *sym_op;
6541 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6543 /* Generate Crypto op data structure */
6544 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6545 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6546 TEST_ASSERT_NOT_NULL(ut_params->op,
6547 "Failed to allocate symmetric crypto operation struct");
6549 sym_op = ut_params->op->sym;
6551 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6552 ut_params->ibuf, tdata->gmac_tag.len);
6553 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6554 "no room to append digest");
6556 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6557 ut_params->ibuf, plaintext_pad_len);
6559 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6560 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
6561 tdata->gmac_tag.len);
6562 TEST_HEXDUMP(stdout, "digest:",
6563 sym_op->auth.digest.data,
6564 tdata->gmac_tag.len);
6567 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6568 uint8_t *, IV_OFFSET);
6570 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
6572 TEST_HEXDUMP(stdout, "iv:", iv_ptr, tdata->iv.len);
6574 sym_op->cipher.data.length = 0;
6575 sym_op->cipher.data.offset = 0;
6577 sym_op->auth.data.offset = 0;
6578 sym_op->auth.data.length = tdata->plaintext.len;
6583 static int create_gmac_session(uint8_t dev_id,
6584 const struct gmac_test_data *tdata,
6585 enum rte_crypto_auth_operation auth_op)
6587 uint8_t auth_key[tdata->key.len];
6589 struct crypto_testsuite_params *ts_params = &testsuite_params;
6590 struct crypto_unittest_params *ut_params = &unittest_params;
6592 memcpy(auth_key, tdata->key.data, tdata->key.len);
6594 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6595 ut_params->auth_xform.next = NULL;
6597 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
6598 ut_params->auth_xform.auth.op = auth_op;
6599 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
6600 ut_params->auth_xform.auth.key.length = tdata->key.len;
6601 ut_params->auth_xform.auth.key.data = auth_key;
6602 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
6603 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
6606 ut_params->sess = rte_cryptodev_sym_session_create(
6607 ts_params->session_mpool);
6609 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6610 &ut_params->auth_xform,
6611 ts_params->session_mpool);
6613 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6619 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
6621 struct crypto_testsuite_params *ts_params = &testsuite_params;
6622 struct crypto_unittest_params *ut_params = &unittest_params;
6626 uint8_t *auth_tag, *plaintext;
6627 uint16_t plaintext_pad_len;
6629 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6630 "No GMAC length in the source data");
6632 retval = create_gmac_session(ts_params->valid_devs[0],
6633 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
6638 if (tdata->plaintext.len > MBUF_SIZE)
6639 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6641 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6642 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6643 "Failed to allocate input buffer in mempool");
6645 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6646 rte_pktmbuf_tailroom(ut_params->ibuf));
6648 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6650 * Runtime generate the large plain text instead of use hard code
6651 * plain text vector. It is done to avoid create huge source file
6652 * with the test vector.
6654 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6655 generate_gmac_large_plaintext(tdata->plaintext.data);
6657 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6659 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6661 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6662 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
6663 tdata->plaintext.len);
6665 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
6671 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6673 ut_params->op->sym->m_src = ut_params->ibuf;
6675 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6676 ut_params->op), "failed to process sym crypto op");
6678 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6679 "crypto op processing failed");
6681 if (ut_params->op->sym->m_dst) {
6682 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6683 uint8_t *, plaintext_pad_len);
6685 auth_tag = plaintext + plaintext_pad_len;
6688 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
6690 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6692 tdata->gmac_tag.data,
6693 tdata->gmac_tag.len,
6694 "GMAC Generated auth tag not as expected");
6700 test_AES_GMAC_authentication_test_case_1(void)
6702 return test_AES_GMAC_authentication(&gmac_test_case_1);
6706 test_AES_GMAC_authentication_test_case_2(void)
6708 return test_AES_GMAC_authentication(&gmac_test_case_2);
6712 test_AES_GMAC_authentication_test_case_3(void)
6714 return test_AES_GMAC_authentication(&gmac_test_case_3);
6718 test_AES_GMAC_authentication_test_case_4(void)
6720 return test_AES_GMAC_authentication(&gmac_test_case_4);
6724 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
6726 struct crypto_testsuite_params *ts_params = &testsuite_params;
6727 struct crypto_unittest_params *ut_params = &unittest_params;
6729 uint32_t plaintext_pad_len;
6732 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6733 "No GMAC length in the source data");
6735 retval = create_gmac_session(ts_params->valid_devs[0],
6736 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
6741 if (tdata->plaintext.len > MBUF_SIZE)
6742 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6744 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6745 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6746 "Failed to allocate input buffer in mempool");
6748 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6749 rte_pktmbuf_tailroom(ut_params->ibuf));
6751 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6754 * Runtime generate the large plain text instead of use hard code
6755 * plain text vector. It is done to avoid create huge source file
6756 * with the test vector.
6758 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6759 generate_gmac_large_plaintext(tdata->plaintext.data);
6761 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6763 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6765 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6766 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
6767 tdata->plaintext.len);
6769 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
6775 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6777 ut_params->op->sym->m_src = ut_params->ibuf;
6779 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6780 ut_params->op), "failed to process sym crypto op");
6782 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6783 "crypto op processing failed");
6790 test_AES_GMAC_authentication_verify_test_case_1(void)
6792 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
6796 test_AES_GMAC_authentication_verify_test_case_2(void)
6798 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
6802 test_AES_GMAC_authentication_verify_test_case_3(void)
6804 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
6808 test_AES_GMAC_authentication_verify_test_case_4(void)
6810 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
6813 struct test_crypto_vector {
6814 enum rte_crypto_cipher_algorithm crypto_algo;
6827 const uint8_t *data;
6832 const uint8_t *data;
6836 enum rte_crypto_auth_algorithm auth_algo;
6844 const uint8_t *data;
6854 static const struct test_crypto_vector
6855 hmac_sha1_test_crypto_vector = {
6856 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6858 .data = plaintext_hash,
6863 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6864 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6865 0xDE, 0xF4, 0xDE, 0xAD
6871 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
6872 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
6873 0x3F, 0x91, 0x64, 0x59
6879 static const struct test_crypto_vector
6880 aes128_gmac_test_vector = {
6881 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
6883 .data = plaintext_hash,
6888 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6889 0x08, 0x09, 0x0A, 0x0B
6895 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6896 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
6902 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
6903 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
6909 static const struct test_crypto_vector
6910 aes128cbc_hmac_sha1_test_vector = {
6911 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
6914 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
6915 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
6921 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6922 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
6927 .data = plaintext_hash,
6931 .data = ciphertext512_aes128cbc,
6934 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6937 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6938 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6939 0xDE, 0xF4, 0xDE, 0xAD
6945 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
6946 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6947 0x18, 0x8C, 0x1D, 0x32
6954 data_corruption(uint8_t *data)
6960 tag_corruption(uint8_t *data, unsigned int tag_offset)
6962 data[tag_offset] += 1;
6966 create_auth_session(struct crypto_unittest_params *ut_params,
6968 const struct test_crypto_vector *reference,
6969 enum rte_crypto_auth_operation auth_op)
6971 struct crypto_testsuite_params *ts_params = &testsuite_params;
6972 uint8_t auth_key[reference->auth_key.len + 1];
6974 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6976 /* Setup Authentication Parameters */
6977 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6978 ut_params->auth_xform.auth.op = auth_op;
6979 ut_params->auth_xform.next = NULL;
6980 ut_params->auth_xform.auth.algo = reference->auth_algo;
6981 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6982 ut_params->auth_xform.auth.key.data = auth_key;
6983 ut_params->auth_xform.auth.digest_length = reference->digest.len;
6985 /* Create Crypto session*/
6986 ut_params->sess = rte_cryptodev_sym_session_create(
6987 ts_params->session_mpool);
6989 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6990 &ut_params->auth_xform,
6991 ts_params->session_mpool);
6993 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6999 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
7001 const struct test_crypto_vector *reference,
7002 enum rte_crypto_auth_operation auth_op,
7003 enum rte_crypto_cipher_operation cipher_op)
7005 struct crypto_testsuite_params *ts_params = &testsuite_params;
7006 uint8_t cipher_key[reference->cipher_key.len + 1];
7007 uint8_t auth_key[reference->auth_key.len + 1];
7009 memcpy(cipher_key, reference->cipher_key.data,
7010 reference->cipher_key.len);
7011 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
7013 /* Setup Authentication Parameters */
7014 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7015 ut_params->auth_xform.auth.op = auth_op;
7016 ut_params->auth_xform.auth.algo = reference->auth_algo;
7017 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
7018 ut_params->auth_xform.auth.key.data = auth_key;
7019 ut_params->auth_xform.auth.digest_length = reference->digest.len;
7021 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
7022 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
7023 ut_params->auth_xform.auth.iv.length = reference->iv.len;
7025 ut_params->auth_xform.next = &ut_params->cipher_xform;
7027 /* Setup Cipher Parameters */
7028 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7029 ut_params->cipher_xform.next = NULL;
7030 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
7031 ut_params->cipher_xform.cipher.op = cipher_op;
7032 ut_params->cipher_xform.cipher.key.data = cipher_key;
7033 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
7034 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7035 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
7038 /* Create Crypto session*/
7039 ut_params->sess = rte_cryptodev_sym_session_create(
7040 ts_params->session_mpool);
7042 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7043 &ut_params->auth_xform,
7044 ts_params->session_mpool);
7046 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7052 create_auth_operation(struct crypto_testsuite_params *ts_params,
7053 struct crypto_unittest_params *ut_params,
7054 const struct test_crypto_vector *reference,
7055 unsigned int auth_generate)
7057 /* Generate Crypto op data structure */
7058 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7059 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7060 TEST_ASSERT_NOT_NULL(ut_params->op,
7061 "Failed to allocate pktmbuf offload");
7063 /* Set crypto operation data parameters */
7064 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7066 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7068 /* set crypto operation source mbuf */
7069 sym_op->m_src = ut_params->ibuf;
7072 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7073 ut_params->ibuf, reference->digest.len);
7075 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7076 "no room to append auth tag");
7078 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7079 ut_params->ibuf, reference->plaintext.len);
7082 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7084 memcpy(sym_op->auth.digest.data,
7085 reference->digest.data,
7086 reference->digest.len);
7088 TEST_HEXDUMP(stdout, "digest:",
7089 sym_op->auth.digest.data,
7090 reference->digest.len);
7092 sym_op->auth.data.length = reference->plaintext.len;
7093 sym_op->auth.data.offset = 0;
7099 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
7100 struct crypto_unittest_params *ut_params,
7101 const struct test_crypto_vector *reference,
7102 unsigned int auth_generate)
7104 /* Generate Crypto op data structure */
7105 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7106 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7107 TEST_ASSERT_NOT_NULL(ut_params->op,
7108 "Failed to allocate pktmbuf offload");
7110 /* Set crypto operation data parameters */
7111 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7113 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7115 /* set crypto operation source mbuf */
7116 sym_op->m_src = ut_params->ibuf;
7119 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7120 ut_params->ibuf, reference->digest.len);
7122 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7123 "no room to append auth tag");
7125 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7126 ut_params->ibuf, reference->ciphertext.len);
7129 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7131 memcpy(sym_op->auth.digest.data,
7132 reference->digest.data,
7133 reference->digest.len);
7135 TEST_HEXDUMP(stdout, "digest:",
7136 sym_op->auth.digest.data,
7137 reference->digest.len);
7139 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
7140 reference->iv.data, reference->iv.len);
7142 sym_op->cipher.data.length = 0;
7143 sym_op->cipher.data.offset = 0;
7145 sym_op->auth.data.length = reference->plaintext.len;
7146 sym_op->auth.data.offset = 0;
7152 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
7153 struct crypto_unittest_params *ut_params,
7154 const struct test_crypto_vector *reference,
7155 unsigned int auth_generate)
7157 /* Generate Crypto op data structure */
7158 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7159 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7160 TEST_ASSERT_NOT_NULL(ut_params->op,
7161 "Failed to allocate pktmbuf offload");
7163 /* Set crypto operation data parameters */
7164 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7166 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7168 /* set crypto operation source mbuf */
7169 sym_op->m_src = ut_params->ibuf;
7172 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7173 ut_params->ibuf, reference->digest.len);
7175 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7176 "no room to append auth tag");
7178 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7179 ut_params->ibuf, reference->ciphertext.len);
7182 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7184 memcpy(sym_op->auth.digest.data,
7185 reference->digest.data,
7186 reference->digest.len);
7188 TEST_HEXDUMP(stdout, "digest:",
7189 sym_op->auth.digest.data,
7190 reference->digest.len);
7192 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
7193 reference->iv.data, reference->iv.len);
7195 sym_op->cipher.data.length = reference->ciphertext.len;
7196 sym_op->cipher.data.offset = 0;
7198 sym_op->auth.data.length = reference->ciphertext.len;
7199 sym_op->auth.data.offset = 0;
7205 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7206 struct crypto_unittest_params *ut_params,
7207 const struct test_crypto_vector *reference)
7209 return create_auth_operation(ts_params, ut_params, reference, 0);
7213 create_auth_verify_GMAC_operation(
7214 struct crypto_testsuite_params *ts_params,
7215 struct crypto_unittest_params *ut_params,
7216 const struct test_crypto_vector *reference)
7218 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
7222 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7223 struct crypto_unittest_params *ut_params,
7224 const struct test_crypto_vector *reference)
7226 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
7230 test_authentication_verify_fail_when_data_corruption(
7231 struct crypto_testsuite_params *ts_params,
7232 struct crypto_unittest_params *ut_params,
7233 const struct test_crypto_vector *reference,
7234 unsigned int data_corrupted)
7240 /* Create session */
7241 retval = create_auth_session(ut_params,
7242 ts_params->valid_devs[0],
7244 RTE_CRYPTO_AUTH_OP_VERIFY);
7248 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7249 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7250 "Failed to allocate input buffer in mempool");
7252 /* clear mbuf payload */
7253 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7254 rte_pktmbuf_tailroom(ut_params->ibuf));
7256 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7257 reference->plaintext.len);
7258 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7259 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7261 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7263 /* Create operation */
7264 retval = create_auth_verify_operation(ts_params, ut_params, reference);
7270 data_corruption(plaintext);
7272 tag_corruption(plaintext, reference->plaintext.len);
7274 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7276 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7277 TEST_ASSERT_EQUAL(ut_params->op->status,
7278 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7279 "authentication not failed");
7281 ut_params->obuf = ut_params->op->sym->m_src;
7282 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7288 test_authentication_verify_GMAC_fail_when_corruption(
7289 struct crypto_testsuite_params *ts_params,
7290 struct crypto_unittest_params *ut_params,
7291 const struct test_crypto_vector *reference,
7292 unsigned int data_corrupted)
7297 /* Create session */
7298 retval = create_auth_cipher_session(ut_params,
7299 ts_params->valid_devs[0],
7301 RTE_CRYPTO_AUTH_OP_VERIFY,
7302 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7306 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7307 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7308 "Failed to allocate input buffer in mempool");
7310 /* clear mbuf payload */
7311 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7312 rte_pktmbuf_tailroom(ut_params->ibuf));
7314 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7315 reference->plaintext.len);
7316 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7317 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7319 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7321 /* Create operation */
7322 retval = create_auth_verify_GMAC_operation(ts_params,
7330 data_corruption(plaintext);
7332 tag_corruption(plaintext, reference->aad.len);
7334 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7336 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7337 TEST_ASSERT_EQUAL(ut_params->op->status,
7338 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7339 "authentication not failed");
7341 ut_params->obuf = ut_params->op->sym->m_src;
7342 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7348 test_authenticated_decryption_fail_when_corruption(
7349 struct crypto_testsuite_params *ts_params,
7350 struct crypto_unittest_params *ut_params,
7351 const struct test_crypto_vector *reference,
7352 unsigned int data_corrupted)
7356 uint8_t *ciphertext;
7358 /* Create session */
7359 retval = create_auth_cipher_session(ut_params,
7360 ts_params->valid_devs[0],
7362 RTE_CRYPTO_AUTH_OP_VERIFY,
7363 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7367 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7368 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7369 "Failed to allocate input buffer in mempool");
7371 /* clear mbuf payload */
7372 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7373 rte_pktmbuf_tailroom(ut_params->ibuf));
7375 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7376 reference->ciphertext.len);
7377 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
7378 memcpy(ciphertext, reference->ciphertext.data,
7379 reference->ciphertext.len);
7381 /* Create operation */
7382 retval = create_cipher_auth_verify_operation(ts_params,
7390 data_corruption(ciphertext);
7392 tag_corruption(ciphertext, reference->ciphertext.len);
7394 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7397 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7398 TEST_ASSERT_EQUAL(ut_params->op->status,
7399 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7400 "authentication not failed");
7402 ut_params->obuf = ut_params->op->sym->m_src;
7403 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7409 create_gcm_operation_SGL(enum rte_crypto_aead_operation op,
7410 const struct gcm_test_data *tdata,
7411 void *digest_mem, uint64_t digest_phys)
7413 struct crypto_testsuite_params *ts_params = &testsuite_params;
7414 struct crypto_unittest_params *ut_params = &unittest_params;
7416 const unsigned int auth_tag_len = tdata->auth_tag.len;
7417 const unsigned int iv_len = tdata->iv.len;
7418 const unsigned int aad_len = tdata->aad.len;
7420 /* Generate Crypto op data structure */
7421 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7422 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7423 TEST_ASSERT_NOT_NULL(ut_params->op,
7424 "Failed to allocate symmetric crypto operation struct");
7426 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7428 sym_op->aead.digest.data = digest_mem;
7430 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7431 "no room to append digest");
7433 sym_op->aead.digest.phys_addr = digest_phys;
7435 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
7436 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7438 TEST_HEXDUMP(stdout, "digest:",
7439 sym_op->aead.digest.data,
7443 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7444 uint8_t *, IV_OFFSET);
7446 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
7448 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
7449 ut_params->ibuf, aad_len);
7450 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7451 "no room to prepend aad");
7452 sym_op->aead.aad.phys_addr = rte_pktmbuf_mtophys(
7455 memset(sym_op->aead.aad.data, 0, aad_len);
7456 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
7458 TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
7459 TEST_HEXDUMP(stdout, "aad:",
7460 sym_op->aead.aad.data, aad_len);
7462 sym_op->aead.data.length = tdata->plaintext.len;
7463 sym_op->aead.data.offset = aad_len;
7468 #define SGL_MAX_NO 16
7471 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
7472 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
7474 struct crypto_testsuite_params *ts_params = &testsuite_params;
7475 struct crypto_unittest_params *ut_params = &unittest_params;
7476 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
7479 int to_trn_tbl[SGL_MAX_NO];
7481 unsigned int trn_data = 0;
7482 uint8_t *plaintext, *ciphertext, *auth_tag;
7484 if (fragsz > tdata->plaintext.len)
7485 fragsz = tdata->plaintext.len;
7487 uint16_t plaintext_len = fragsz;
7488 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7490 if (fragsz_oop > tdata->plaintext.len)
7491 frag_size_oop = tdata->plaintext.len;
7494 void *digest_mem = NULL;
7496 uint32_t prepend_len = tdata->aad.len;
7498 if (tdata->plaintext.len % fragsz != 0) {
7499 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
7502 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
7507 * For out-op-place we need to alloc another mbuf
7510 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7511 rte_pktmbuf_append(ut_params->obuf,
7512 frag_size_oop + prepend_len);
7513 buf_oop = ut_params->obuf;
7516 /* Create GCM session */
7517 retval = create_gcm_session(ts_params->valid_devs[0],
7518 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7519 tdata->key.data, tdata->key.len,
7520 tdata->aad.len, tdata->auth_tag.len,
7525 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7527 /* clear mbuf payload */
7528 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7529 rte_pktmbuf_tailroom(ut_params->ibuf));
7531 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7534 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7536 trn_data += plaintext_len;
7538 buf = ut_params->ibuf;
7541 * Loop until no more fragments
7544 while (trn_data < tdata->plaintext.len) {
7546 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
7547 (tdata->plaintext.len - trn_data) : fragsz;
7549 to_trn_tbl[ecx++] = to_trn;
7551 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7554 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7555 rte_pktmbuf_tailroom(buf));
7558 if (oop && !fragsz_oop) {
7559 buf_last_oop = buf_oop->next =
7560 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7561 buf_oop = buf_oop->next;
7562 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7563 0, rte_pktmbuf_tailroom(buf_oop));
7564 rte_pktmbuf_append(buf_oop, to_trn);
7567 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7570 memcpy(plaintext, tdata->plaintext.data + trn_data,
7573 if (trn_data == tdata->plaintext.len) {
7576 digest_mem = rte_pktmbuf_append(buf_oop,
7577 tdata->auth_tag.len);
7579 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
7580 tdata->auth_tag.len);
7584 uint64_t digest_phys = 0;
7586 ut_params->ibuf->nb_segs = segs;
7589 if (fragsz_oop && oop) {
7593 if (frag_size_oop == tdata->plaintext.len) {
7594 digest_mem = rte_pktmbuf_append(ut_params->obuf,
7595 tdata->auth_tag.len);
7597 digest_phys = rte_pktmbuf_mtophys_offset(
7599 tdata->plaintext.len + prepend_len);
7602 trn_data = frag_size_oop;
7603 while (trn_data < tdata->plaintext.len) {
7606 (tdata->plaintext.len - trn_data <
7608 (tdata->plaintext.len - trn_data) :
7611 to_trn_tbl[ecx++] = to_trn;
7613 buf_last_oop = buf_oop->next =
7614 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7615 buf_oop = buf_oop->next;
7616 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7617 0, rte_pktmbuf_tailroom(buf_oop));
7618 rte_pktmbuf_append(buf_oop, to_trn);
7622 if (trn_data == tdata->plaintext.len) {
7623 digest_mem = rte_pktmbuf_append(buf_oop,
7624 tdata->auth_tag.len);
7628 ut_params->obuf->nb_segs = segs;
7632 * Place digest at the end of the last buffer
7635 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
7636 if (oop && buf_last_oop)
7637 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
7639 if (!digest_mem && !oop) {
7640 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7641 + tdata->auth_tag.len);
7642 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
7643 tdata->plaintext.len);
7646 /* Create GCM opertaion */
7647 retval = create_gcm_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
7648 tdata, digest_mem, digest_phys);
7653 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7655 ut_params->op->sym->m_src = ut_params->ibuf;
7657 ut_params->op->sym->m_dst = ut_params->obuf;
7659 /* Process crypto operation */
7660 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7661 ut_params->op), "failed to process sym crypto op");
7663 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7664 "crypto op processing failed");
7667 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7668 uint8_t *, prepend_len);
7670 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7671 uint8_t *, prepend_len);
7675 fragsz = fragsz_oop;
7677 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7679 tdata->ciphertext.data,
7681 "GCM Ciphertext data not as expected");
7683 buf = ut_params->op->sym->m_src->next;
7685 buf = ut_params->op->sym->m_dst->next;
7687 unsigned int off = fragsz;
7691 ciphertext = rte_pktmbuf_mtod(buf,
7694 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7696 tdata->ciphertext.data + off,
7698 "GCM Ciphertext data not as expected");
7700 off += to_trn_tbl[ecx++];
7704 auth_tag = digest_mem;
7705 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7707 tdata->auth_tag.data,
7708 tdata->auth_tag.len,
7709 "GCM Generated auth tag not as expected");
7715 #define OUT_OF_PLACE 1
7718 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
7720 return test_AES_GCM_authenticated_encryption_SGL(
7721 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
7725 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
7727 return test_AES_GCM_authenticated_encryption_SGL(
7728 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
7732 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
7734 return test_AES_GCM_authenticated_encryption_SGL(
7735 &gcm_test_case_8, OUT_OF_PLACE, 400,
7736 gcm_test_case_8.plaintext.len);
7740 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
7743 return test_AES_GCM_authenticated_encryption_SGL(
7744 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
7748 test_authentication_verify_fail_when_data_corrupted(
7749 struct crypto_testsuite_params *ts_params,
7750 struct crypto_unittest_params *ut_params,
7751 const struct test_crypto_vector *reference)
7753 return test_authentication_verify_fail_when_data_corruption(
7754 ts_params, ut_params, reference, 1);
7758 test_authentication_verify_fail_when_tag_corrupted(
7759 struct crypto_testsuite_params *ts_params,
7760 struct crypto_unittest_params *ut_params,
7761 const struct test_crypto_vector *reference)
7763 return test_authentication_verify_fail_when_data_corruption(
7764 ts_params, ut_params, reference, 0);
7768 test_authentication_verify_GMAC_fail_when_data_corrupted(
7769 struct crypto_testsuite_params *ts_params,
7770 struct crypto_unittest_params *ut_params,
7771 const struct test_crypto_vector *reference)
7773 return test_authentication_verify_GMAC_fail_when_corruption(
7774 ts_params, ut_params, reference, 1);
7778 test_authentication_verify_GMAC_fail_when_tag_corrupted(
7779 struct crypto_testsuite_params *ts_params,
7780 struct crypto_unittest_params *ut_params,
7781 const struct test_crypto_vector *reference)
7783 return test_authentication_verify_GMAC_fail_when_corruption(
7784 ts_params, ut_params, reference, 0);
7788 test_authenticated_decryption_fail_when_data_corrupted(
7789 struct crypto_testsuite_params *ts_params,
7790 struct crypto_unittest_params *ut_params,
7791 const struct test_crypto_vector *reference)
7793 return test_authenticated_decryption_fail_when_corruption(
7794 ts_params, ut_params, reference, 1);
7798 test_authenticated_decryption_fail_when_tag_corrupted(
7799 struct crypto_testsuite_params *ts_params,
7800 struct crypto_unittest_params *ut_params,
7801 const struct test_crypto_vector *reference)
7803 return test_authenticated_decryption_fail_when_corruption(
7804 ts_params, ut_params, reference, 0);
7808 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
7810 return test_authentication_verify_fail_when_data_corrupted(
7811 &testsuite_params, &unittest_params,
7812 &hmac_sha1_test_crypto_vector);
7816 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
7818 return test_authentication_verify_fail_when_tag_corrupted(
7819 &testsuite_params, &unittest_params,
7820 &hmac_sha1_test_crypto_vector);
7824 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
7826 return test_authentication_verify_GMAC_fail_when_data_corrupted(
7827 &testsuite_params, &unittest_params,
7828 &aes128_gmac_test_vector);
7832 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
7834 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
7835 &testsuite_params, &unittest_params,
7836 &aes128_gmac_test_vector);
7840 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
7842 return test_authenticated_decryption_fail_when_data_corrupted(
7845 &aes128cbc_hmac_sha1_test_vector);
7849 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
7851 return test_authenticated_decryption_fail_when_tag_corrupted(
7854 &aes128cbc_hmac_sha1_test_vector);
7857 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
7859 /* global AESNI slave IDs for the scheduler test */
7860 uint8_t aesni_ids[2];
7863 test_scheduler_attach_slave_op(void)
7865 struct crypto_testsuite_params *ts_params = &testsuite_params;
7866 uint8_t sched_id = ts_params->valid_devs[0];
7867 uint32_t nb_devs, i, nb_devs_attached = 0;
7871 /* create 2 AESNI_MB if necessary */
7872 nb_devs = rte_cryptodev_device_count_by_driver(
7873 rte_cryptodev_driver_id_get(
7874 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
7876 for (i = nb_devs; i < 2; i++) {
7877 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
7878 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
7880 ret = rte_vdev_init(vdev_name, NULL);
7882 TEST_ASSERT(ret == 0,
7883 "Failed to create instance %u of"
7885 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7889 /* attach 2 AESNI_MB cdevs */
7890 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
7892 struct rte_cryptodev_info info;
7894 rte_cryptodev_info_get(i, &info);
7895 if (info.driver_id != rte_cryptodev_driver_id_get(
7896 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
7900 * Create the session mempool again, since now there are new devices
7901 * to use the mempool.
7903 if (ts_params->session_mpool) {
7904 rte_mempool_free(ts_params->session_mpool);
7905 ts_params->session_mpool = NULL;
7907 unsigned int session_size = rte_cryptodev_get_private_session_size(i);
7910 * Create mempool with maximum number of sessions * 2,
7911 * to include the session headers
7913 if (ts_params->session_mpool == NULL) {
7914 ts_params->session_mpool = rte_mempool_create(
7916 info.sym.max_nb_sessions * 2,
7918 0, 0, NULL, NULL, NULL,
7919 NULL, SOCKET_ID_ANY,
7922 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
7923 "session mempool allocation failed");
7926 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
7929 TEST_ASSERT(ret == 0,
7930 "Failed to attach device %u of pmd : %s", i,
7931 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7933 aesni_ids[nb_devs_attached] = (uint8_t)i;
7942 test_scheduler_detach_slave_op(void)
7944 struct crypto_testsuite_params *ts_params = &testsuite_params;
7945 uint8_t sched_id = ts_params->valid_devs[0];
7949 for (i = 0; i < 2; i++) {
7950 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
7952 TEST_ASSERT(ret == 0,
7953 "Failed to detach device %u", aesni_ids[i]);
7960 test_scheduler_mode_op(void)
7962 struct crypto_testsuite_params *ts_params = &testsuite_params;
7963 uint8_t sched_id = ts_params->valid_devs[0];
7964 struct rte_cryptodev_scheduler_ops op = {0};
7965 struct rte_cryptodev_scheduler dummy_scheduler = {
7966 .description = "dummy scheduler to test mode",
7967 .name = "dummy scheduler",
7968 .mode = CDEV_SCHED_MODE_USERDEFINED,
7973 /* set user defined mode */
7974 ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
7976 TEST_ASSERT(ret == 0,
7977 "Failed to set cdev %u to user defined mode", sched_id);
7979 /* set round robin mode */
7980 ret = rte_cryptodev_scheduler_mode_set(sched_id,
7981 CDEV_SCHED_MODE_ROUNDROBIN);
7982 TEST_ASSERT(ret == 0,
7983 "Failed to set cdev %u to round-robin mode", sched_id);
7984 TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) ==
7985 CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
7991 static struct unit_test_suite cryptodev_scheduler_testsuite = {
7992 .suite_name = "Crypto Device Scheduler Unit Test Suite",
7993 .setup = testsuite_setup,
7994 .teardown = testsuite_teardown,
7995 .unit_test_cases = {
7996 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
7997 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
7998 TEST_CASE_ST(ut_setup, ut_teardown,
7999 test_AES_chain_scheduler_all),
8000 TEST_CASE_ST(ut_setup, ut_teardown,
8001 test_AES_cipheronly_scheduler_all),
8002 TEST_CASE_ST(ut_setup, ut_teardown,
8003 test_authonly_scheduler_all),
8004 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8005 TEST_CASES_END() /**< NULL terminate unit test array */
8009 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
8011 static struct unit_test_suite cryptodev_qat_testsuite = {
8012 .suite_name = "Crypto QAT Unit Test Suite",
8013 .setup = testsuite_setup,
8014 .teardown = testsuite_teardown,
8015 .unit_test_cases = {
8016 TEST_CASE_ST(ut_setup, ut_teardown,
8017 test_device_configure_invalid_dev_id),
8018 TEST_CASE_ST(ut_setup, ut_teardown,
8019 test_device_configure_invalid_queue_pair_ids),
8020 TEST_CASE_ST(ut_setup, ut_teardown,
8021 test_queue_pair_descriptor_setup),
8022 TEST_CASE_ST(ut_setup, ut_teardown,
8023 test_multi_session),
8025 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
8026 TEST_CASE_ST(ut_setup, ut_teardown,
8027 test_AES_cipheronly_qat_all),
8028 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
8029 TEST_CASE_ST(ut_setup, ut_teardown,
8030 test_3DES_cipheronly_qat_all),
8031 TEST_CASE_ST(ut_setup, ut_teardown,
8032 test_DES_cipheronly_qat_all),
8033 TEST_CASE_ST(ut_setup, ut_teardown,
8034 test_AES_docsis_qat_all),
8035 TEST_CASE_ST(ut_setup, ut_teardown,
8036 test_DES_docsis_qat_all),
8037 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
8038 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
8040 /** AES GCM Authenticated Encryption */
8041 TEST_CASE_ST(ut_setup, ut_teardown,
8042 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
8043 TEST_CASE_ST(ut_setup, ut_teardown,
8044 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
8045 TEST_CASE_ST(ut_setup, ut_teardown,
8046 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
8047 TEST_CASE_ST(ut_setup, ut_teardown,
8048 test_AES_GCM_authenticated_encryption_test_case_1),
8049 TEST_CASE_ST(ut_setup, ut_teardown,
8050 test_AES_GCM_authenticated_encryption_test_case_2),
8051 TEST_CASE_ST(ut_setup, ut_teardown,
8052 test_AES_GCM_authenticated_encryption_test_case_3),
8053 TEST_CASE_ST(ut_setup, ut_teardown,
8054 test_AES_GCM_authenticated_encryption_test_case_4),
8055 TEST_CASE_ST(ut_setup, ut_teardown,
8056 test_AES_GCM_authenticated_encryption_test_case_5),
8057 TEST_CASE_ST(ut_setup, ut_teardown,
8058 test_AES_GCM_authenticated_encryption_test_case_6),
8059 TEST_CASE_ST(ut_setup, ut_teardown,
8060 test_AES_GCM_authenticated_encryption_test_case_7),
8062 /** AES GCM Authenticated Decryption */
8063 TEST_CASE_ST(ut_setup, ut_teardown,
8064 test_AES_GCM_authenticated_decryption_test_case_1),
8065 TEST_CASE_ST(ut_setup, ut_teardown,
8066 test_AES_GCM_authenticated_decryption_test_case_2),
8067 TEST_CASE_ST(ut_setup, ut_teardown,
8068 test_AES_GCM_authenticated_decryption_test_case_3),
8069 TEST_CASE_ST(ut_setup, ut_teardown,
8070 test_AES_GCM_authenticated_decryption_test_case_4),
8071 TEST_CASE_ST(ut_setup, ut_teardown,
8072 test_AES_GCM_authenticated_decryption_test_case_5),
8073 TEST_CASE_ST(ut_setup, ut_teardown,
8074 test_AES_GCM_authenticated_decryption_test_case_6),
8075 TEST_CASE_ST(ut_setup, ut_teardown,
8076 test_AES_GCM_authenticated_decryption_test_case_7),
8078 /** AES GCM Authenticated Encryption 192 bits key */
8079 TEST_CASE_ST(ut_setup, ut_teardown,
8080 test_AES_GCM_auth_encryption_test_case_192_1),
8081 TEST_CASE_ST(ut_setup, ut_teardown,
8082 test_AES_GCM_auth_encryption_test_case_192_2),
8083 TEST_CASE_ST(ut_setup, ut_teardown,
8084 test_AES_GCM_auth_encryption_test_case_192_3),
8085 TEST_CASE_ST(ut_setup, ut_teardown,
8086 test_AES_GCM_auth_encryption_test_case_192_4),
8087 TEST_CASE_ST(ut_setup, ut_teardown,
8088 test_AES_GCM_auth_encryption_test_case_192_5),
8089 TEST_CASE_ST(ut_setup, ut_teardown,
8090 test_AES_GCM_auth_encryption_test_case_192_6),
8091 TEST_CASE_ST(ut_setup, ut_teardown,
8092 test_AES_GCM_auth_encryption_test_case_192_7),
8094 /** AES GCM Authenticated Decryption 192 bits key */
8095 TEST_CASE_ST(ut_setup, ut_teardown,
8096 test_AES_GCM_auth_decryption_test_case_192_1),
8097 TEST_CASE_ST(ut_setup, ut_teardown,
8098 test_AES_GCM_auth_decryption_test_case_192_2),
8099 TEST_CASE_ST(ut_setup, ut_teardown,
8100 test_AES_GCM_auth_decryption_test_case_192_3),
8101 TEST_CASE_ST(ut_setup, ut_teardown,
8102 test_AES_GCM_auth_decryption_test_case_192_4),
8103 TEST_CASE_ST(ut_setup, ut_teardown,
8104 test_AES_GCM_auth_decryption_test_case_192_5),
8105 TEST_CASE_ST(ut_setup, ut_teardown,
8106 test_AES_GCM_auth_decryption_test_case_192_6),
8107 TEST_CASE_ST(ut_setup, ut_teardown,
8108 test_AES_GCM_auth_decryption_test_case_192_7),
8110 /** AES GCM Authenticated Encryption 256 bits key */
8111 TEST_CASE_ST(ut_setup, ut_teardown,
8112 test_AES_GCM_auth_encryption_test_case_256_1),
8113 TEST_CASE_ST(ut_setup, ut_teardown,
8114 test_AES_GCM_auth_encryption_test_case_256_2),
8115 TEST_CASE_ST(ut_setup, ut_teardown,
8116 test_AES_GCM_auth_encryption_test_case_256_3),
8117 TEST_CASE_ST(ut_setup, ut_teardown,
8118 test_AES_GCM_auth_encryption_test_case_256_4),
8119 TEST_CASE_ST(ut_setup, ut_teardown,
8120 test_AES_GCM_auth_encryption_test_case_256_5),
8121 TEST_CASE_ST(ut_setup, ut_teardown,
8122 test_AES_GCM_auth_encryption_test_case_256_6),
8123 TEST_CASE_ST(ut_setup, ut_teardown,
8124 test_AES_GCM_auth_encryption_test_case_256_7),
8126 /** AES GMAC Authentication */
8127 TEST_CASE_ST(ut_setup, ut_teardown,
8128 test_AES_GMAC_authentication_test_case_1),
8129 TEST_CASE_ST(ut_setup, ut_teardown,
8130 test_AES_GMAC_authentication_verify_test_case_1),
8131 TEST_CASE_ST(ut_setup, ut_teardown,
8132 test_AES_GMAC_authentication_test_case_2),
8133 TEST_CASE_ST(ut_setup, ut_teardown,
8134 test_AES_GMAC_authentication_verify_test_case_2),
8135 TEST_CASE_ST(ut_setup, ut_teardown,
8136 test_AES_GMAC_authentication_test_case_3),
8137 TEST_CASE_ST(ut_setup, ut_teardown,
8138 test_AES_GMAC_authentication_verify_test_case_3),
8140 /** SNOW 3G encrypt only (UEA2) */
8141 TEST_CASE_ST(ut_setup, ut_teardown,
8142 test_snow3g_encryption_test_case_1),
8143 TEST_CASE_ST(ut_setup, ut_teardown,
8144 test_snow3g_encryption_test_case_2),
8145 TEST_CASE_ST(ut_setup, ut_teardown,
8146 test_snow3g_encryption_test_case_3),
8147 TEST_CASE_ST(ut_setup, ut_teardown,
8148 test_snow3g_encryption_test_case_4),
8149 TEST_CASE_ST(ut_setup, ut_teardown,
8150 test_snow3g_encryption_test_case_5),
8152 TEST_CASE_ST(ut_setup, ut_teardown,
8153 test_snow3g_encryption_test_case_1_oop),
8154 TEST_CASE_ST(ut_setup, ut_teardown,
8155 test_snow3g_decryption_test_case_1_oop),
8157 /** SNOW 3G decrypt only (UEA2) */
8158 TEST_CASE_ST(ut_setup, ut_teardown,
8159 test_snow3g_decryption_test_case_1),
8160 TEST_CASE_ST(ut_setup, ut_teardown,
8161 test_snow3g_decryption_test_case_2),
8162 TEST_CASE_ST(ut_setup, ut_teardown,
8163 test_snow3g_decryption_test_case_3),
8164 TEST_CASE_ST(ut_setup, ut_teardown,
8165 test_snow3g_decryption_test_case_4),
8166 TEST_CASE_ST(ut_setup, ut_teardown,
8167 test_snow3g_decryption_test_case_5),
8168 TEST_CASE_ST(ut_setup, ut_teardown,
8169 test_snow3g_hash_generate_test_case_1),
8170 TEST_CASE_ST(ut_setup, ut_teardown,
8171 test_snow3g_hash_generate_test_case_2),
8172 TEST_CASE_ST(ut_setup, ut_teardown,
8173 test_snow3g_hash_generate_test_case_3),
8174 TEST_CASE_ST(ut_setup, ut_teardown,
8175 test_snow3g_hash_verify_test_case_1),
8176 TEST_CASE_ST(ut_setup, ut_teardown,
8177 test_snow3g_hash_verify_test_case_2),
8178 TEST_CASE_ST(ut_setup, ut_teardown,
8179 test_snow3g_hash_verify_test_case_3),
8180 TEST_CASE_ST(ut_setup, ut_teardown,
8181 test_snow3g_cipher_auth_test_case_1),
8182 TEST_CASE_ST(ut_setup, ut_teardown,
8183 test_snow3g_auth_cipher_test_case_1),
8185 /** ZUC encrypt only (EEA3) */
8186 TEST_CASE_ST(ut_setup, ut_teardown,
8187 test_zuc_encryption_test_case_1),
8188 TEST_CASE_ST(ut_setup, ut_teardown,
8189 test_zuc_encryption_test_case_2),
8190 TEST_CASE_ST(ut_setup, ut_teardown,
8191 test_zuc_encryption_test_case_3),
8192 TEST_CASE_ST(ut_setup, ut_teardown,
8193 test_zuc_encryption_test_case_4),
8194 TEST_CASE_ST(ut_setup, ut_teardown,
8195 test_zuc_encryption_test_case_5),
8197 /** ZUC authenticate (EIA3) */
8198 TEST_CASE_ST(ut_setup, ut_teardown,
8199 test_zuc_hash_generate_test_case_6),
8200 TEST_CASE_ST(ut_setup, ut_teardown,
8201 test_zuc_hash_generate_test_case_7),
8202 TEST_CASE_ST(ut_setup, ut_teardown,
8203 test_zuc_hash_generate_test_case_8),
8205 /** ZUC alg-chain (EEA3/EIA3) */
8206 TEST_CASE_ST(ut_setup, ut_teardown,
8207 test_zuc_cipher_auth_test_case_1),
8208 TEST_CASE_ST(ut_setup, ut_teardown,
8209 test_zuc_cipher_auth_test_case_2),
8211 /** HMAC_MD5 Authentication */
8212 TEST_CASE_ST(ut_setup, ut_teardown,
8213 test_MD5_HMAC_generate_case_1),
8214 TEST_CASE_ST(ut_setup, ut_teardown,
8215 test_MD5_HMAC_verify_case_1),
8216 TEST_CASE_ST(ut_setup, ut_teardown,
8217 test_MD5_HMAC_generate_case_2),
8218 TEST_CASE_ST(ut_setup, ut_teardown,
8219 test_MD5_HMAC_verify_case_2),
8222 TEST_CASE_ST(ut_setup, ut_teardown,
8223 test_null_auth_only_operation),
8224 TEST_CASE_ST(ut_setup, ut_teardown,
8225 test_null_cipher_only_operation),
8226 TEST_CASE_ST(ut_setup, ut_teardown,
8227 test_null_cipher_auth_operation),
8228 TEST_CASE_ST(ut_setup, ut_teardown,
8229 test_null_auth_cipher_operation),
8232 TEST_CASE_ST(ut_setup, ut_teardown,
8233 test_kasumi_hash_generate_test_case_1),
8234 TEST_CASE_ST(ut_setup, ut_teardown,
8235 test_kasumi_hash_generate_test_case_2),
8236 TEST_CASE_ST(ut_setup, ut_teardown,
8237 test_kasumi_hash_generate_test_case_3),
8238 TEST_CASE_ST(ut_setup, ut_teardown,
8239 test_kasumi_hash_generate_test_case_4),
8240 TEST_CASE_ST(ut_setup, ut_teardown,
8241 test_kasumi_hash_generate_test_case_5),
8242 TEST_CASE_ST(ut_setup, ut_teardown,
8243 test_kasumi_hash_generate_test_case_6),
8245 TEST_CASE_ST(ut_setup, ut_teardown,
8246 test_kasumi_hash_verify_test_case_1),
8247 TEST_CASE_ST(ut_setup, ut_teardown,
8248 test_kasumi_hash_verify_test_case_2),
8249 TEST_CASE_ST(ut_setup, ut_teardown,
8250 test_kasumi_hash_verify_test_case_3),
8251 TEST_CASE_ST(ut_setup, ut_teardown,
8252 test_kasumi_hash_verify_test_case_4),
8253 TEST_CASE_ST(ut_setup, ut_teardown,
8254 test_kasumi_hash_verify_test_case_5),
8256 TEST_CASE_ST(ut_setup, ut_teardown,
8257 test_kasumi_encryption_test_case_1),
8258 TEST_CASE_ST(ut_setup, ut_teardown,
8259 test_kasumi_encryption_test_case_3),
8260 TEST_CASE_ST(ut_setup, ut_teardown,
8261 test_kasumi_auth_cipher_test_case_1),
8262 TEST_CASE_ST(ut_setup, ut_teardown,
8263 test_kasumi_cipher_auth_test_case_1),
8265 /** Negative tests */
8266 TEST_CASE_ST(ut_setup, ut_teardown,
8267 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8268 TEST_CASE_ST(ut_setup, ut_teardown,
8269 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8270 TEST_CASE_ST(ut_setup, ut_teardown,
8271 authentication_verify_AES128_GMAC_fail_data_corrupt),
8272 TEST_CASE_ST(ut_setup, ut_teardown,
8273 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8274 TEST_CASE_ST(ut_setup, ut_teardown,
8275 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8276 TEST_CASE_ST(ut_setup, ut_teardown,
8277 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8279 TEST_CASES_END() /**< NULL terminate unit test array */
8283 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
8284 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
8285 .setup = testsuite_setup,
8286 .teardown = testsuite_teardown,
8287 .unit_test_cases = {
8288 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
8289 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
8290 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
8291 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
8293 TEST_CASES_END() /**< NULL terminate unit test array */
8297 static struct unit_test_suite cryptodev_openssl_testsuite = {
8298 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
8299 .setup = testsuite_setup,
8300 .teardown = testsuite_teardown,
8301 .unit_test_cases = {
8302 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
8303 TEST_CASE_ST(ut_setup, ut_teardown,
8304 test_multi_session_random_usage),
8305 TEST_CASE_ST(ut_setup, ut_teardown,
8306 test_AES_chain_openssl_all),
8307 TEST_CASE_ST(ut_setup, ut_teardown,
8308 test_AES_cipheronly_openssl_all),
8309 TEST_CASE_ST(ut_setup, ut_teardown,
8310 test_3DES_chain_openssl_all),
8311 TEST_CASE_ST(ut_setup, ut_teardown,
8312 test_3DES_cipheronly_openssl_all),
8313 TEST_CASE_ST(ut_setup, ut_teardown,
8314 test_DES_docsis_openssl_all),
8315 TEST_CASE_ST(ut_setup, ut_teardown,
8316 test_authonly_openssl_all),
8318 /** AES GCM Authenticated Encryption */
8319 TEST_CASE_ST(ut_setup, ut_teardown,
8320 test_AES_GCM_authenticated_encryption_test_case_1),
8321 TEST_CASE_ST(ut_setup, ut_teardown,
8322 test_AES_GCM_authenticated_encryption_test_case_2),
8323 TEST_CASE_ST(ut_setup, ut_teardown,
8324 test_AES_GCM_authenticated_encryption_test_case_3),
8325 TEST_CASE_ST(ut_setup, ut_teardown,
8326 test_AES_GCM_authenticated_encryption_test_case_4),
8327 TEST_CASE_ST(ut_setup, ut_teardown,
8328 test_AES_GCM_authenticated_encryption_test_case_5),
8329 TEST_CASE_ST(ut_setup, ut_teardown,
8330 test_AES_GCM_authenticated_encryption_test_case_6),
8331 TEST_CASE_ST(ut_setup, ut_teardown,
8332 test_AES_GCM_authenticated_encryption_test_case_7),
8334 /** AES GCM Authenticated Decryption */
8335 TEST_CASE_ST(ut_setup, ut_teardown,
8336 test_AES_GCM_authenticated_decryption_test_case_1),
8337 TEST_CASE_ST(ut_setup, ut_teardown,
8338 test_AES_GCM_authenticated_decryption_test_case_2),
8339 TEST_CASE_ST(ut_setup, ut_teardown,
8340 test_AES_GCM_authenticated_decryption_test_case_3),
8341 TEST_CASE_ST(ut_setup, ut_teardown,
8342 test_AES_GCM_authenticated_decryption_test_case_4),
8343 TEST_CASE_ST(ut_setup, ut_teardown,
8344 test_AES_GCM_authenticated_decryption_test_case_5),
8345 TEST_CASE_ST(ut_setup, ut_teardown,
8346 test_AES_GCM_authenticated_decryption_test_case_6),
8347 TEST_CASE_ST(ut_setup, ut_teardown,
8348 test_AES_GCM_authenticated_decryption_test_case_7),
8351 /** AES GCM Authenticated Encryption 192 bits key */
8352 TEST_CASE_ST(ut_setup, ut_teardown,
8353 test_AES_GCM_auth_encryption_test_case_192_1),
8354 TEST_CASE_ST(ut_setup, ut_teardown,
8355 test_AES_GCM_auth_encryption_test_case_192_2),
8356 TEST_CASE_ST(ut_setup, ut_teardown,
8357 test_AES_GCM_auth_encryption_test_case_192_3),
8358 TEST_CASE_ST(ut_setup, ut_teardown,
8359 test_AES_GCM_auth_encryption_test_case_192_4),
8360 TEST_CASE_ST(ut_setup, ut_teardown,
8361 test_AES_GCM_auth_encryption_test_case_192_5),
8362 TEST_CASE_ST(ut_setup, ut_teardown,
8363 test_AES_GCM_auth_encryption_test_case_192_6),
8364 TEST_CASE_ST(ut_setup, ut_teardown,
8365 test_AES_GCM_auth_encryption_test_case_192_7),
8367 /** AES GCM Authenticated Decryption 192 bits key */
8368 TEST_CASE_ST(ut_setup, ut_teardown,
8369 test_AES_GCM_auth_decryption_test_case_192_1),
8370 TEST_CASE_ST(ut_setup, ut_teardown,
8371 test_AES_GCM_auth_decryption_test_case_192_2),
8372 TEST_CASE_ST(ut_setup, ut_teardown,
8373 test_AES_GCM_auth_decryption_test_case_192_3),
8374 TEST_CASE_ST(ut_setup, ut_teardown,
8375 test_AES_GCM_auth_decryption_test_case_192_4),
8376 TEST_CASE_ST(ut_setup, ut_teardown,
8377 test_AES_GCM_auth_decryption_test_case_192_5),
8378 TEST_CASE_ST(ut_setup, ut_teardown,
8379 test_AES_GCM_auth_decryption_test_case_192_6),
8380 TEST_CASE_ST(ut_setup, ut_teardown,
8381 test_AES_GCM_auth_decryption_test_case_192_7),
8383 /** AES GCM Authenticated Encryption 256 bits key */
8384 TEST_CASE_ST(ut_setup, ut_teardown,
8385 test_AES_GCM_auth_encryption_test_case_256_1),
8386 TEST_CASE_ST(ut_setup, ut_teardown,
8387 test_AES_GCM_auth_encryption_test_case_256_2),
8388 TEST_CASE_ST(ut_setup, ut_teardown,
8389 test_AES_GCM_auth_encryption_test_case_256_3),
8390 TEST_CASE_ST(ut_setup, ut_teardown,
8391 test_AES_GCM_auth_encryption_test_case_256_4),
8392 TEST_CASE_ST(ut_setup, ut_teardown,
8393 test_AES_GCM_auth_encryption_test_case_256_5),
8394 TEST_CASE_ST(ut_setup, ut_teardown,
8395 test_AES_GCM_auth_encryption_test_case_256_6),
8396 TEST_CASE_ST(ut_setup, ut_teardown,
8397 test_AES_GCM_auth_encryption_test_case_256_7),
8399 /** AES GCM Authenticated Decryption 256 bits key */
8400 TEST_CASE_ST(ut_setup, ut_teardown,
8401 test_AES_GCM_auth_decryption_test_case_256_1),
8402 TEST_CASE_ST(ut_setup, ut_teardown,
8403 test_AES_GCM_auth_decryption_test_case_256_2),
8404 TEST_CASE_ST(ut_setup, ut_teardown,
8405 test_AES_GCM_auth_decryption_test_case_256_3),
8406 TEST_CASE_ST(ut_setup, ut_teardown,
8407 test_AES_GCM_auth_decryption_test_case_256_4),
8408 TEST_CASE_ST(ut_setup, ut_teardown,
8409 test_AES_GCM_auth_decryption_test_case_256_5),
8410 TEST_CASE_ST(ut_setup, ut_teardown,
8411 test_AES_GCM_auth_decryption_test_case_256_6),
8412 TEST_CASE_ST(ut_setup, ut_teardown,
8413 test_AES_GCM_auth_decryption_test_case_256_7),
8415 /** AES GMAC Authentication */
8416 TEST_CASE_ST(ut_setup, ut_teardown,
8417 test_AES_GMAC_authentication_test_case_1),
8418 TEST_CASE_ST(ut_setup, ut_teardown,
8419 test_AES_GMAC_authentication_verify_test_case_1),
8420 TEST_CASE_ST(ut_setup, ut_teardown,
8421 test_AES_GMAC_authentication_test_case_2),
8422 TEST_CASE_ST(ut_setup, ut_teardown,
8423 test_AES_GMAC_authentication_verify_test_case_2),
8424 TEST_CASE_ST(ut_setup, ut_teardown,
8425 test_AES_GMAC_authentication_test_case_3),
8426 TEST_CASE_ST(ut_setup, ut_teardown,
8427 test_AES_GMAC_authentication_verify_test_case_3),
8428 TEST_CASE_ST(ut_setup, ut_teardown,
8429 test_AES_GMAC_authentication_test_case_4),
8430 TEST_CASE_ST(ut_setup, ut_teardown,
8431 test_AES_GMAC_authentication_verify_test_case_4),
8433 /** Scatter-Gather */
8434 TEST_CASE_ST(ut_setup, ut_teardown,
8435 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8437 /** Negative tests */
8438 TEST_CASE_ST(ut_setup, ut_teardown,
8439 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8440 TEST_CASE_ST(ut_setup, ut_teardown,
8441 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8442 TEST_CASE_ST(ut_setup, ut_teardown,
8443 authentication_verify_AES128_GMAC_fail_data_corrupt),
8444 TEST_CASE_ST(ut_setup, ut_teardown,
8445 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8446 TEST_CASE_ST(ut_setup, ut_teardown,
8447 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8448 TEST_CASE_ST(ut_setup, ut_teardown,
8449 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8451 TEST_CASES_END() /**< NULL terminate unit test array */
8455 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
8456 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
8457 .setup = testsuite_setup,
8458 .teardown = testsuite_teardown,
8459 .unit_test_cases = {
8460 /** AES GCM Authenticated Encryption */
8461 TEST_CASE_ST(ut_setup, ut_teardown,
8462 test_AES_GCM_authenticated_encryption_test_case_1),
8463 TEST_CASE_ST(ut_setup, ut_teardown,
8464 test_AES_GCM_authenticated_encryption_test_case_2),
8465 TEST_CASE_ST(ut_setup, ut_teardown,
8466 test_AES_GCM_authenticated_encryption_test_case_3),
8467 TEST_CASE_ST(ut_setup, ut_teardown,
8468 test_AES_GCM_authenticated_encryption_test_case_4),
8469 TEST_CASE_ST(ut_setup, ut_teardown,
8470 test_AES_GCM_authenticated_encryption_test_case_5),
8471 TEST_CASE_ST(ut_setup, ut_teardown,
8472 test_AES_GCM_authenticated_encryption_test_case_6),
8473 TEST_CASE_ST(ut_setup, ut_teardown,
8474 test_AES_GCM_authenticated_encryption_test_case_7),
8476 /** AES GCM Authenticated Decryption */
8477 TEST_CASE_ST(ut_setup, ut_teardown,
8478 test_AES_GCM_authenticated_decryption_test_case_1),
8479 TEST_CASE_ST(ut_setup, ut_teardown,
8480 test_AES_GCM_authenticated_decryption_test_case_2),
8481 TEST_CASE_ST(ut_setup, ut_teardown,
8482 test_AES_GCM_authenticated_decryption_test_case_3),
8483 TEST_CASE_ST(ut_setup, ut_teardown,
8484 test_AES_GCM_authenticated_decryption_test_case_4),
8485 TEST_CASE_ST(ut_setup, ut_teardown,
8486 test_AES_GCM_authenticated_decryption_test_case_5),
8487 TEST_CASE_ST(ut_setup, ut_teardown,
8488 test_AES_GCM_authenticated_decryption_test_case_6),
8489 TEST_CASE_ST(ut_setup, ut_teardown,
8490 test_AES_GCM_authenticated_decryption_test_case_7),
8492 /** AES GCM Authenticated Encryption 192 bits key */
8493 TEST_CASE_ST(ut_setup, ut_teardown,
8494 test_AES_GCM_auth_encryption_test_case_192_1),
8495 TEST_CASE_ST(ut_setup, ut_teardown,
8496 test_AES_GCM_auth_encryption_test_case_192_2),
8497 TEST_CASE_ST(ut_setup, ut_teardown,
8498 test_AES_GCM_auth_encryption_test_case_192_3),
8499 TEST_CASE_ST(ut_setup, ut_teardown,
8500 test_AES_GCM_auth_encryption_test_case_192_4),
8501 TEST_CASE_ST(ut_setup, ut_teardown,
8502 test_AES_GCM_auth_encryption_test_case_192_5),
8503 TEST_CASE_ST(ut_setup, ut_teardown,
8504 test_AES_GCM_auth_encryption_test_case_192_6),
8505 TEST_CASE_ST(ut_setup, ut_teardown,
8506 test_AES_GCM_auth_encryption_test_case_192_7),
8508 /** AES GCM Authenticated Decryption 192 bits key */
8509 TEST_CASE_ST(ut_setup, ut_teardown,
8510 test_AES_GCM_auth_decryption_test_case_192_1),
8511 TEST_CASE_ST(ut_setup, ut_teardown,
8512 test_AES_GCM_auth_decryption_test_case_192_2),
8513 TEST_CASE_ST(ut_setup, ut_teardown,
8514 test_AES_GCM_auth_decryption_test_case_192_3),
8515 TEST_CASE_ST(ut_setup, ut_teardown,
8516 test_AES_GCM_auth_decryption_test_case_192_4),
8517 TEST_CASE_ST(ut_setup, ut_teardown,
8518 test_AES_GCM_auth_decryption_test_case_192_5),
8519 TEST_CASE_ST(ut_setup, ut_teardown,
8520 test_AES_GCM_auth_decryption_test_case_192_6),
8521 TEST_CASE_ST(ut_setup, ut_teardown,
8522 test_AES_GCM_auth_decryption_test_case_192_7),
8524 /** AES GCM Authenticated Encryption 256 bits key */
8525 TEST_CASE_ST(ut_setup, ut_teardown,
8526 test_AES_GCM_auth_encryption_test_case_256_1),
8527 TEST_CASE_ST(ut_setup, ut_teardown,
8528 test_AES_GCM_auth_encryption_test_case_256_2),
8529 TEST_CASE_ST(ut_setup, ut_teardown,
8530 test_AES_GCM_auth_encryption_test_case_256_3),
8531 TEST_CASE_ST(ut_setup, ut_teardown,
8532 test_AES_GCM_auth_encryption_test_case_256_4),
8533 TEST_CASE_ST(ut_setup, ut_teardown,
8534 test_AES_GCM_auth_encryption_test_case_256_5),
8535 TEST_CASE_ST(ut_setup, ut_teardown,
8536 test_AES_GCM_auth_encryption_test_case_256_6),
8537 TEST_CASE_ST(ut_setup, ut_teardown,
8538 test_AES_GCM_auth_encryption_test_case_256_7),
8540 /** AES GCM Authenticated Decryption 256 bits key */
8541 TEST_CASE_ST(ut_setup, ut_teardown,
8542 test_AES_GCM_auth_decryption_test_case_256_1),
8543 TEST_CASE_ST(ut_setup, ut_teardown,
8544 test_AES_GCM_auth_decryption_test_case_256_2),
8545 TEST_CASE_ST(ut_setup, ut_teardown,
8546 test_AES_GCM_auth_decryption_test_case_256_3),
8547 TEST_CASE_ST(ut_setup, ut_teardown,
8548 test_AES_GCM_auth_decryption_test_case_256_4),
8549 TEST_CASE_ST(ut_setup, ut_teardown,
8550 test_AES_GCM_auth_decryption_test_case_256_5),
8551 TEST_CASE_ST(ut_setup, ut_teardown,
8552 test_AES_GCM_auth_decryption_test_case_256_6),
8553 TEST_CASE_ST(ut_setup, ut_teardown,
8554 test_AES_GCM_auth_decryption_test_case_256_7),
8556 /** AES GCM Authenticated Encryption big aad size */
8557 TEST_CASE_ST(ut_setup, ut_teardown,
8558 test_AES_GCM_auth_encryption_test_case_aad_1),
8559 TEST_CASE_ST(ut_setup, ut_teardown,
8560 test_AES_GCM_auth_encryption_test_case_aad_2),
8562 /** AES GCM Authenticated Decryption big aad size */
8563 TEST_CASE_ST(ut_setup, ut_teardown,
8564 test_AES_GCM_auth_decryption_test_case_aad_1),
8565 TEST_CASE_ST(ut_setup, ut_teardown,
8566 test_AES_GCM_auth_decryption_test_case_aad_2),
8568 /** AES GMAC Authentication */
8569 TEST_CASE_ST(ut_setup, ut_teardown,
8570 test_AES_GMAC_authentication_test_case_1),
8571 TEST_CASE_ST(ut_setup, ut_teardown,
8572 test_AES_GMAC_authentication_verify_test_case_1),
8573 TEST_CASE_ST(ut_setup, ut_teardown,
8574 test_AES_GMAC_authentication_test_case_3),
8575 TEST_CASE_ST(ut_setup, ut_teardown,
8576 test_AES_GMAC_authentication_verify_test_case_3),
8577 TEST_CASE_ST(ut_setup, ut_teardown,
8578 test_AES_GMAC_authentication_test_case_4),
8579 TEST_CASE_ST(ut_setup, ut_teardown,
8580 test_AES_GMAC_authentication_verify_test_case_4),
8582 /** Negative tests */
8583 TEST_CASE_ST(ut_setup, ut_teardown,
8584 authentication_verify_AES128_GMAC_fail_data_corrupt),
8585 TEST_CASE_ST(ut_setup, ut_teardown,
8586 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8588 /** Out of place tests */
8589 TEST_CASE_ST(ut_setup, ut_teardown,
8590 test_AES_GCM_authenticated_encryption_oop_test_case_1),
8591 TEST_CASE_ST(ut_setup, ut_teardown,
8592 test_AES_GCM_authenticated_decryption_oop_test_case_1),
8594 /** Session-less tests */
8595 TEST_CASE_ST(ut_setup, ut_teardown,
8596 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
8597 TEST_CASE_ST(ut_setup, ut_teardown,
8598 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
8600 /** Scatter-Gather */
8601 TEST_CASE_ST(ut_setup, ut_teardown,
8602 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8604 TEST_CASES_END() /**< NULL terminate unit test array */
8608 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
8609 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
8610 .setup = testsuite_setup,
8611 .teardown = testsuite_teardown,
8612 .unit_test_cases = {
8613 /** KASUMI encrypt only (UEA1) */
8614 TEST_CASE_ST(ut_setup, ut_teardown,
8615 test_kasumi_encryption_test_case_1),
8616 TEST_CASE_ST(ut_setup, ut_teardown,
8617 test_kasumi_encryption_test_case_1_sgl),
8618 TEST_CASE_ST(ut_setup, ut_teardown,
8619 test_kasumi_encryption_test_case_2),
8620 TEST_CASE_ST(ut_setup, ut_teardown,
8621 test_kasumi_encryption_test_case_3),
8622 TEST_CASE_ST(ut_setup, ut_teardown,
8623 test_kasumi_encryption_test_case_4),
8624 TEST_CASE_ST(ut_setup, ut_teardown,
8625 test_kasumi_encryption_test_case_5),
8626 /** KASUMI decrypt only (UEA1) */
8627 TEST_CASE_ST(ut_setup, ut_teardown,
8628 test_kasumi_decryption_test_case_1),
8629 TEST_CASE_ST(ut_setup, ut_teardown,
8630 test_kasumi_decryption_test_case_2),
8631 TEST_CASE_ST(ut_setup, ut_teardown,
8632 test_kasumi_decryption_test_case_3),
8633 TEST_CASE_ST(ut_setup, ut_teardown,
8634 test_kasumi_decryption_test_case_4),
8635 TEST_CASE_ST(ut_setup, ut_teardown,
8636 test_kasumi_decryption_test_case_5),
8638 TEST_CASE_ST(ut_setup, ut_teardown,
8639 test_kasumi_encryption_test_case_1_oop),
8640 TEST_CASE_ST(ut_setup, ut_teardown,
8641 test_kasumi_encryption_test_case_1_oop_sgl),
8644 TEST_CASE_ST(ut_setup, ut_teardown,
8645 test_kasumi_decryption_test_case_1_oop),
8647 /** KASUMI hash only (UIA1) */
8648 TEST_CASE_ST(ut_setup, ut_teardown,
8649 test_kasumi_hash_generate_test_case_1),
8650 TEST_CASE_ST(ut_setup, ut_teardown,
8651 test_kasumi_hash_generate_test_case_2),
8652 TEST_CASE_ST(ut_setup, ut_teardown,
8653 test_kasumi_hash_generate_test_case_3),
8654 TEST_CASE_ST(ut_setup, ut_teardown,
8655 test_kasumi_hash_generate_test_case_4),
8656 TEST_CASE_ST(ut_setup, ut_teardown,
8657 test_kasumi_hash_generate_test_case_5),
8658 TEST_CASE_ST(ut_setup, ut_teardown,
8659 test_kasumi_hash_generate_test_case_6),
8660 TEST_CASE_ST(ut_setup, ut_teardown,
8661 test_kasumi_hash_verify_test_case_1),
8662 TEST_CASE_ST(ut_setup, ut_teardown,
8663 test_kasumi_hash_verify_test_case_2),
8664 TEST_CASE_ST(ut_setup, ut_teardown,
8665 test_kasumi_hash_verify_test_case_3),
8666 TEST_CASE_ST(ut_setup, ut_teardown,
8667 test_kasumi_hash_verify_test_case_4),
8668 TEST_CASE_ST(ut_setup, ut_teardown,
8669 test_kasumi_hash_verify_test_case_5),
8670 TEST_CASE_ST(ut_setup, ut_teardown,
8671 test_kasumi_auth_cipher_test_case_1),
8672 TEST_CASE_ST(ut_setup, ut_teardown,
8673 test_kasumi_cipher_auth_test_case_1),
8674 TEST_CASES_END() /**< NULL terminate unit test array */
8677 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
8678 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
8679 .setup = testsuite_setup,
8680 .teardown = testsuite_teardown,
8681 .unit_test_cases = {
8682 /** SNOW 3G encrypt only (UEA2) */
8683 TEST_CASE_ST(ut_setup, ut_teardown,
8684 test_snow3g_encryption_test_case_1),
8685 TEST_CASE_ST(ut_setup, ut_teardown,
8686 test_snow3g_encryption_test_case_2),
8687 TEST_CASE_ST(ut_setup, ut_teardown,
8688 test_snow3g_encryption_test_case_3),
8689 TEST_CASE_ST(ut_setup, ut_teardown,
8690 test_snow3g_encryption_test_case_4),
8691 TEST_CASE_ST(ut_setup, ut_teardown,
8692 test_snow3g_encryption_test_case_5),
8694 TEST_CASE_ST(ut_setup, ut_teardown,
8695 test_snow3g_encryption_test_case_1_oop),
8696 TEST_CASE_ST(ut_setup, ut_teardown,
8697 test_snow3g_encryption_test_case_1_oop_sgl),
8698 TEST_CASE_ST(ut_setup, ut_teardown,
8699 test_snow3g_decryption_test_case_1_oop),
8701 TEST_CASE_ST(ut_setup, ut_teardown,
8702 test_snow3g_encryption_test_case_1_offset_oop),
8704 /** SNOW 3G decrypt only (UEA2) */
8705 TEST_CASE_ST(ut_setup, ut_teardown,
8706 test_snow3g_decryption_test_case_1),
8707 TEST_CASE_ST(ut_setup, ut_teardown,
8708 test_snow3g_decryption_test_case_2),
8709 TEST_CASE_ST(ut_setup, ut_teardown,
8710 test_snow3g_decryption_test_case_3),
8711 TEST_CASE_ST(ut_setup, ut_teardown,
8712 test_snow3g_decryption_test_case_4),
8713 TEST_CASE_ST(ut_setup, ut_teardown,
8714 test_snow3g_decryption_test_case_5),
8715 TEST_CASE_ST(ut_setup, ut_teardown,
8716 test_snow3g_hash_generate_test_case_1),
8717 TEST_CASE_ST(ut_setup, ut_teardown,
8718 test_snow3g_hash_generate_test_case_2),
8719 TEST_CASE_ST(ut_setup, ut_teardown,
8720 test_snow3g_hash_generate_test_case_3),
8721 /* Tests with buffers which length is not byte-aligned */
8722 TEST_CASE_ST(ut_setup, ut_teardown,
8723 test_snow3g_hash_generate_test_case_4),
8724 TEST_CASE_ST(ut_setup, ut_teardown,
8725 test_snow3g_hash_generate_test_case_5),
8726 TEST_CASE_ST(ut_setup, ut_teardown,
8727 test_snow3g_hash_generate_test_case_6),
8728 TEST_CASE_ST(ut_setup, ut_teardown,
8729 test_snow3g_hash_verify_test_case_1),
8730 TEST_CASE_ST(ut_setup, ut_teardown,
8731 test_snow3g_hash_verify_test_case_2),
8732 TEST_CASE_ST(ut_setup, ut_teardown,
8733 test_snow3g_hash_verify_test_case_3),
8734 /* Tests with buffers which length is not byte-aligned */
8735 TEST_CASE_ST(ut_setup, ut_teardown,
8736 test_snow3g_hash_verify_test_case_4),
8737 TEST_CASE_ST(ut_setup, ut_teardown,
8738 test_snow3g_hash_verify_test_case_5),
8739 TEST_CASE_ST(ut_setup, ut_teardown,
8740 test_snow3g_hash_verify_test_case_6),
8741 TEST_CASE_ST(ut_setup, ut_teardown,
8742 test_snow3g_cipher_auth_test_case_1),
8743 TEST_CASE_ST(ut_setup, ut_teardown,
8744 test_snow3g_auth_cipher_test_case_1),
8746 TEST_CASES_END() /**< NULL terminate unit test array */
8750 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
8751 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
8752 .setup = testsuite_setup,
8753 .teardown = testsuite_teardown,
8754 .unit_test_cases = {
8755 /** ZUC encrypt only (EEA3) */
8756 TEST_CASE_ST(ut_setup, ut_teardown,
8757 test_zuc_encryption_test_case_1),
8758 TEST_CASE_ST(ut_setup, ut_teardown,
8759 test_zuc_encryption_test_case_2),
8760 TEST_CASE_ST(ut_setup, ut_teardown,
8761 test_zuc_encryption_test_case_3),
8762 TEST_CASE_ST(ut_setup, ut_teardown,
8763 test_zuc_encryption_test_case_4),
8764 TEST_CASE_ST(ut_setup, ut_teardown,
8765 test_zuc_encryption_test_case_5),
8766 TEST_CASE_ST(ut_setup, ut_teardown,
8767 test_zuc_hash_generate_test_case_1),
8768 TEST_CASE_ST(ut_setup, ut_teardown,
8769 test_zuc_hash_generate_test_case_2),
8770 TEST_CASE_ST(ut_setup, ut_teardown,
8771 test_zuc_hash_generate_test_case_3),
8772 TEST_CASE_ST(ut_setup, ut_teardown,
8773 test_zuc_hash_generate_test_case_4),
8774 TEST_CASE_ST(ut_setup, ut_teardown,
8775 test_zuc_hash_generate_test_case_5),
8776 TEST_CASE_ST(ut_setup, ut_teardown,
8777 test_zuc_encryption_test_case_6_sgl),
8778 TEST_CASES_END() /**< NULL terminate unit test array */
8782 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
8783 .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
8784 .setup = testsuite_setup,
8785 .teardown = testsuite_teardown,
8786 .unit_test_cases = {
8787 TEST_CASE_ST(ut_setup, ut_teardown,
8788 test_device_configure_invalid_dev_id),
8789 TEST_CASE_ST(ut_setup, ut_teardown,
8790 test_multi_session),
8792 TEST_CASE_ST(ut_setup, ut_teardown,
8793 test_AES_chain_dpaa2_sec_all),
8794 TEST_CASE_ST(ut_setup, ut_teardown,
8795 test_3DES_chain_dpaa2_sec_all),
8796 TEST_CASE_ST(ut_setup, ut_teardown,
8797 test_AES_cipheronly_dpaa2_sec_all),
8798 TEST_CASE_ST(ut_setup, ut_teardown,
8799 test_3DES_cipheronly_dpaa2_sec_all),
8800 TEST_CASE_ST(ut_setup, ut_teardown,
8801 test_authonly_dpaa2_sec_all),
8803 /** AES GCM Authenticated Encryption */
8804 TEST_CASE_ST(ut_setup, ut_teardown,
8805 test_AES_GCM_authenticated_encryption_test_case_1),
8806 TEST_CASE_ST(ut_setup, ut_teardown,
8807 test_AES_GCM_authenticated_encryption_test_case_2),
8808 TEST_CASE_ST(ut_setup, ut_teardown,
8809 test_AES_GCM_authenticated_encryption_test_case_3),
8810 TEST_CASE_ST(ut_setup, ut_teardown,
8811 test_AES_GCM_authenticated_encryption_test_case_4),
8812 TEST_CASE_ST(ut_setup, ut_teardown,
8813 test_AES_GCM_authenticated_encryption_test_case_5),
8814 TEST_CASE_ST(ut_setup, ut_teardown,
8815 test_AES_GCM_authenticated_encryption_test_case_6),
8816 TEST_CASE_ST(ut_setup, ut_teardown,
8817 test_AES_GCM_authenticated_encryption_test_case_7),
8819 /** AES GCM Authenticated Decryption */
8820 TEST_CASE_ST(ut_setup, ut_teardown,
8821 test_AES_GCM_authenticated_decryption_test_case_1),
8822 TEST_CASE_ST(ut_setup, ut_teardown,
8823 test_AES_GCM_authenticated_decryption_test_case_2),
8824 TEST_CASE_ST(ut_setup, ut_teardown,
8825 test_AES_GCM_authenticated_decryption_test_case_3),
8826 TEST_CASE_ST(ut_setup, ut_teardown,
8827 test_AES_GCM_authenticated_decryption_test_case_4),
8828 TEST_CASE_ST(ut_setup, ut_teardown,
8829 test_AES_GCM_authenticated_decryption_test_case_5),
8830 TEST_CASE_ST(ut_setup, ut_teardown,
8831 test_AES_GCM_authenticated_decryption_test_case_6),
8832 TEST_CASE_ST(ut_setup, ut_teardown,
8833 test_AES_GCM_authenticated_decryption_test_case_7),
8835 /** AES GCM Authenticated Encryption 192 bits key */
8836 TEST_CASE_ST(ut_setup, ut_teardown,
8837 test_AES_GCM_auth_encryption_test_case_192_1),
8838 TEST_CASE_ST(ut_setup, ut_teardown,
8839 test_AES_GCM_auth_encryption_test_case_192_2),
8840 TEST_CASE_ST(ut_setup, ut_teardown,
8841 test_AES_GCM_auth_encryption_test_case_192_3),
8842 TEST_CASE_ST(ut_setup, ut_teardown,
8843 test_AES_GCM_auth_encryption_test_case_192_4),
8844 TEST_CASE_ST(ut_setup, ut_teardown,
8845 test_AES_GCM_auth_encryption_test_case_192_5),
8846 TEST_CASE_ST(ut_setup, ut_teardown,
8847 test_AES_GCM_auth_encryption_test_case_192_6),
8848 TEST_CASE_ST(ut_setup, ut_teardown,
8849 test_AES_GCM_auth_encryption_test_case_192_7),
8851 /** AES GCM Authenticated Decryption 192 bits key */
8852 TEST_CASE_ST(ut_setup, ut_teardown,
8853 test_AES_GCM_auth_decryption_test_case_192_1),
8854 TEST_CASE_ST(ut_setup, ut_teardown,
8855 test_AES_GCM_auth_decryption_test_case_192_2),
8856 TEST_CASE_ST(ut_setup, ut_teardown,
8857 test_AES_GCM_auth_decryption_test_case_192_3),
8858 TEST_CASE_ST(ut_setup, ut_teardown,
8859 test_AES_GCM_auth_decryption_test_case_192_4),
8860 TEST_CASE_ST(ut_setup, ut_teardown,
8861 test_AES_GCM_auth_decryption_test_case_192_5),
8862 TEST_CASE_ST(ut_setup, ut_teardown,
8863 test_AES_GCM_auth_decryption_test_case_192_6),
8864 TEST_CASE_ST(ut_setup, ut_teardown,
8865 test_AES_GCM_auth_decryption_test_case_192_7),
8867 /** AES GCM Authenticated Encryption 256 bits key */
8868 TEST_CASE_ST(ut_setup, ut_teardown,
8869 test_AES_GCM_auth_encryption_test_case_256_1),
8870 TEST_CASE_ST(ut_setup, ut_teardown,
8871 test_AES_GCM_auth_encryption_test_case_256_2),
8872 TEST_CASE_ST(ut_setup, ut_teardown,
8873 test_AES_GCM_auth_encryption_test_case_256_3),
8874 TEST_CASE_ST(ut_setup, ut_teardown,
8875 test_AES_GCM_auth_encryption_test_case_256_4),
8876 TEST_CASE_ST(ut_setup, ut_teardown,
8877 test_AES_GCM_auth_encryption_test_case_256_5),
8878 TEST_CASE_ST(ut_setup, ut_teardown,
8879 test_AES_GCM_auth_encryption_test_case_256_6),
8880 TEST_CASE_ST(ut_setup, ut_teardown,
8881 test_AES_GCM_auth_encryption_test_case_256_7),
8883 /** AES GCM Authenticated Decryption 256 bits key */
8884 TEST_CASE_ST(ut_setup, ut_teardown,
8885 test_AES_GCM_auth_decryption_test_case_256_1),
8886 TEST_CASE_ST(ut_setup, ut_teardown,
8887 test_AES_GCM_auth_decryption_test_case_256_2),
8888 TEST_CASE_ST(ut_setup, ut_teardown,
8889 test_AES_GCM_auth_decryption_test_case_256_3),
8890 TEST_CASE_ST(ut_setup, ut_teardown,
8891 test_AES_GCM_auth_decryption_test_case_256_4),
8892 TEST_CASE_ST(ut_setup, ut_teardown,
8893 test_AES_GCM_auth_decryption_test_case_256_5),
8894 TEST_CASE_ST(ut_setup, ut_teardown,
8895 test_AES_GCM_auth_decryption_test_case_256_6),
8896 TEST_CASE_ST(ut_setup, ut_teardown,
8897 test_AES_GCM_auth_decryption_test_case_256_7),
8899 TEST_CASES_END() /**< NULL terminate unit test array */
8903 static struct unit_test_suite cryptodev_null_testsuite = {
8904 .suite_name = "Crypto Device NULL Unit Test Suite",
8905 .setup = testsuite_setup,
8906 .teardown = testsuite_teardown,
8907 .unit_test_cases = {
8908 TEST_CASE_ST(ut_setup, ut_teardown,
8909 test_null_auth_only_operation),
8910 TEST_CASE_ST(ut_setup, ut_teardown,
8911 test_null_cipher_only_operation),
8912 TEST_CASE_ST(ut_setup, ut_teardown,
8913 test_null_cipher_auth_operation),
8914 TEST_CASE_ST(ut_setup, ut_teardown,
8915 test_null_auth_cipher_operation),
8916 TEST_CASE_ST(ut_setup, ut_teardown,
8917 test_null_invalid_operation),
8918 TEST_CASE_ST(ut_setup, ut_teardown,
8919 test_null_burst_operation),
8921 TEST_CASES_END() /**< NULL terminate unit test array */
8925 static struct unit_test_suite cryptodev_armv8_testsuite = {
8926 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
8927 .setup = testsuite_setup,
8928 .teardown = testsuite_teardown,
8929 .unit_test_cases = {
8930 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
8932 /** Negative tests */
8933 TEST_CASE_ST(ut_setup, ut_teardown,
8934 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8935 TEST_CASE_ST(ut_setup, ut_teardown,
8936 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8938 TEST_CASES_END() /**< NULL terminate unit test array */
8943 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
8945 gbl_driver_id = rte_cryptodev_driver_id_get(
8946 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
8948 if (gbl_driver_id == -1) {
8949 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
8950 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
8951 "in config file to run this testsuite.\n");
8955 return unit_test_suite_runner(&cryptodev_qat_testsuite);
8959 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
8961 gbl_driver_id = rte_cryptodev_driver_id_get(
8962 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
8964 if (gbl_driver_id == -1) {
8965 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
8966 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
8967 "in config file to run this testsuite.\n");
8971 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
8975 test_cryptodev_openssl(void)
8977 gbl_driver_id = rte_cryptodev_driver_id_get(
8978 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
8980 if (gbl_driver_id == -1) {
8981 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
8982 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
8983 "in config file to run this testsuite.\n");
8987 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
8991 test_cryptodev_aesni_gcm(void)
8993 gbl_driver_id = rte_cryptodev_driver_id_get(
8994 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
8996 if (gbl_driver_id == -1) {
8997 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
8998 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
8999 "in config file to run this testsuite.\n");
9003 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
9007 test_cryptodev_null(void)
9009 gbl_driver_id = rte_cryptodev_driver_id_get(
9010 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
9012 if (gbl_driver_id == -1) {
9013 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
9014 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
9015 "in config file to run this testsuite.\n");
9019 return unit_test_suite_runner(&cryptodev_null_testsuite);
9023 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
9025 gbl_driver_id = rte_cryptodev_driver_id_get(
9026 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
9028 if (gbl_driver_id == -1) {
9029 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
9030 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
9031 "in config file to run this testsuite.\n");
9035 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
9039 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
9041 gbl_driver_id = rte_cryptodev_driver_id_get(
9042 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
9044 if (gbl_driver_id == -1) {
9045 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
9046 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
9047 "in config file to run this testsuite.\n");
9051 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
9055 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
9057 gbl_driver_id = rte_cryptodev_driver_id_get(
9058 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
9060 if (gbl_driver_id == -1) {
9061 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
9062 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
9063 "in config file to run this testsuite.\n");
9067 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
9071 test_cryptodev_armv8(void)
9073 gbl_driver_id = rte_cryptodev_driver_id_get(
9074 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
9076 if (gbl_driver_id == -1) {
9077 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
9078 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
9079 "in config file to run this testsuite.\n");
9083 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
9086 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
9089 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
9091 gbl_driver_id = rte_cryptodev_driver_id_get(
9092 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
9094 if (gbl_driver_id == -1) {
9095 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
9096 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
9097 "in config file to run this testsuite.\n");
9101 if (rte_cryptodev_driver_id_get(
9102 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
9103 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
9104 " enabled in config file to run this testsuite.\n");
9107 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
9110 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
9115 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
9117 gbl_driver_id = rte_cryptodev_driver_id_get(
9118 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
9120 if (gbl_driver_id == -1) {
9121 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
9122 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
9123 "in config file to run this testsuite.\n");
9127 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
9130 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
9131 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
9132 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
9133 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
9134 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
9135 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
9136 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
9137 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
9138 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
9139 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);