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>
39 #include <rte_crypto.h>
40 #include <rte_cryptodev.h>
41 #include <rte_cryptodev_pmd.h>
43 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
44 #include <rte_cryptodev_scheduler.h>
45 #include <rte_cryptodev_scheduler_operations.h>
49 #include "test_cryptodev.h"
51 #include "test_cryptodev_blockcipher.h"
52 #include "test_cryptodev_aes_test_vectors.h"
53 #include "test_cryptodev_des_test_vectors.h"
54 #include "test_cryptodev_hash_test_vectors.h"
55 #include "test_cryptodev_kasumi_test_vectors.h"
56 #include "test_cryptodev_kasumi_hash_test_vectors.h"
57 #include "test_cryptodev_snow3g_test_vectors.h"
58 #include "test_cryptodev_snow3g_hash_test_vectors.h"
59 #include "test_cryptodev_zuc_test_vectors.h"
60 #include "test_cryptodev_gcm_test_vectors.h"
61 #include "test_cryptodev_hmac_test_vectors.h"
63 static enum rte_cryptodev_type gbl_cryptodev_type;
65 struct crypto_testsuite_params {
66 struct rte_mempool *mbuf_pool;
67 struct rte_mempool *large_mbuf_pool;
68 struct rte_mempool *op_mpool;
69 struct rte_cryptodev_config conf;
70 struct rte_cryptodev_qp_conf qp_conf;
72 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
73 uint8_t valid_dev_count;
76 struct crypto_unittest_params {
77 struct rte_crypto_sym_xform cipher_xform;
78 struct rte_crypto_sym_xform auth_xform;
80 struct rte_cryptodev_sym_session *sess;
82 struct rte_crypto_op *op;
84 struct rte_mbuf *obuf, *ibuf;
89 #define ALIGN_POW2_ROUNDUP(num, align) \
90 (((num) + (align) - 1) & ~((align) - 1))
93 * Forward declarations.
96 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
97 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
101 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
102 struct crypto_unittest_params *ut_params,
103 struct crypto_testsuite_params *ts_param,
104 const uint8_t *cipher,
105 const uint8_t *digest,
108 static struct rte_mbuf *
109 setup_test_string(struct rte_mempool *mpool,
110 const char *string, size_t len, uint8_t blocksize)
112 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
113 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
115 memset(m->buf_addr, 0, m->buf_len);
117 char *dst = rte_pktmbuf_append(m, t_len);
124 rte_memcpy(dst, string, t_len);
126 memset(dst, 0, t_len);
132 /* Get number of bytes in X bits (rounding up) */
134 ceil_byte_length(uint32_t num_bits)
137 return ((num_bits >> 3) + 1);
139 return (num_bits >> 3);
142 static struct rte_crypto_op *
143 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
145 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
146 printf("Error sending packet for encryption");
152 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
158 static struct crypto_testsuite_params testsuite_params = { NULL };
159 static struct crypto_unittest_params unittest_params;
162 testsuite_setup(void)
164 struct crypto_testsuite_params *ts_params = &testsuite_params;
165 struct rte_cryptodev_info info;
166 uint32_t i = 0, nb_devs, dev_id;
170 memset(ts_params, 0, sizeof(*ts_params));
172 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
173 if (ts_params->mbuf_pool == NULL) {
174 /* Not already created so create */
175 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
177 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
179 if (ts_params->mbuf_pool == NULL) {
180 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
185 ts_params->large_mbuf_pool = rte_mempool_lookup(
186 "CRYPTO_LARGE_MBUFPOOL");
187 if (ts_params->large_mbuf_pool == NULL) {
188 /* Not already created so create */
189 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
190 "CRYPTO_LARGE_MBUFPOOL",
193 if (ts_params->large_mbuf_pool == NULL) {
195 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
200 ts_params->op_mpool = rte_crypto_op_pool_create(
201 "MBUF_CRYPTO_SYM_OP_POOL",
202 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
203 NUM_MBUFS, MBUF_CACHE_SIZE,
205 sizeof(struct rte_crypto_sym_xform),
207 if (ts_params->op_mpool == NULL) {
208 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
212 /* Create an AESNI MB device if required */
213 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
214 #ifndef RTE_LIBRTE_PMD_AESNI_MB
215 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
216 " enabled in config file to run this testsuite.\n");
219 nb_devs = rte_cryptodev_count_devtype(
220 RTE_CRYPTODEV_AESNI_MB_PMD);
223 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
225 TEST_ASSERT(ret == 0,
226 "Failed to create instance of"
228 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
232 /* Create an AESNI GCM device if required */
233 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
234 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
235 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
236 " enabled in config file to run this testsuite.\n");
239 nb_devs = rte_cryptodev_count_devtype(
240 RTE_CRYPTODEV_AESNI_GCM_PMD);
242 TEST_ASSERT_SUCCESS(rte_vdev_init(
243 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
244 "Failed to create instance of"
246 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
250 /* Create a SNOW 3G device if required */
251 if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
252 #ifndef RTE_LIBRTE_PMD_SNOW3G
253 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
254 " enabled in config file to run this testsuite.\n");
257 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
259 TEST_ASSERT_SUCCESS(rte_vdev_init(
260 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
261 "Failed to create instance of"
263 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
267 /* Create a KASUMI device if required */
268 if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
269 #ifndef RTE_LIBRTE_PMD_KASUMI
270 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
271 " enabled in config file to run this testsuite.\n");
274 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
276 TEST_ASSERT_SUCCESS(rte_vdev_init(
277 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
278 "Failed to create instance of"
280 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
284 /* Create a ZUC device if required */
285 if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
286 #ifndef RTE_LIBRTE_PMD_ZUC
287 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
288 " enabled in config file to run this testsuite.\n");
291 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
293 TEST_ASSERT_SUCCESS(rte_vdev_init(
294 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
295 "Failed to create instance of"
297 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
301 /* Create a NULL device if required */
302 if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
303 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
304 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
305 " enabled in config file to run this testsuite.\n");
308 nb_devs = rte_cryptodev_count_devtype(
309 RTE_CRYPTODEV_NULL_PMD);
312 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
314 TEST_ASSERT(ret == 0,
315 "Failed to create instance of"
317 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
321 /* Create an OPENSSL device if required */
322 if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
323 #ifndef RTE_LIBRTE_PMD_OPENSSL
324 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
325 " enabled in config file to run this testsuite.\n");
328 nb_devs = rte_cryptodev_count_devtype(
329 RTE_CRYPTODEV_OPENSSL_PMD);
332 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
335 TEST_ASSERT(ret == 0, "Failed to create "
336 "instance of pmd : %s",
337 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
341 /* Create a ARMv8 device if required */
342 if (gbl_cryptodev_type == RTE_CRYPTODEV_ARMV8_PMD) {
343 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
344 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
345 " enabled in config file to run this testsuite.\n");
348 nb_devs = rte_cryptodev_count_devtype(
349 RTE_CRYPTODEV_ARMV8_PMD);
352 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
355 TEST_ASSERT(ret == 0, "Failed to create "
356 "instance of pmd : %s",
357 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
361 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
362 if (gbl_cryptodev_type == RTE_CRYPTODEV_SCHEDULER_PMD) {
364 #ifndef RTE_LIBRTE_PMD_AESNI_MB
365 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
366 " enabled in config file to run this testsuite.\n");
369 nb_devs = rte_cryptodev_count_devtype(
370 RTE_CRYPTODEV_SCHEDULER_PMD);
373 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
376 TEST_ASSERT(ret == 0,
377 "Failed to create instance %u of"
379 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
382 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
384 #ifndef RTE_LIBRTE_PMD_QAT
385 if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
386 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
387 "in config file to run this testsuite.\n");
392 nb_devs = rte_cryptodev_count();
394 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
398 /* Create list of valid crypto devs */
399 for (i = 0; i < nb_devs; i++) {
400 rte_cryptodev_info_get(i, &info);
401 if (info.dev_type == gbl_cryptodev_type)
402 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
405 if (ts_params->valid_dev_count < 1)
408 /* Set up all the qps on the first of the valid devices found */
410 dev_id = ts_params->valid_devs[0];
412 rte_cryptodev_info_get(dev_id, &info);
414 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
415 ts_params->conf.socket_id = SOCKET_ID_ANY;
416 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
418 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
420 "Failed to configure cryptodev %u with %u qps",
421 dev_id, ts_params->conf.nb_queue_pairs);
423 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
425 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
426 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
427 dev_id, qp_id, &ts_params->qp_conf,
428 rte_cryptodev_socket_id(dev_id)),
429 "Failed to setup queue pair %u on cryptodev %u",
437 testsuite_teardown(void)
439 struct crypto_testsuite_params *ts_params = &testsuite_params;
441 if (ts_params->mbuf_pool != NULL) {
442 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
443 rte_mempool_avail_count(ts_params->mbuf_pool));
446 if (ts_params->op_mpool != NULL) {
447 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
448 rte_mempool_avail_count(ts_params->op_mpool));
456 struct crypto_testsuite_params *ts_params = &testsuite_params;
457 struct crypto_unittest_params *ut_params = &unittest_params;
461 /* Clear unit test parameters before running test */
462 memset(ut_params, 0, sizeof(*ut_params));
464 /* Reconfigure device to default parameters */
465 ts_params->conf.socket_id = SOCKET_ID_ANY;
466 ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
468 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
470 "Failed to configure cryptodev %u",
471 ts_params->valid_devs[0]);
473 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
474 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
475 ts_params->valid_devs[0], qp_id,
477 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
478 "Failed to setup queue pair %u on cryptodev %u",
479 qp_id, ts_params->valid_devs[0]);
483 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
485 /* Start the device */
486 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
487 "Failed to start cryptodev %u",
488 ts_params->valid_devs[0]);
496 struct crypto_testsuite_params *ts_params = &testsuite_params;
497 struct crypto_unittest_params *ut_params = &unittest_params;
498 struct rte_cryptodev_stats stats;
500 /* free crypto session structure */
501 if (ut_params->sess) {
502 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
504 ut_params->sess = NULL;
507 /* free crypto operation structure */
509 rte_crypto_op_free(ut_params->op);
512 * free mbuf - both obuf and ibuf are usually the same,
513 * so check if they point at the same address is necessary,
514 * to avoid freeing the mbuf twice.
516 if (ut_params->obuf) {
517 rte_pktmbuf_free(ut_params->obuf);
518 if (ut_params->ibuf == ut_params->obuf)
522 if (ut_params->ibuf) {
523 rte_pktmbuf_free(ut_params->ibuf);
527 if (ts_params->mbuf_pool != NULL)
528 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
529 rte_mempool_avail_count(ts_params->mbuf_pool));
531 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
533 /* Stop the device */
534 rte_cryptodev_stop(ts_params->valid_devs[0]);
538 test_device_configure_invalid_dev_id(void)
540 struct crypto_testsuite_params *ts_params = &testsuite_params;
541 uint16_t dev_id, num_devs = 0;
543 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
544 "Need at least %d devices for test", 1);
546 /* valid dev_id values */
547 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
549 /* Stop the device in case it's started so it can be configured */
550 rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
552 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
553 "Failed test for rte_cryptodev_configure: "
554 "invalid dev_num %u", dev_id);
556 /* invalid dev_id values */
559 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
560 "Failed test for rte_cryptodev_configure: "
561 "invalid dev_num %u", dev_id);
565 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
566 "Failed test for rte_cryptodev_configure:"
567 "invalid dev_num %u", dev_id);
573 test_device_configure_invalid_queue_pair_ids(void)
575 struct crypto_testsuite_params *ts_params = &testsuite_params;
576 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
578 /* Stop the device in case it's started so it can be configured */
579 rte_cryptodev_stop(ts_params->valid_devs[0]);
581 /* valid - one queue pairs */
582 ts_params->conf.nb_queue_pairs = 1;
584 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
586 "Failed to configure cryptodev: dev_id %u, qp_id %u",
587 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
590 /* valid - max value queue pairs */
591 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
593 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
595 "Failed to configure cryptodev: dev_id %u, qp_id %u",
596 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
599 /* invalid - zero queue pairs */
600 ts_params->conf.nb_queue_pairs = 0;
602 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
604 "Failed test for rte_cryptodev_configure, dev_id %u,"
606 ts_params->valid_devs[0],
607 ts_params->conf.nb_queue_pairs);
610 /* invalid - max value supported by field queue pairs */
611 ts_params->conf.nb_queue_pairs = UINT16_MAX;
613 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
615 "Failed test for rte_cryptodev_configure, dev_id %u,"
617 ts_params->valid_devs[0],
618 ts_params->conf.nb_queue_pairs);
621 /* invalid - max value + 1 queue pairs */
622 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
624 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
626 "Failed test for rte_cryptodev_configure, dev_id %u,"
628 ts_params->valid_devs[0],
629 ts_params->conf.nb_queue_pairs);
631 /* revert to original testsuite value */
632 ts_params->conf.nb_queue_pairs = orig_nb_qps;
638 test_queue_pair_descriptor_setup(void)
640 struct crypto_testsuite_params *ts_params = &testsuite_params;
641 struct rte_cryptodev_info dev_info;
642 struct rte_cryptodev_qp_conf qp_conf = {
643 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
648 /* Stop the device in case it's started so it can be configured */
649 rte_cryptodev_stop(ts_params->valid_devs[0]);
652 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
654 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
656 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
657 &ts_params->conf), "Failed to configure cryptodev %u",
658 ts_params->valid_devs[0]);
662 * Test various ring sizes on this device. memzones can't be
663 * freed so are re-used if ring is released and re-created.
665 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
667 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
668 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
669 ts_params->valid_devs[0], qp_id, &qp_conf,
670 rte_cryptodev_socket_id(
671 ts_params->valid_devs[0])),
673 "rte_cryptodev_queue_pair_setup: num_inflights "
674 "%u on qp %u on cryptodev %u",
675 qp_conf.nb_descriptors, qp_id,
676 ts_params->valid_devs[0]);
679 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
681 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
682 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
683 ts_params->valid_devs[0], qp_id, &qp_conf,
684 rte_cryptodev_socket_id(
685 ts_params->valid_devs[0])),
687 " rte_cryptodev_queue_pair_setup: num_inflights"
688 " %u on qp %u on cryptodev %u",
689 qp_conf.nb_descriptors, qp_id,
690 ts_params->valid_devs[0]);
693 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
695 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
696 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
697 ts_params->valid_devs[0], qp_id, &qp_conf,
698 rte_cryptodev_socket_id(
699 ts_params->valid_devs[0])),
701 "rte_cryptodev_queue_pair_setup: num_inflights"
702 " %u on qp %u on cryptodev %u",
703 qp_conf.nb_descriptors, qp_id,
704 ts_params->valid_devs[0]);
707 /* invalid number of descriptors - max supported + 2 */
708 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
710 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
711 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
712 ts_params->valid_devs[0], qp_id, &qp_conf,
713 rte_cryptodev_socket_id(
714 ts_params->valid_devs[0])),
715 "Unexpectedly passed test for "
716 "rte_cryptodev_queue_pair_setup:"
717 "num_inflights %u on qp %u on cryptodev %u",
718 qp_conf.nb_descriptors, qp_id,
719 ts_params->valid_devs[0]);
722 /* invalid number of descriptors - max value of parameter */
723 qp_conf.nb_descriptors = UINT32_MAX-1;
725 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
726 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
727 ts_params->valid_devs[0], qp_id, &qp_conf,
728 rte_cryptodev_socket_id(
729 ts_params->valid_devs[0])),
730 "Unexpectedly passed test for "
731 "rte_cryptodev_queue_pair_setup:"
732 "num_inflights %u on qp %u on cryptodev %u",
733 qp_conf.nb_descriptors, qp_id,
734 ts_params->valid_devs[0]);
737 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
739 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
740 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
741 ts_params->valid_devs[0], qp_id, &qp_conf,
742 rte_cryptodev_socket_id(
743 ts_params->valid_devs[0])),
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 "Unexpectedly passed test for "
760 "rte_cryptodev_queue_pair_setup:"
761 "num_inflights %u on qp %u on cryptodev %u",
762 qp_conf.nb_descriptors, qp_id,
763 ts_params->valid_devs[0]);
766 /* test invalid queue pair id */
767 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
769 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */
771 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
772 ts_params->valid_devs[0],
774 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
775 "Failed test for rte_cryptodev_queue_pair_setup:"
776 "invalid qp %u on cryptodev %u",
777 qp_id, ts_params->valid_devs[0]);
779 qp_id = 0xffff; /*invalid*/
781 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
782 ts_params->valid_devs[0],
784 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
785 "Failed test for rte_cryptodev_queue_pair_setup:"
786 "invalid qp %u on cryptodev %u",
787 qp_id, ts_params->valid_devs[0]);
792 /* ***** Plaintext data for tests ***** */
794 const char catch_22_quote_1[] =
795 "There was only one catch and that was Catch-22, which "
796 "specified that a concern for one's safety in the face of "
797 "dangers that were real and immediate was the process of a "
798 "rational mind. Orr was crazy and could be grounded. All he "
799 "had to do was ask; and as soon as he did, he would no longer "
800 "be crazy and would have to fly more missions. Orr would be "
801 "crazy to fly more missions and sane if he didn't, but if he "
802 "was sane he had to fly them. If he flew them he was crazy "
803 "and didn't have to; but if he didn't want to he was sane and "
804 "had to. Yossarian was moved very deeply by the absolute "
805 "simplicity of this clause of Catch-22 and let out a "
806 "respectful whistle. \"That's some catch, that Catch-22\", he "
807 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
809 const char catch_22_quote[] =
810 "What a lousy earth! He wondered how many people were "
811 "destitute that same night even in his own prosperous country, "
812 "how many homes were shanties, how many husbands were drunk "
813 "and wives socked, and how many children were bullied, abused, "
814 "or abandoned. How many families hungered for food they could "
815 "not afford to buy? How many hearts were broken? How many "
816 "suicides would take place that same night, how many people "
817 "would go insane? How many cockroaches and landlords would "
818 "triumph? How many winners were losers, successes failures, "
819 "and rich men poor men? How many wise guys were stupid? How "
820 "many happy endings were unhappy endings? How many honest men "
821 "were liars, brave men cowards, loyal men traitors, how many "
822 "sainted men were corrupt, how many people in positions of "
823 "trust had sold their souls to bodyguards, how many had never "
824 "had souls? How many straight-and-narrow paths were crooked "
825 "paths? How many best families were worst families and how "
826 "many good people were bad people? When you added them all up "
827 "and then subtracted, you might be left with only the children, "
828 "and perhaps with Albert Einstein and an old violinist or "
829 "sculptor somewhere.";
831 #define QUOTE_480_BYTES (480)
832 #define QUOTE_512_BYTES (512)
833 #define QUOTE_768_BYTES (768)
834 #define QUOTE_1024_BYTES (1024)
838 /* ***** SHA1 Hash Tests ***** */
840 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
842 static uint8_t hmac_sha1_key[] = {
843 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
844 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
845 0xDE, 0xF4, 0xDE, 0xAD };
847 /* ***** SHA224 Hash Tests ***** */
849 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
852 /* ***** AES-CBC Cipher Tests ***** */
854 #define CIPHER_KEY_LENGTH_AES_CBC (16)
855 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
857 static uint8_t aes_cbc_key[] = {
858 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
859 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
861 static uint8_t aes_cbc_iv[] = {
862 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
863 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
866 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
868 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
869 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
870 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
871 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
872 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
873 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
874 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
875 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
876 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
877 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
878 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
879 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
880 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
881 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
882 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
883 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
884 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
885 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
886 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
887 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
888 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
889 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
890 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
891 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
892 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
893 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
894 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
895 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
896 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
897 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
898 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
899 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
900 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
901 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
902 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
903 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
904 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
905 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
906 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
907 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
908 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
909 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
910 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
911 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
912 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
913 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
914 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
915 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
916 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
917 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
918 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
919 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
920 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
921 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
922 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
923 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
924 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
925 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
926 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
927 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
928 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
929 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
930 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
931 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
932 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
935 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
936 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
937 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
938 0x18, 0x8c, 0x1d, 0x32
942 /* Multisession Vector context Test */
944 static uint8_t ms_aes_cbc_key0[] = {
945 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
946 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
949 static uint8_t ms_aes_cbc_iv0[] = {
950 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
951 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
954 static const uint8_t ms_aes_cbc_cipher0[] = {
955 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
956 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
957 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
958 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
959 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
960 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
961 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
962 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
963 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
964 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
965 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
966 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
967 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
968 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
969 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
970 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
971 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
972 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
973 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
974 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
975 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
976 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
977 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
978 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
979 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
980 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
981 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
982 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
983 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
984 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
985 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
986 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
987 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
988 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
989 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
990 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
991 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
992 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
993 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
994 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
995 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
996 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
997 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
998 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
999 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1000 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1001 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1002 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1003 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1004 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1005 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1006 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1007 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1008 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1009 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1010 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1011 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1012 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1013 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1014 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1015 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1016 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1017 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1018 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1022 static uint8_t ms_hmac_key0[] = {
1023 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1024 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1025 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1026 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1027 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1028 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1029 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1030 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1033 static const uint8_t ms_hmac_digest0[] = {
1034 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1035 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1036 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1037 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1038 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1039 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1040 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1041 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1045 /* Begin session 1 */
1047 static uint8_t ms_aes_cbc_key1[] = {
1048 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1049 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1052 static uint8_t ms_aes_cbc_iv1[] = {
1053 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1054 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1057 static const uint8_t ms_aes_cbc_cipher1[] = {
1058 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1059 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1060 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1061 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1062 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1063 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1064 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1065 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1066 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1067 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1068 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1069 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1070 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1071 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1072 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1073 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1074 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1075 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1076 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1077 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1078 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1079 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1080 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1081 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1082 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1083 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1084 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1085 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1086 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1087 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1088 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1089 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1090 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1091 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1092 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1093 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1094 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1095 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1096 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1097 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1098 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1099 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1100 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1101 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1102 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1103 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1104 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1105 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1106 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1107 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1108 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1109 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1110 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1111 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1112 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1113 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1114 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1115 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1116 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1117 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1118 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1119 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1120 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1121 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1125 static uint8_t ms_hmac_key1[] = {
1126 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1127 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1128 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1129 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1130 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1131 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1132 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1133 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1136 static const uint8_t ms_hmac_digest1[] = {
1137 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1138 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1139 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1140 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1141 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1142 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1143 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1144 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1147 /* Begin Session 2 */
1148 static uint8_t ms_aes_cbc_key2[] = {
1149 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1150 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1153 static uint8_t ms_aes_cbc_iv2[] = {
1154 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1155 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1158 static const uint8_t ms_aes_cbc_cipher2[] = {
1159 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1160 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1161 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1162 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1163 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1164 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1165 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1166 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1167 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1168 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1169 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1170 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1171 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1172 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1173 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1174 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1175 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1176 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1177 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1178 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1179 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1180 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1181 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1182 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1183 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1184 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1185 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1186 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1187 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1188 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1189 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1190 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1191 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1192 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1193 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1194 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1195 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1196 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1197 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1198 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1199 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1200 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1201 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1202 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1203 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1204 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1205 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1206 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1207 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1208 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1209 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1210 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1211 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1212 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1213 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1214 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1215 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1216 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1217 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1218 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1219 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1220 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1221 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1222 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1225 static uint8_t ms_hmac_key2[] = {
1226 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1227 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1228 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1229 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1230 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1231 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1232 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1233 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1236 static const uint8_t ms_hmac_digest2[] = {
1237 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1238 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1239 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1240 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1241 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1242 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1243 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1244 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1251 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1253 struct crypto_testsuite_params *ts_params = &testsuite_params;
1254 struct crypto_unittest_params *ut_params = &unittest_params;
1256 /* Generate test mbuf data and space for digest */
1257 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1258 catch_22_quote, QUOTE_512_BYTES, 0);
1260 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1261 DIGEST_BYTE_LENGTH_SHA1);
1262 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1264 /* Setup Cipher Parameters */
1265 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1266 ut_params->cipher_xform.next = &ut_params->auth_xform;
1268 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1269 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1270 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1271 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1273 /* Setup HMAC Parameters */
1274 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1276 ut_params->auth_xform.next = NULL;
1278 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1279 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1280 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1281 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1282 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1284 /* Create crypto session*/
1285 ut_params->sess = rte_cryptodev_sym_session_create(
1286 ts_params->valid_devs[0],
1287 &ut_params->cipher_xform);
1288 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1290 /* Generate crypto op data structure */
1291 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1292 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1293 TEST_ASSERT_NOT_NULL(ut_params->op,
1294 "Failed to allocate symmetric crypto operation struct");
1296 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1298 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1300 /* set crypto operation source mbuf */
1301 sym_op->m_src = ut_params->ibuf;
1303 /* Set crypto operation authentication parameters */
1304 sym_op->auth.digest.data = ut_params->digest;
1305 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1306 ut_params->ibuf, QUOTE_512_BYTES);
1307 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1309 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1310 sym_op->auth.data.length = QUOTE_512_BYTES;
1312 /* Set crypto operation cipher parameters */
1313 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1314 CIPHER_IV_LENGTH_AES_CBC);
1315 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1316 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1318 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1319 CIPHER_IV_LENGTH_AES_CBC);
1321 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1322 sym_op->cipher.data.length = QUOTE_512_BYTES;
1324 /* Process crypto operation */
1325 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1326 ut_params->op), "failed to process sym crypto op");
1328 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1329 "crypto op processing failed");
1332 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1333 uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1335 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1336 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1338 "ciphertext data not as expected");
1340 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1342 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1343 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1344 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1345 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1346 DIGEST_BYTE_LENGTH_SHA1,
1347 "Generated digest data not as expected");
1349 return TEST_SUCCESS;
1352 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1354 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1356 static uint8_t hmac_sha512_key[] = {
1357 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1358 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1359 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1360 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1361 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1362 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1363 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1364 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1366 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1367 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1368 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1369 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1370 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1371 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1372 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1373 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1374 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1379 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1380 struct crypto_unittest_params *ut_params,
1381 uint8_t *cipher_key,
1385 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1386 struct crypto_unittest_params *ut_params,
1387 struct crypto_testsuite_params *ts_params,
1388 const uint8_t *cipher,
1389 const uint8_t *digest,
1394 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1395 struct crypto_unittest_params *ut_params,
1396 uint8_t *cipher_key,
1400 /* Setup Cipher Parameters */
1401 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1402 ut_params->cipher_xform.next = NULL;
1404 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1405 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1406 ut_params->cipher_xform.cipher.key.data = cipher_key;
1407 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1409 /* Setup HMAC Parameters */
1410 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1411 ut_params->auth_xform.next = &ut_params->cipher_xform;
1413 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1414 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1415 ut_params->auth_xform.auth.key.data = hmac_key;
1416 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1417 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1419 return TEST_SUCCESS;
1424 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1425 struct crypto_unittest_params *ut_params,
1426 struct crypto_testsuite_params *ts_params,
1427 const uint8_t *cipher,
1428 const uint8_t *digest,
1431 /* Generate test mbuf data and digest */
1432 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1435 QUOTE_512_BYTES, 0);
1437 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1438 DIGEST_BYTE_LENGTH_SHA512);
1439 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1441 rte_memcpy(ut_params->digest,
1443 DIGEST_BYTE_LENGTH_SHA512);
1445 /* Generate Crypto op data structure */
1446 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1447 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1448 TEST_ASSERT_NOT_NULL(ut_params->op,
1449 "Failed to allocate symmetric crypto operation struct");
1451 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1453 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1455 /* set crypto operation source mbuf */
1456 sym_op->m_src = ut_params->ibuf;
1458 sym_op->auth.digest.data = ut_params->digest;
1459 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1460 ut_params->ibuf, QUOTE_512_BYTES);
1461 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1463 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1464 sym_op->auth.data.length = QUOTE_512_BYTES;
1466 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1467 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1468 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1469 ut_params->ibuf, 0);
1470 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1472 rte_memcpy(sym_op->cipher.iv.data, iv,
1473 CIPHER_IV_LENGTH_AES_CBC);
1475 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
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 *) +
1490 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
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, ts_params->valid_devs[0],
1509 RTE_CRYPTODEV_AESNI_MB_PMD,
1510 BLKCIPHER_AES_CIPHERONLY_TYPE);
1512 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1514 return TEST_SUCCESS;
1518 test_AES_docsis_mb_all(void)
1520 struct crypto_testsuite_params *ts_params = &testsuite_params;
1523 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1524 ts_params->op_mpool, ts_params->valid_devs[0],
1525 RTE_CRYPTODEV_AESNI_MB_PMD,
1526 BLKCIPHER_AES_DOCSIS_TYPE);
1528 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1530 return TEST_SUCCESS;
1534 test_AES_docsis_qat_all(void)
1536 struct crypto_testsuite_params *ts_params = &testsuite_params;
1539 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1540 ts_params->op_mpool, ts_params->valid_devs[0],
1541 RTE_CRYPTODEV_QAT_SYM_PMD,
1542 BLKCIPHER_AES_DOCSIS_TYPE);
1544 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1546 return TEST_SUCCESS;
1550 test_DES_docsis_qat_all(void)
1552 struct crypto_testsuite_params *ts_params = &testsuite_params;
1555 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1556 ts_params->op_mpool, ts_params->valid_devs[0],
1557 RTE_CRYPTODEV_QAT_SYM_PMD,
1558 BLKCIPHER_DES_DOCSIS_TYPE);
1560 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1562 return TEST_SUCCESS;
1566 test_authonly_mb_all(void)
1568 struct crypto_testsuite_params *ts_params = &testsuite_params;
1571 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1572 ts_params->op_mpool, ts_params->valid_devs[0],
1573 RTE_CRYPTODEV_AESNI_MB_PMD,
1574 BLKCIPHER_AUTHONLY_TYPE);
1576 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1578 return TEST_SUCCESS;
1582 test_AES_chain_mb_all(void)
1584 struct crypto_testsuite_params *ts_params = &testsuite_params;
1587 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1588 ts_params->op_mpool, ts_params->valid_devs[0],
1589 RTE_CRYPTODEV_AESNI_MB_PMD,
1590 BLKCIPHER_AES_CHAIN_TYPE);
1592 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1594 return TEST_SUCCESS;
1597 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1600 test_AES_cipheronly_scheduler_all(void)
1602 struct crypto_testsuite_params *ts_params = &testsuite_params;
1605 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1606 ts_params->op_mpool, ts_params->valid_devs[0],
1607 RTE_CRYPTODEV_SCHEDULER_PMD,
1608 BLKCIPHER_AES_CIPHERONLY_TYPE);
1610 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1612 return TEST_SUCCESS;
1616 test_AES_chain_scheduler_all(void)
1618 struct crypto_testsuite_params *ts_params = &testsuite_params;
1621 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1622 ts_params->op_mpool, ts_params->valid_devs[0],
1623 RTE_CRYPTODEV_SCHEDULER_PMD,
1624 BLKCIPHER_AES_CHAIN_TYPE);
1626 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1628 return TEST_SUCCESS;
1632 test_authonly_scheduler_all(void)
1634 struct crypto_testsuite_params *ts_params = &testsuite_params;
1637 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1638 ts_params->op_mpool, ts_params->valid_devs[0],
1639 RTE_CRYPTODEV_SCHEDULER_PMD,
1640 BLKCIPHER_AUTHONLY_TYPE);
1642 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1644 return TEST_SUCCESS;
1647 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1650 test_AES_chain_openssl_all(void)
1652 struct crypto_testsuite_params *ts_params = &testsuite_params;
1655 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1656 ts_params->op_mpool, ts_params->valid_devs[0],
1657 RTE_CRYPTODEV_OPENSSL_PMD,
1658 BLKCIPHER_AES_CHAIN_TYPE);
1660 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1662 return TEST_SUCCESS;
1666 test_AES_cipheronly_openssl_all(void)
1668 struct crypto_testsuite_params *ts_params = &testsuite_params;
1671 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1672 ts_params->op_mpool, ts_params->valid_devs[0],
1673 RTE_CRYPTODEV_OPENSSL_PMD,
1674 BLKCIPHER_AES_CIPHERONLY_TYPE);
1676 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1678 return TEST_SUCCESS;
1682 test_AES_chain_qat_all(void)
1684 struct crypto_testsuite_params *ts_params = &testsuite_params;
1687 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1688 ts_params->op_mpool, ts_params->valid_devs[0],
1689 RTE_CRYPTODEV_QAT_SYM_PMD,
1690 BLKCIPHER_AES_CHAIN_TYPE);
1692 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1694 return TEST_SUCCESS;
1698 test_AES_cipheronly_qat_all(void)
1700 struct crypto_testsuite_params *ts_params = &testsuite_params;
1703 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1704 ts_params->op_mpool, ts_params->valid_devs[0],
1705 RTE_CRYPTODEV_QAT_SYM_PMD,
1706 BLKCIPHER_AES_CIPHERONLY_TYPE);
1708 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1710 return TEST_SUCCESS;
1714 test_AES_chain_dpaa2_sec_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, ts_params->valid_devs[0],
1721 RTE_CRYPTODEV_DPAA2_SEC_PMD,
1722 BLKCIPHER_AES_CHAIN_TYPE);
1724 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1726 return TEST_SUCCESS;
1730 test_AES_cipheronly_dpaa2_sec_all(void)
1732 struct crypto_testsuite_params *ts_params = &testsuite_params;
1735 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1736 ts_params->op_mpool, ts_params->valid_devs[0],
1737 RTE_CRYPTODEV_DPAA2_SEC_PMD,
1738 BLKCIPHER_AES_CIPHERONLY_TYPE);
1740 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1742 return TEST_SUCCESS;
1746 test_authonly_openssl_all(void)
1748 struct crypto_testsuite_params *ts_params = &testsuite_params;
1751 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1752 ts_params->op_mpool, ts_params->valid_devs[0],
1753 RTE_CRYPTODEV_OPENSSL_PMD,
1754 BLKCIPHER_AUTHONLY_TYPE);
1756 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1758 return TEST_SUCCESS;
1762 test_AES_chain_armv8_all(void)
1764 struct crypto_testsuite_params *ts_params = &testsuite_params;
1767 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1768 ts_params->op_mpool, ts_params->valid_devs[0],
1769 RTE_CRYPTODEV_ARMV8_PMD,
1770 BLKCIPHER_AES_CHAIN_TYPE);
1772 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1774 return TEST_SUCCESS;
1777 /* ***** SNOW 3G Tests ***** */
1779 create_wireless_algo_hash_session(uint8_t dev_id,
1780 const uint8_t *key, const uint8_t key_len,
1781 const uint8_t aad_len, const uint8_t auth_len,
1782 enum rte_crypto_auth_operation op,
1783 enum rte_crypto_auth_algorithm algo)
1785 uint8_t hash_key[key_len];
1787 struct crypto_unittest_params *ut_params = &unittest_params;
1789 memcpy(hash_key, key, key_len);
1791 TEST_HEXDUMP(stdout, "key:", key, key_len);
1793 /* Setup Authentication Parameters */
1794 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1795 ut_params->auth_xform.next = NULL;
1797 ut_params->auth_xform.auth.op = op;
1798 ut_params->auth_xform.auth.algo = algo;
1799 ut_params->auth_xform.auth.key.length = key_len;
1800 ut_params->auth_xform.auth.key.data = hash_key;
1801 ut_params->auth_xform.auth.digest_length = auth_len;
1802 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1803 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1804 &ut_params->auth_xform);
1805 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1810 create_wireless_algo_cipher_session(uint8_t dev_id,
1811 enum rte_crypto_cipher_operation op,
1812 enum rte_crypto_cipher_algorithm algo,
1813 const uint8_t *key, const uint8_t key_len)
1815 uint8_t cipher_key[key_len];
1817 struct crypto_unittest_params *ut_params = &unittest_params;
1819 memcpy(cipher_key, key, key_len);
1821 /* Setup Cipher Parameters */
1822 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1823 ut_params->cipher_xform.next = NULL;
1825 ut_params->cipher_xform.cipher.algo = algo;
1826 ut_params->cipher_xform.cipher.op = op;
1827 ut_params->cipher_xform.cipher.key.data = cipher_key;
1828 ut_params->cipher_xform.cipher.key.length = key_len;
1830 TEST_HEXDUMP(stdout, "key:", key, key_len);
1832 /* Create Crypto session */
1833 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1836 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1841 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1842 const unsigned cipher_len,
1843 const unsigned cipher_offset,
1844 enum rte_crypto_cipher_algorithm algo)
1846 struct crypto_testsuite_params *ts_params = &testsuite_params;
1847 struct crypto_unittest_params *ut_params = &unittest_params;
1848 unsigned iv_pad_len = 0;
1850 /* Generate Crypto op data structure */
1851 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1852 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1853 TEST_ASSERT_NOT_NULL(ut_params->op,
1854 "Failed to allocate pktmbuf offload");
1856 /* Set crypto operation data parameters */
1857 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1859 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1861 /* set crypto operation source mbuf */
1862 sym_op->m_src = ut_params->ibuf;
1865 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1866 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1868 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1870 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1873 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1875 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1876 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1877 sym_op->cipher.iv.length = iv_pad_len;
1879 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1880 sym_op->cipher.data.length = cipher_len;
1881 sym_op->cipher.data.offset = cipher_offset;
1886 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1887 const unsigned cipher_len,
1888 const unsigned cipher_offset,
1889 enum rte_crypto_cipher_algorithm algo)
1891 struct crypto_testsuite_params *ts_params = &testsuite_params;
1892 struct crypto_unittest_params *ut_params = &unittest_params;
1893 unsigned iv_pad_len = 0;
1895 /* Generate Crypto op data structure */
1896 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1897 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1898 TEST_ASSERT_NOT_NULL(ut_params->op,
1899 "Failed to allocate pktmbuf offload");
1901 /* Set crypto operation data parameters */
1902 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1904 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1906 /* set crypto operation source mbuf */
1907 sym_op->m_src = ut_params->ibuf;
1908 sym_op->m_dst = ut_params->obuf;
1911 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1912 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1914 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1915 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1918 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1920 /* For OOP operation both buffers must have the same size */
1921 if (ut_params->obuf)
1922 rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len);
1924 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1925 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1926 sym_op->cipher.iv.length = iv_pad_len;
1928 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1929 sym_op->cipher.data.length = cipher_len;
1930 sym_op->cipher.data.offset = cipher_offset;
1935 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1936 enum rte_crypto_cipher_operation cipher_op,
1937 enum rte_crypto_auth_operation auth_op,
1938 enum rte_crypto_auth_algorithm auth_algo,
1939 enum rte_crypto_cipher_algorithm cipher_algo,
1940 const uint8_t *key, const uint8_t key_len,
1941 const uint8_t aad_len, const uint8_t auth_len)
1944 uint8_t cipher_auth_key[key_len];
1946 struct crypto_unittest_params *ut_params = &unittest_params;
1948 memcpy(cipher_auth_key, key, key_len);
1950 /* Setup Authentication Parameters */
1951 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1952 ut_params->auth_xform.next = NULL;
1954 ut_params->auth_xform.auth.op = auth_op;
1955 ut_params->auth_xform.auth.algo = auth_algo;
1956 ut_params->auth_xform.auth.key.length = key_len;
1957 /* Hash key = cipher key */
1958 ut_params->auth_xform.auth.key.data = cipher_auth_key;
1959 ut_params->auth_xform.auth.digest_length = auth_len;
1960 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1962 /* Setup Cipher Parameters */
1963 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1964 ut_params->cipher_xform.next = &ut_params->auth_xform;
1966 ut_params->cipher_xform.cipher.algo = cipher_algo;
1967 ut_params->cipher_xform.cipher.op = cipher_op;
1968 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1969 ut_params->cipher_xform.cipher.key.length = key_len;
1971 TEST_HEXDUMP(stdout, "key:", key, key_len);
1973 /* Create Crypto session*/
1974 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1975 &ut_params->cipher_xform);
1977 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1982 create_wireless_cipher_auth_session(uint8_t dev_id,
1983 enum rte_crypto_cipher_operation cipher_op,
1984 enum rte_crypto_auth_operation auth_op,
1985 enum rte_crypto_auth_algorithm auth_algo,
1986 enum rte_crypto_cipher_algorithm cipher_algo,
1987 const struct wireless_test_data *tdata)
1989 const uint8_t key_len = tdata->key.len;
1990 uint8_t cipher_auth_key[key_len];
1992 struct crypto_unittest_params *ut_params = &unittest_params;
1993 const uint8_t *key = tdata->key.data;
1994 const uint8_t aad_len = tdata->aad.len;
1995 const uint8_t auth_len = tdata->digest.len;
1997 memcpy(cipher_auth_key, key, key_len);
1999 /* Setup Authentication Parameters */
2000 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2001 ut_params->auth_xform.next = NULL;
2003 ut_params->auth_xform.auth.op = auth_op;
2004 ut_params->auth_xform.auth.algo = auth_algo;
2005 ut_params->auth_xform.auth.key.length = key_len;
2006 /* Hash key = cipher key */
2007 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2008 ut_params->auth_xform.auth.digest_length = auth_len;
2009 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2011 /* Setup Cipher Parameters */
2012 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2013 ut_params->cipher_xform.next = &ut_params->auth_xform;
2015 ut_params->cipher_xform.cipher.algo = cipher_algo;
2016 ut_params->cipher_xform.cipher.op = cipher_op;
2017 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2018 ut_params->cipher_xform.cipher.key.length = key_len;
2020 TEST_HEXDUMP(stdout, "key:", key, key_len);
2022 /* Create Crypto session*/
2023 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2024 &ut_params->cipher_xform);
2026 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2031 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2032 const struct wireless_test_data *tdata)
2034 return create_wireless_cipher_auth_session(dev_id,
2035 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2036 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2037 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2041 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2042 enum rte_crypto_cipher_operation cipher_op,
2043 enum rte_crypto_auth_operation auth_op,
2044 enum rte_crypto_auth_algorithm auth_algo,
2045 enum rte_crypto_cipher_algorithm cipher_algo,
2046 const uint8_t *key, const uint8_t key_len,
2047 const uint8_t aad_len, const uint8_t auth_len)
2049 uint8_t auth_cipher_key[key_len];
2051 struct crypto_unittest_params *ut_params = &unittest_params;
2053 memcpy(auth_cipher_key, key, key_len);
2055 /* Setup Authentication Parameters */
2056 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2057 ut_params->auth_xform.auth.op = auth_op;
2058 ut_params->auth_xform.next = &ut_params->cipher_xform;
2059 ut_params->auth_xform.auth.algo = auth_algo;
2060 ut_params->auth_xform.auth.key.length = key_len;
2061 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2062 ut_params->auth_xform.auth.digest_length = auth_len;
2063 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2065 /* Setup Cipher Parameters */
2066 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2067 ut_params->cipher_xform.next = NULL;
2068 ut_params->cipher_xform.cipher.algo = cipher_algo;
2069 ut_params->cipher_xform.cipher.op = cipher_op;
2070 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2071 ut_params->cipher_xform.cipher.key.length = key_len;
2073 TEST_HEXDUMP(stdout, "key:", key, key_len);
2075 /* Create Crypto session*/
2076 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2077 &ut_params->auth_xform);
2079 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2085 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2086 const unsigned auth_tag_len,
2087 const uint8_t *aad, const unsigned aad_len,
2088 unsigned data_pad_len,
2089 enum rte_crypto_auth_operation op,
2090 enum rte_crypto_auth_algorithm algo,
2091 const unsigned auth_len, const unsigned auth_offset)
2093 struct crypto_testsuite_params *ts_params = &testsuite_params;
2095 struct crypto_unittest_params *ut_params = &unittest_params;
2097 unsigned aad_buffer_len;
2099 /* Generate Crypto op data structure */
2100 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2101 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2102 TEST_ASSERT_NOT_NULL(ut_params->op,
2103 "Failed to allocate pktmbuf offload");
2105 /* Set crypto operation data parameters */
2106 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2108 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2110 /* set crypto operation source mbuf */
2111 sym_op->m_src = ut_params->ibuf;
2115 * Always allocate the aad up to the block size.
2116 * The cryptodev API calls out -
2117 * - the array must be big enough to hold the AAD, plus any
2118 * space to round this up to the nearest multiple of the
2119 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2121 if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2122 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2124 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2125 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2126 ut_params->ibuf, aad_buffer_len);
2127 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2128 "no room to prepend aad");
2129 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2131 sym_op->auth.aad.length = aad_len;
2133 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2134 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2136 TEST_HEXDUMP(stdout, "aad:",
2137 sym_op->auth.aad.data, aad_len);
2140 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2141 ut_params->ibuf, auth_tag_len);
2143 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2144 "no room to append auth tag");
2145 ut_params->digest = sym_op->auth.digest.data;
2146 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2147 ut_params->ibuf, data_pad_len + aad_len);
2148 sym_op->auth.digest.length = auth_tag_len;
2149 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2150 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2152 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2154 TEST_HEXDUMP(stdout, "digest:",
2155 sym_op->auth.digest.data,
2156 sym_op->auth.digest.length);
2158 sym_op->auth.data.length = auth_len;
2159 sym_op->auth.data.offset = auth_offset;
2165 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2166 enum rte_crypto_auth_operation op,
2167 enum rte_crypto_auth_algorithm auth_algo,
2168 enum rte_crypto_cipher_algorithm cipher_algo)
2170 struct crypto_testsuite_params *ts_params = &testsuite_params;
2171 struct crypto_unittest_params *ut_params = &unittest_params;
2173 const uint8_t *auth_tag = tdata->digest.data;
2174 const unsigned int auth_tag_len = tdata->digest.len;
2175 const uint8_t *aad = tdata->aad.data;
2176 const uint8_t aad_len = tdata->aad.len;
2177 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2178 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2180 const uint8_t *iv = tdata->iv.data;
2181 const uint8_t iv_len = tdata->iv.len;
2182 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2183 const unsigned int cipher_offset = tdata->iv.len << 3;
2184 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2185 const unsigned int auth_offset = tdata->aad.len << 3;
2187 unsigned int iv_pad_len = 0;
2188 unsigned int aad_buffer_len;
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");
2195 /* Set crypto operation data parameters */
2196 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2198 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2200 /* set crypto operation source mbuf */
2201 sym_op->m_src = ut_params->ibuf;
2204 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2205 ut_params->ibuf, auth_tag_len);
2207 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2208 "no room to append auth tag");
2209 ut_params->digest = sym_op->auth.digest.data;
2210 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2211 ut_params->ibuf, data_pad_len);
2212 sym_op->auth.digest.length = auth_tag_len;
2213 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2214 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2216 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2218 TEST_HEXDUMP(stdout, "digest:",
2219 sym_op->auth.digest.data,
2220 sym_op->auth.digest.length);
2224 * Always allocate the aad up to the block size.
2225 * The cryptodev API calls out -
2226 * - the array must be big enough to hold the AAD, plus any
2227 * space to round this up to the nearest multiple of the
2228 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2230 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2231 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2233 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2234 sym_op->auth.aad.data =
2235 (uint8_t *)rte_pktmbuf_prepend(
2236 ut_params->ibuf, aad_buffer_len);
2237 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2238 "no room to prepend aad");
2239 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2241 sym_op->auth.aad.length = aad_len;
2242 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2243 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2244 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
2247 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2248 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2250 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2251 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2252 ut_params->ibuf, iv_pad_len);
2254 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2255 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2256 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2257 sym_op->cipher.iv.length = iv_pad_len;
2258 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2259 sym_op->cipher.data.length = cipher_len;
2260 sym_op->cipher.data.offset = cipher_offset + auth_offset;
2261 sym_op->auth.data.length = auth_len;
2262 sym_op->auth.data.offset = auth_offset + cipher_offset;
2268 create_zuc_cipher_hash_generate_operation(
2269 const struct wireless_test_data *tdata)
2271 return create_wireless_cipher_hash_operation(tdata,
2272 RTE_CRYPTO_AUTH_OP_GENERATE,
2273 RTE_CRYPTO_AUTH_ZUC_EIA3,
2274 RTE_CRYPTO_CIPHER_ZUC_EEA3);
2278 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2279 const unsigned auth_tag_len,
2280 const uint8_t *aad, const uint8_t aad_len,
2281 unsigned data_pad_len,
2282 enum rte_crypto_auth_operation op,
2283 enum rte_crypto_auth_algorithm auth_algo,
2284 enum rte_crypto_cipher_algorithm cipher_algo,
2285 const uint8_t *iv, const uint8_t iv_len,
2286 const unsigned cipher_len, const unsigned cipher_offset,
2287 const unsigned auth_len, const unsigned auth_offset)
2289 struct crypto_testsuite_params *ts_params = &testsuite_params;
2290 struct crypto_unittest_params *ut_params = &unittest_params;
2292 unsigned iv_pad_len = 0;
2293 unsigned aad_buffer_len;
2295 /* Generate Crypto op data structure */
2296 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2297 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2298 TEST_ASSERT_NOT_NULL(ut_params->op,
2299 "Failed to allocate pktmbuf offload");
2300 /* Set crypto operation data parameters */
2301 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2303 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2305 /* set crypto operation source mbuf */
2306 sym_op->m_src = ut_params->ibuf;
2309 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2310 ut_params->ibuf, auth_tag_len);
2312 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2313 "no room to append auth tag");
2314 ut_params->digest = sym_op->auth.digest.data;
2315 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2316 ut_params->ibuf, data_pad_len);
2317 sym_op->auth.digest.length = auth_tag_len;
2318 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2319 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2321 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2323 TEST_HEXDUMP(stdout, "digest:",
2324 sym_op->auth.digest.data,
2325 sym_op->auth.digest.length);
2329 * Always allocate the aad up to the block size.
2330 * The cryptodev API calls out -
2331 * - the array must be big enough to hold the AAD, plus any
2332 * space to round this up to the nearest multiple of the
2333 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2335 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2336 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2338 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2339 sym_op->auth.aad.data =
2340 (uint8_t *)rte_pktmbuf_prepend(
2341 ut_params->ibuf, aad_buffer_len);
2342 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2343 "no room to prepend aad");
2344 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2346 sym_op->auth.aad.length = aad_len;
2347 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2348 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2349 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
2352 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2353 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2355 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2356 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2357 ut_params->ibuf, iv_pad_len);
2359 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2360 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2361 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2362 sym_op->cipher.iv.length = iv_pad_len;
2363 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2364 sym_op->cipher.data.length = cipher_len;
2365 sym_op->cipher.data.offset = cipher_offset + auth_offset;
2366 sym_op->auth.data.length = auth_len;
2367 sym_op->auth.data.offset = auth_offset + cipher_offset;
2373 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
2374 const uint8_t *iv, const uint8_t iv_len,
2375 const uint8_t *aad, const uint8_t aad_len,
2376 unsigned data_pad_len,
2377 const unsigned cipher_len, const unsigned cipher_offset,
2378 const unsigned auth_len, const unsigned auth_offset,
2379 enum rte_crypto_auth_algorithm auth_algo,
2380 enum rte_crypto_cipher_algorithm cipher_algo)
2382 struct crypto_testsuite_params *ts_params = &testsuite_params;
2383 struct crypto_unittest_params *ut_params = &unittest_params;
2385 unsigned iv_pad_len = 0;
2386 unsigned aad_buffer_len = 0;
2388 /* Generate Crypto op data structure */
2389 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2390 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2391 TEST_ASSERT_NOT_NULL(ut_params->op,
2392 "Failed to allocate pktmbuf offload");
2394 /* Set crypto operation data parameters */
2395 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2397 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2399 /* set crypto operation source mbuf */
2400 sym_op->m_src = ut_params->ibuf;
2403 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2404 ut_params->ibuf, auth_tag_len);
2406 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2407 "no room to append auth tag");
2409 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2410 ut_params->ibuf, data_pad_len);
2411 sym_op->auth.digest.length = auth_tag_len;
2413 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2415 TEST_HEXDUMP(stdout, "digest:",
2416 sym_op->auth.digest.data,
2417 sym_op->auth.digest.length);
2421 * Always allocate the aad up to the block size.
2422 * The cryptodev API calls out -
2423 * - the array must be big enough to hold the AAD, plus any
2424 * space to round this up to the nearest multiple of the
2425 * block size (8 bytes for KASUMI 16 bytes).
2427 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2428 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2430 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2431 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2432 ut_params->ibuf, aad_buffer_len);
2433 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2434 "no room to prepend aad");
2435 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2437 sym_op->auth.aad.length = aad_len;
2438 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2439 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2440 TEST_HEXDUMP(stdout, "aad:",
2441 sym_op->auth.aad.data, aad_len);
2444 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2445 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2447 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2449 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2450 ut_params->ibuf, iv_pad_len);
2451 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2453 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2454 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2455 sym_op->cipher.iv.length = iv_pad_len;
2457 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2459 sym_op->cipher.data.length = cipher_len;
2460 sym_op->cipher.data.offset = auth_offset + cipher_offset;
2462 sym_op->auth.data.length = auth_len;
2463 sym_op->auth.data.offset = auth_offset + cipher_offset;
2469 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2471 struct crypto_testsuite_params *ts_params = &testsuite_params;
2472 struct crypto_unittest_params *ut_params = &unittest_params;
2475 unsigned plaintext_pad_len;
2476 unsigned plaintext_len;
2479 /* Create SNOW 3G session */
2480 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2481 tdata->key.data, tdata->key.len,
2482 tdata->aad.len, tdata->digest.len,
2483 RTE_CRYPTO_AUTH_OP_GENERATE,
2484 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2488 /* alloc mbuf and set payload */
2489 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2491 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2492 rte_pktmbuf_tailroom(ut_params->ibuf));
2494 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2495 /* Append data which is padded to a multiple of */
2496 /* the algorithms block size */
2497 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2498 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2500 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2502 /* Create SNOW 3G operation */
2503 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2504 tdata->aad.data, tdata->aad.len,
2505 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2506 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2507 tdata->validAuthLenInBits.len,
2508 (tdata->aad.len << 3));
2512 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2514 ut_params->obuf = ut_params->op->sym->m_src;
2515 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2516 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2517 + plaintext_pad_len + tdata->aad.len;
2520 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2523 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2524 "SNOW 3G Generated auth tag not as expected");
2530 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2532 struct crypto_testsuite_params *ts_params = &testsuite_params;
2533 struct crypto_unittest_params *ut_params = &unittest_params;
2536 unsigned plaintext_pad_len;
2537 unsigned plaintext_len;
2540 /* Create SNOW 3G session */
2541 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2542 tdata->key.data, tdata->key.len,
2543 tdata->aad.len, tdata->digest.len,
2544 RTE_CRYPTO_AUTH_OP_VERIFY,
2545 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2548 /* alloc mbuf and set payload */
2549 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2551 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2552 rte_pktmbuf_tailroom(ut_params->ibuf));
2554 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2555 /* Append data which is padded to a multiple of */
2556 /* the algorithms block size */
2557 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2558 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2560 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2562 /* Create SNOW 3G operation */
2563 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2565 tdata->aad.data, tdata->aad.len,
2567 RTE_CRYPTO_AUTH_OP_VERIFY,
2568 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2569 tdata->validAuthLenInBits.len,
2570 (tdata->aad.len << 3));
2574 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2576 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2577 ut_params->obuf = ut_params->op->sym->m_src;
2578 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2579 + plaintext_pad_len + tdata->aad.len;
2582 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2591 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2593 struct crypto_testsuite_params *ts_params = &testsuite_params;
2594 struct crypto_unittest_params *ut_params = &unittest_params;
2597 unsigned plaintext_pad_len;
2598 unsigned plaintext_len;
2601 /* Create KASUMI session */
2602 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2603 tdata->key.data, tdata->key.len,
2604 tdata->aad.len, tdata->digest.len,
2605 RTE_CRYPTO_AUTH_OP_GENERATE,
2606 RTE_CRYPTO_AUTH_KASUMI_F9);
2610 /* alloc mbuf and set payload */
2611 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2613 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2614 rte_pktmbuf_tailroom(ut_params->ibuf));
2616 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2617 /* Append data which is padded to a multiple of */
2618 /* the algorithms block size */
2619 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2620 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2622 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2624 /* Create KASUMI operation */
2625 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2626 tdata->aad.data, tdata->aad.len,
2627 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2628 RTE_CRYPTO_AUTH_KASUMI_F9,
2629 tdata->validAuthLenInBits.len,
2630 (tdata->aad.len << 3));
2634 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2636 ut_params->obuf = ut_params->op->sym->m_src;
2637 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2638 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2639 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
2642 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2645 DIGEST_BYTE_LENGTH_KASUMI_F9,
2646 "KASUMI Generated auth tag not as expected");
2652 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2654 struct crypto_testsuite_params *ts_params = &testsuite_params;
2655 struct crypto_unittest_params *ut_params = &unittest_params;
2658 unsigned plaintext_pad_len;
2659 unsigned plaintext_len;
2662 /* Create KASUMI session */
2663 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2664 tdata->key.data, tdata->key.len,
2665 tdata->aad.len, tdata->digest.len,
2666 RTE_CRYPTO_AUTH_OP_VERIFY,
2667 RTE_CRYPTO_AUTH_KASUMI_F9);
2670 /* alloc mbuf and set payload */
2671 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2673 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2674 rte_pktmbuf_tailroom(ut_params->ibuf));
2676 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2677 /* Append data which is padded to a multiple */
2678 /* of the algorithms block size */
2679 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2680 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2682 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2684 /* Create KASUMI operation */
2685 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2687 tdata->aad.data, tdata->aad.len,
2689 RTE_CRYPTO_AUTH_OP_VERIFY,
2690 RTE_CRYPTO_AUTH_KASUMI_F9,
2691 tdata->validAuthLenInBits.len,
2692 (tdata->aad.len << 3));
2696 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2698 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2699 ut_params->obuf = ut_params->op->sym->m_src;
2700 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2701 + plaintext_pad_len + tdata->aad.len;
2704 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2713 test_snow3g_hash_generate_test_case_1(void)
2715 return test_snow3g_authentication(&snow3g_hash_test_case_1);
2719 test_snow3g_hash_generate_test_case_2(void)
2721 return test_snow3g_authentication(&snow3g_hash_test_case_2);
2725 test_snow3g_hash_generate_test_case_3(void)
2727 return test_snow3g_authentication(&snow3g_hash_test_case_3);
2731 test_snow3g_hash_generate_test_case_4(void)
2733 return test_snow3g_authentication(&snow3g_hash_test_case_4);
2737 test_snow3g_hash_generate_test_case_5(void)
2739 return test_snow3g_authentication(&snow3g_hash_test_case_5);
2743 test_snow3g_hash_generate_test_case_6(void)
2745 return test_snow3g_authentication(&snow3g_hash_test_case_6);
2749 test_snow3g_hash_verify_test_case_1(void)
2751 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2756 test_snow3g_hash_verify_test_case_2(void)
2758 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2762 test_snow3g_hash_verify_test_case_3(void)
2764 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2768 test_snow3g_hash_verify_test_case_4(void)
2770 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2774 test_snow3g_hash_verify_test_case_5(void)
2776 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2780 test_snow3g_hash_verify_test_case_6(void)
2782 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2786 test_kasumi_hash_generate_test_case_1(void)
2788 return test_kasumi_authentication(&kasumi_hash_test_case_1);
2792 test_kasumi_hash_generate_test_case_2(void)
2794 return test_kasumi_authentication(&kasumi_hash_test_case_2);
2798 test_kasumi_hash_generate_test_case_3(void)
2800 return test_kasumi_authentication(&kasumi_hash_test_case_3);
2804 test_kasumi_hash_generate_test_case_4(void)
2806 return test_kasumi_authentication(&kasumi_hash_test_case_4);
2810 test_kasumi_hash_generate_test_case_5(void)
2812 return test_kasumi_authentication(&kasumi_hash_test_case_5);
2816 test_kasumi_hash_generate_test_case_6(void)
2818 return test_kasumi_authentication(&kasumi_hash_test_case_6);
2822 test_kasumi_hash_verify_test_case_1(void)
2824 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2828 test_kasumi_hash_verify_test_case_2(void)
2830 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2834 test_kasumi_hash_verify_test_case_3(void)
2836 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2840 test_kasumi_hash_verify_test_case_4(void)
2842 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2846 test_kasumi_hash_verify_test_case_5(void)
2848 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2852 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2854 struct crypto_testsuite_params *ts_params = &testsuite_params;
2855 struct crypto_unittest_params *ut_params = &unittest_params;
2858 uint8_t *plaintext, *ciphertext;
2859 unsigned plaintext_pad_len;
2860 unsigned plaintext_len;
2862 /* Create KASUMI session */
2863 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2864 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2865 RTE_CRYPTO_CIPHER_KASUMI_F8,
2866 tdata->key.data, tdata->key.len);
2870 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2872 /* Clear mbuf payload */
2873 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2874 rte_pktmbuf_tailroom(ut_params->ibuf));
2876 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2877 /* Append data which is padded to a multiple */
2878 /* of the algorithms block size */
2879 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2880 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2882 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2884 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2886 /* Create KASUMI operation */
2887 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2888 tdata->plaintext.len,
2889 (tdata->iv.len << 3),
2890 RTE_CRYPTO_CIPHER_KASUMI_F8);
2894 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2896 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2898 ut_params->obuf = ut_params->op->sym->m_dst;
2899 if (ut_params->obuf)
2900 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2903 ciphertext = plaintext;
2905 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2908 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2910 tdata->ciphertext.data,
2911 tdata->validCipherLenInBits.len,
2912 "KASUMI Ciphertext data not as expected");
2917 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2919 struct crypto_testsuite_params *ts_params = &testsuite_params;
2920 struct crypto_unittest_params *ut_params = &unittest_params;
2924 unsigned int plaintext_pad_len;
2925 unsigned int plaintext_len;
2927 uint8_t buffer[10000];
2928 const uint8_t *ciphertext;
2930 struct rte_cryptodev_info dev_info;
2932 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2933 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
2934 printf("Device doesn't support scatter-gather. "
2939 /* Create KASUMI session */
2940 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2941 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2942 RTE_CRYPTO_CIPHER_KASUMI_F8,
2943 tdata->key.data, tdata->key.len);
2947 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2950 /* Append data which is padded to a multiple */
2951 /* of the algorithms block size */
2952 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2954 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2955 plaintext_pad_len, 10, 0);
2957 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2959 /* Create KASUMI operation */
2960 retval = create_wireless_algo_cipher_operation(tdata->iv.data,
2962 tdata->plaintext.len,
2963 (tdata->iv.len << 3),
2964 RTE_CRYPTO_CIPHER_KASUMI_F8);
2968 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2970 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2972 ut_params->obuf = ut_params->op->sym->m_dst;
2974 if (ut_params->obuf)
2975 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
2976 plaintext_len, buffer);
2978 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
2979 plaintext_len, buffer);
2982 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2985 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2987 tdata->ciphertext.data,
2988 tdata->validCipherLenInBits.len,
2989 "KASUMI Ciphertext data not as expected");
2994 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2996 struct crypto_testsuite_params *ts_params = &testsuite_params;
2997 struct crypto_unittest_params *ut_params = &unittest_params;
3000 uint8_t *plaintext, *ciphertext;
3001 unsigned plaintext_pad_len;
3002 unsigned plaintext_len;
3004 /* Create KASUMI session */
3005 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3006 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3007 RTE_CRYPTO_CIPHER_KASUMI_F8,
3008 tdata->key.data, tdata->key.len);
3012 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3013 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3015 /* Clear mbuf payload */
3016 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3017 rte_pktmbuf_tailroom(ut_params->ibuf));
3019 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3020 /* Append data which is padded to a multiple */
3021 /* of the algorithms block size */
3022 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3023 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3025 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3026 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3028 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3030 /* Create KASUMI operation */
3031 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3033 tdata->plaintext.len,
3034 (tdata->iv.len << 3),
3035 RTE_CRYPTO_CIPHER_KASUMI_F8);
3039 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3041 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3043 ut_params->obuf = ut_params->op->sym->m_dst;
3044 if (ut_params->obuf)
3045 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3048 ciphertext = plaintext;
3050 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3053 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3055 tdata->ciphertext.data,
3056 tdata->validCipherLenInBits.len,
3057 "KASUMI Ciphertext data not as expected");
3062 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3064 struct crypto_testsuite_params *ts_params = &testsuite_params;
3065 struct crypto_unittest_params *ut_params = &unittest_params;
3068 unsigned int plaintext_pad_len;
3069 unsigned int plaintext_len;
3071 const uint8_t *ciphertext;
3072 uint8_t buffer[2048];
3074 struct rte_cryptodev_info dev_info;
3076 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3077 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3078 printf("Device doesn't support scatter-gather. "
3083 /* Create KASUMI session */
3084 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3085 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3086 RTE_CRYPTO_CIPHER_KASUMI_F8,
3087 tdata->key.data, tdata->key.len);
3091 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3092 /* Append data which is padded to a multiple */
3093 /* of the algorithms block size */
3094 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3096 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3097 plaintext_pad_len, 10, 0);
3098 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3099 plaintext_pad_len, 3, 0);
3101 /* Append data which is padded to a multiple */
3102 /* of the algorithms block size */
3103 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3105 /* Create KASUMI operation */
3106 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3108 tdata->plaintext.len,
3109 (tdata->iv.len << 3),
3110 RTE_CRYPTO_CIPHER_KASUMI_F8);
3114 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3116 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3118 ut_params->obuf = ut_params->op->sym->m_dst;
3119 if (ut_params->obuf)
3120 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
3121 plaintext_pad_len, buffer);
3123 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
3124 plaintext_pad_len, buffer);
3127 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3129 tdata->ciphertext.data,
3130 tdata->validCipherLenInBits.len,
3131 "KASUMI Ciphertext data not as expected");
3137 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3139 struct crypto_testsuite_params *ts_params = &testsuite_params;
3140 struct crypto_unittest_params *ut_params = &unittest_params;
3143 uint8_t *ciphertext, *plaintext;
3144 unsigned ciphertext_pad_len;
3145 unsigned ciphertext_len;
3147 /* Create KASUMI session */
3148 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3149 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3150 RTE_CRYPTO_CIPHER_KASUMI_F8,
3151 tdata->key.data, tdata->key.len);
3155 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3156 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3158 /* Clear mbuf payload */
3159 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3160 rte_pktmbuf_tailroom(ut_params->ibuf));
3162 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3163 /* Append data which is padded to a multiple */
3164 /* of the algorithms block size */
3165 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3166 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3167 ciphertext_pad_len);
3168 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3169 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3171 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3173 /* Create KASUMI operation */
3174 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3176 tdata->ciphertext.len,
3177 (tdata->iv.len << 3),
3178 RTE_CRYPTO_CIPHER_KASUMI_F8);
3182 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3184 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3186 ut_params->obuf = ut_params->op->sym->m_dst;
3187 if (ut_params->obuf)
3188 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3191 plaintext = ciphertext;
3193 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3196 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3198 tdata->plaintext.data,
3199 tdata->validCipherLenInBits.len,
3200 "KASUMI Plaintext data not as expected");
3205 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3207 struct crypto_testsuite_params *ts_params = &testsuite_params;
3208 struct crypto_unittest_params *ut_params = &unittest_params;
3211 uint8_t *ciphertext, *plaintext;
3212 unsigned ciphertext_pad_len;
3213 unsigned ciphertext_len;
3215 /* Create KASUMI session */
3216 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3217 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3218 RTE_CRYPTO_CIPHER_KASUMI_F8,
3219 tdata->key.data, tdata->key.len);
3223 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3225 /* Clear mbuf payload */
3226 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3227 rte_pktmbuf_tailroom(ut_params->ibuf));
3229 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3230 /* Append data which is padded to a multiple */
3231 /* of the algorithms block size */
3232 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3233 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3234 ciphertext_pad_len);
3235 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3237 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3239 /* Create KASUMI operation */
3240 retval = create_wireless_algo_cipher_operation(tdata->iv.data,
3242 tdata->ciphertext.len,
3243 (tdata->iv.len << 3),
3244 RTE_CRYPTO_CIPHER_KASUMI_F8);
3248 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3250 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3252 ut_params->obuf = ut_params->op->sym->m_dst;
3253 if (ut_params->obuf)
3254 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3257 plaintext = ciphertext;
3259 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3262 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3264 tdata->plaintext.data,
3265 tdata->validCipherLenInBits.len,
3266 "KASUMI Plaintext data not as expected");
3271 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3273 struct crypto_testsuite_params *ts_params = &testsuite_params;
3274 struct crypto_unittest_params *ut_params = &unittest_params;
3277 uint8_t *plaintext, *ciphertext;
3278 unsigned plaintext_pad_len;
3279 unsigned plaintext_len;
3281 /* Create SNOW 3G session */
3282 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3283 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3284 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3285 tdata->key.data, tdata->key.len);
3289 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3291 /* Clear mbuf payload */
3292 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3293 rte_pktmbuf_tailroom(ut_params->ibuf));
3295 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3296 /* Append data which is padded to a multiple of */
3297 /* the algorithms block size */
3298 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3299 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3301 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3303 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3305 /* Create SNOW 3G operation */
3306 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3307 tdata->validCipherLenInBits.len,
3308 (tdata->iv.len << 3),
3309 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3313 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3315 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3317 ut_params->obuf = ut_params->op->sym->m_dst;
3318 if (ut_params->obuf)
3319 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3322 ciphertext = plaintext;
3324 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3327 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3329 tdata->ciphertext.data,
3330 tdata->validDataLenInBits.len,
3331 "SNOW 3G Ciphertext data not as expected");
3337 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3339 struct crypto_testsuite_params *ts_params = &testsuite_params;
3340 struct crypto_unittest_params *ut_params = &unittest_params;
3341 uint8_t *plaintext, *ciphertext;
3344 unsigned plaintext_pad_len;
3345 unsigned plaintext_len;
3347 /* Create SNOW 3G session */
3348 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3349 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3350 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3351 tdata->key.data, tdata->key.len);
3355 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3356 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3358 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3359 "Failed to allocate input buffer in mempool");
3360 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3361 "Failed to allocate output buffer in mempool");
3363 /* Clear mbuf payload */
3364 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3365 rte_pktmbuf_tailroom(ut_params->ibuf));
3367 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3368 /* Append data which is padded to a multiple of */
3369 /* the algorithms block size */
3370 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3371 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3373 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3374 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3376 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3378 /* Create SNOW 3G operation */
3379 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3381 tdata->validCipherLenInBits.len,
3382 (tdata->iv.len << 3),
3383 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3387 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3389 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3391 ut_params->obuf = ut_params->op->sym->m_dst;
3392 if (ut_params->obuf)
3393 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3396 ciphertext = plaintext;
3398 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3401 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3403 tdata->ciphertext.data,
3404 tdata->validDataLenInBits.len,
3405 "SNOW 3G Ciphertext data not as expected");
3410 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3412 struct crypto_testsuite_params *ts_params = &testsuite_params;
3413 struct crypto_unittest_params *ut_params = &unittest_params;
3416 unsigned int plaintext_pad_len;
3417 unsigned int plaintext_len;
3418 uint8_t buffer[10000];
3419 const uint8_t *ciphertext;
3421 struct rte_cryptodev_info dev_info;
3423 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3424 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3425 printf("Device doesn't support scatter-gather. "
3430 /* Create SNOW 3G session */
3431 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3432 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3433 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3434 tdata->key.data, tdata->key.len);
3438 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3439 /* Append data which is padded to a multiple of */
3440 /* the algorithms block size */
3441 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3443 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3444 plaintext_pad_len, 10, 0);
3445 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3446 plaintext_pad_len, 3, 0);
3448 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3449 "Failed to allocate input buffer in mempool");
3450 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3451 "Failed to allocate output buffer in mempool");
3453 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3455 /* Create SNOW 3G operation */
3456 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3458 tdata->validCipherLenInBits.len,
3459 (tdata->iv.len << 3),
3460 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3464 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3466 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3468 ut_params->obuf = ut_params->op->sym->m_dst;
3469 if (ut_params->obuf)
3470 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
3471 plaintext_len, buffer);
3473 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
3474 plaintext_len, buffer);
3476 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3479 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3481 tdata->ciphertext.data,
3482 tdata->validDataLenInBits.len,
3483 "SNOW 3G Ciphertext data not as expected");
3488 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3490 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3492 uint8_t curr_byte, prev_byte;
3493 uint32_t length_in_bytes = ceil_byte_length(length + offset);
3494 uint8_t lower_byte_mask = (1 << offset) - 1;
3497 prev_byte = buffer[0];
3498 buffer[0] >>= offset;
3500 for (i = 1; i < length_in_bytes; i++) {
3501 curr_byte = buffer[i];
3502 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3503 (curr_byte >> offset);
3504 prev_byte = curr_byte;
3509 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3511 struct crypto_testsuite_params *ts_params = &testsuite_params;
3512 struct crypto_unittest_params *ut_params = &unittest_params;
3513 uint8_t *plaintext, *ciphertext;
3515 uint32_t plaintext_len;
3516 uint32_t plaintext_pad_len;
3517 uint8_t extra_offset = 4;
3518 uint8_t *expected_ciphertext_shifted;
3520 /* Create SNOW 3G session */
3521 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3522 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3523 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3524 tdata->key.data, tdata->key.len);
3528 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3529 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3531 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3532 "Failed to allocate input buffer in mempool");
3533 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3534 "Failed to allocate output buffer in mempool");
3536 /* Clear mbuf payload */
3537 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3538 rte_pktmbuf_tailroom(ut_params->ibuf));
3540 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3542 * Append data which is padded to a
3543 * multiple of the algorithms block size
3545 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3547 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3550 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3552 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3553 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3555 #ifdef RTE_APP_TEST_DEBUG
3556 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3558 /* Create SNOW 3G operation */
3559 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3561 tdata->validCipherLenInBits.len,
3562 (tdata->iv.len << 3) +
3564 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3568 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3570 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3572 ut_params->obuf = ut_params->op->sym->m_dst;
3573 if (ut_params->obuf)
3574 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3577 ciphertext = plaintext;
3579 #ifdef RTE_APP_TEST_DEBUG
3580 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3583 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3585 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3586 "failed to reserve memory for ciphertext shifted\n");
3588 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3589 ceil_byte_length(tdata->ciphertext.len));
3590 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3593 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3595 expected_ciphertext_shifted,
3596 tdata->validDataLenInBits.len,
3598 "SNOW 3G Ciphertext data not as expected");
3602 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3604 struct crypto_testsuite_params *ts_params = &testsuite_params;
3605 struct crypto_unittest_params *ut_params = &unittest_params;
3609 uint8_t *plaintext, *ciphertext;
3610 unsigned ciphertext_pad_len;
3611 unsigned ciphertext_len;
3613 /* Create SNOW 3G session */
3614 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3615 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3616 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3617 tdata->key.data, tdata->key.len);
3621 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3623 /* Clear mbuf payload */
3624 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3625 rte_pktmbuf_tailroom(ut_params->ibuf));
3627 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3628 /* Append data which is padded to a multiple of */
3629 /* the algorithms block size */
3630 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3631 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3632 ciphertext_pad_len);
3633 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3635 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3637 /* Create SNOW 3G operation */
3638 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3639 tdata->validCipherLenInBits.len,
3640 (tdata->iv.len << 3),
3641 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3645 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3647 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3648 ut_params->obuf = ut_params->op->sym->m_dst;
3649 if (ut_params->obuf)
3650 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3653 plaintext = ciphertext;
3655 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3658 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3659 tdata->plaintext.data,
3660 tdata->validDataLenInBits.len,
3661 "SNOW 3G Plaintext data not as expected");
3665 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3667 struct crypto_testsuite_params *ts_params = &testsuite_params;
3668 struct crypto_unittest_params *ut_params = &unittest_params;
3672 uint8_t *plaintext, *ciphertext;
3673 unsigned ciphertext_pad_len;
3674 unsigned ciphertext_len;
3676 /* Create SNOW 3G session */
3677 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3678 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3679 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3680 tdata->key.data, tdata->key.len);
3684 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3685 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3687 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3688 "Failed to allocate input buffer");
3689 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3690 "Failed to allocate output buffer");
3692 /* Clear mbuf payload */
3693 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3694 rte_pktmbuf_tailroom(ut_params->ibuf));
3696 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3697 rte_pktmbuf_tailroom(ut_params->obuf));
3699 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3700 /* Append data which is padded to a multiple of */
3701 /* the algorithms block size */
3702 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3703 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3704 ciphertext_pad_len);
3705 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3706 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3708 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3710 /* Create SNOW 3G operation */
3711 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3713 tdata->validCipherLenInBits.len,
3714 (tdata->iv.len << 3),
3715 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3719 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3721 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3722 ut_params->obuf = ut_params->op->sym->m_dst;
3723 if (ut_params->obuf)
3724 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3727 plaintext = ciphertext;
3729 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3732 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3733 tdata->plaintext.data,
3734 tdata->validDataLenInBits.len,
3735 "SNOW 3G Plaintext data not as expected");
3740 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
3742 struct crypto_testsuite_params *ts_params = &testsuite_params;
3743 struct crypto_unittest_params *ut_params = &unittest_params;
3747 uint8_t *plaintext, *ciphertext;
3748 unsigned int plaintext_pad_len;
3749 unsigned int plaintext_len;
3751 struct rte_cryptodev_sym_capability_idx cap_idx;
3753 /* Check if device supports ZUC EEA3 */
3754 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3755 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
3757 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3761 /* Check if device supports ZUC EIA3 */
3762 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3763 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
3765 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3769 /* Create ZUC session */
3770 retval = create_zuc_cipher_auth_encrypt_generate_session(
3771 ts_params->valid_devs[0],
3775 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3777 /* clear mbuf payload */
3778 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3779 rte_pktmbuf_tailroom(ut_params->ibuf));
3781 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3782 /* Append data which is padded to a multiple of */
3783 /* the algorithms block size */
3784 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3785 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3787 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3789 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3791 /* Create ZUC operation */
3792 retval = create_zuc_cipher_hash_generate_operation(tdata);
3796 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3798 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3799 ut_params->obuf = ut_params->op->sym->m_src;
3800 if (ut_params->obuf)
3801 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3802 + tdata->iv.len + tdata->aad.len;
3804 ciphertext = plaintext;
3806 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3808 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3810 tdata->ciphertext.data,
3811 tdata->validDataLenInBits.len,
3812 "ZUC Ciphertext data not as expected");
3814 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3815 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3818 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3822 "ZUC Generated auth tag not as expected");
3827 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3829 struct crypto_testsuite_params *ts_params = &testsuite_params;
3830 struct crypto_unittest_params *ut_params = &unittest_params;
3834 uint8_t *plaintext, *ciphertext;
3835 unsigned plaintext_pad_len;
3836 unsigned plaintext_len;
3838 /* Create SNOW 3G session */
3839 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3840 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3841 RTE_CRYPTO_AUTH_OP_GENERATE,
3842 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3843 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3844 tdata->key.data, tdata->key.len,
3845 tdata->aad.len, tdata->digest.len);
3848 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3850 /* clear mbuf payload */
3851 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3852 rte_pktmbuf_tailroom(ut_params->ibuf));
3854 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3855 /* Append data which is padded to a multiple of */
3856 /* the algorithms block size */
3857 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3858 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3860 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3862 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3864 /* Create SNOW 3G operation */
3865 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3866 tdata->digest.len, tdata->aad.data,
3867 tdata->aad.len, /*tdata->plaintext.len,*/
3868 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3869 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3870 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3871 tdata->iv.data, tdata->iv.len,
3872 tdata->validCipherLenInBits.len,
3873 (tdata->iv.len << 3),
3874 tdata->validAuthLenInBits.len,
3875 (tdata->aad.len << 3)
3880 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3882 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3883 ut_params->obuf = ut_params->op->sym->m_src;
3884 if (ut_params->obuf)
3885 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3886 + tdata->iv.len + tdata->aad.len;
3888 ciphertext = plaintext;
3890 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3892 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3894 tdata->ciphertext.data,
3895 tdata->validDataLenInBits.len,
3896 "SNOW 3G Ciphertext data not as expected");
3898 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3899 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3902 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3905 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3906 "SNOW 3G Generated auth tag not as expected");
3910 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3912 struct crypto_testsuite_params *ts_params = &testsuite_params;
3913 struct crypto_unittest_params *ut_params = &unittest_params;
3917 uint8_t *plaintext, *ciphertext;
3918 unsigned plaintext_pad_len;
3919 unsigned plaintext_len;
3921 /* Create SNOW 3G session */
3922 retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3923 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3924 RTE_CRYPTO_AUTH_OP_GENERATE,
3925 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3926 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3927 tdata->key.data, tdata->key.len,
3928 tdata->aad.len, tdata->digest.len);
3932 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3934 /* clear mbuf payload */
3935 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3936 rte_pktmbuf_tailroom(ut_params->ibuf));
3938 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3939 /* Append data which is padded to a multiple of */
3940 /* the algorithms block size */
3941 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3942 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3944 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3946 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3948 /* Create SNOW 3G operation */
3949 retval = create_wireless_algo_auth_cipher_operation(
3951 tdata->iv.data, tdata->iv.len,
3952 tdata->aad.data, tdata->aad.len,
3954 tdata->validCipherLenInBits.len,
3955 (tdata->iv.len << 3),
3956 tdata->validAuthLenInBits.len,
3957 (tdata->aad.len << 3),
3958 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3959 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3965 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3967 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3968 ut_params->obuf = ut_params->op->sym->m_src;
3969 if (ut_params->obuf)
3970 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3971 + tdata->aad.len + tdata->iv.len;
3973 ciphertext = plaintext;
3975 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3976 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3977 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3980 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3982 tdata->ciphertext.data,
3983 tdata->validDataLenInBits.len,
3984 "SNOW 3G Ciphertext data not as expected");
3987 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3990 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3991 "SNOW 3G Generated auth tag not as expected");
3996 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3998 struct crypto_testsuite_params *ts_params = &testsuite_params;
3999 struct crypto_unittest_params *ut_params = &unittest_params;
4003 uint8_t *plaintext, *ciphertext;
4004 unsigned plaintext_pad_len;
4005 unsigned plaintext_len;
4007 /* Create KASUMI session */
4008 retval = create_wireless_algo_auth_cipher_session(
4009 ts_params->valid_devs[0],
4010 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4011 RTE_CRYPTO_AUTH_OP_GENERATE,
4012 RTE_CRYPTO_AUTH_KASUMI_F9,
4013 RTE_CRYPTO_CIPHER_KASUMI_F8,
4014 tdata->key.data, tdata->key.len,
4015 tdata->aad.len, tdata->digest.len);
4018 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4020 /* clear mbuf payload */
4021 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4022 rte_pktmbuf_tailroom(ut_params->ibuf));
4024 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4025 /* Append data which is padded to a multiple of */
4026 /* the algorithms block size */
4027 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4028 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4030 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4032 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4034 /* Create KASUMI operation */
4035 retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
4036 tdata->iv.data, tdata->iv.len,
4037 tdata->aad.data, tdata->aad.len,
4039 tdata->validCipherLenInBits.len,
4040 (tdata->iv.len << 3),
4041 tdata->validAuthLenInBits.len,
4042 (tdata->aad.len << 3),
4043 RTE_CRYPTO_AUTH_KASUMI_F9,
4044 RTE_CRYPTO_CIPHER_KASUMI_F8
4050 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4052 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4053 ut_params->obuf = ut_params->op->sym->m_src;
4054 if (ut_params->obuf)
4055 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4056 + tdata->iv.len + tdata->aad.len;
4058 ciphertext = plaintext;
4061 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4063 tdata->ciphertext.data,
4064 tdata->validCipherLenInBits.len,
4065 "KASUMI Ciphertext data not as expected");
4066 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4067 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
4070 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4073 DIGEST_BYTE_LENGTH_KASUMI_F9,
4074 "KASUMI Generated auth tag not as expected");
4079 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4081 struct crypto_testsuite_params *ts_params = &testsuite_params;
4082 struct crypto_unittest_params *ut_params = &unittest_params;
4086 uint8_t *plaintext, *ciphertext;
4087 unsigned plaintext_pad_len;
4088 unsigned plaintext_len;
4090 /* Create KASUMI session */
4091 retval = create_wireless_algo_cipher_auth_session(
4092 ts_params->valid_devs[0],
4093 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4094 RTE_CRYPTO_AUTH_OP_GENERATE,
4095 RTE_CRYPTO_AUTH_KASUMI_F9,
4096 RTE_CRYPTO_CIPHER_KASUMI_F8,
4097 tdata->key.data, tdata->key.len,
4098 tdata->aad.len, tdata->digest.len);
4102 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4104 /* clear mbuf payload */
4105 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4106 rte_pktmbuf_tailroom(ut_params->ibuf));
4108 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4109 /* Append data which is padded to a multiple of */
4110 /* the algorithms block size */
4111 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4112 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4114 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4116 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4118 /* Create KASUMI operation */
4119 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4120 tdata->digest.len, tdata->aad.data,
4122 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4123 RTE_CRYPTO_AUTH_KASUMI_F9,
4124 RTE_CRYPTO_CIPHER_KASUMI_F8,
4125 tdata->iv.data, tdata->iv.len,
4126 tdata->validCipherLenInBits.len,
4127 (tdata->iv.len << 3),
4128 tdata->validAuthLenInBits.len,
4129 (tdata->aad.len << 3)
4134 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4136 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4137 ut_params->obuf = ut_params->op->sym->m_src;
4138 if (ut_params->obuf)
4139 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4140 + tdata->aad.len + tdata->iv.len;
4142 ciphertext = plaintext;
4144 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4145 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
4148 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4150 tdata->ciphertext.data,
4151 tdata->validCipherLenInBits.len,
4152 "KASUMI Ciphertext data not as expected");
4155 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4158 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4159 "KASUMI Generated auth tag not as expected");
4164 test_zuc_encryption(const struct wireless_test_data *tdata)
4166 struct crypto_testsuite_params *ts_params = &testsuite_params;
4167 struct crypto_unittest_params *ut_params = &unittest_params;
4170 uint8_t *plaintext, *ciphertext;
4171 unsigned plaintext_pad_len;
4172 unsigned plaintext_len;
4174 struct rte_cryptodev_sym_capability_idx cap_idx;
4176 /* Check if device supports ZUC EEA3 */
4177 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4178 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4180 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4184 /* Create ZUC session */
4185 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4186 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4187 RTE_CRYPTO_CIPHER_ZUC_EEA3,
4188 tdata->key.data, tdata->key.len);
4192 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4194 /* Clear mbuf payload */
4195 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4196 rte_pktmbuf_tailroom(ut_params->ibuf));
4198 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4199 /* Append data which is padded to a multiple */
4200 /* of the algorithms block size */
4201 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4202 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4204 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4206 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4208 /* Create ZUC operation */
4209 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
4210 tdata->plaintext.len,
4211 (tdata->iv.len << 3),
4212 RTE_CRYPTO_CIPHER_ZUC_EEA3);
4216 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4218 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4220 ut_params->obuf = ut_params->op->sym->m_dst;
4221 if (ut_params->obuf)
4222 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4225 ciphertext = plaintext;
4227 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4230 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4232 tdata->ciphertext.data,
4233 tdata->validCipherLenInBits.len,
4234 "ZUC Ciphertext data not as expected");
4239 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4241 struct crypto_testsuite_params *ts_params = &testsuite_params;
4242 struct crypto_unittest_params *ut_params = &unittest_params;
4246 unsigned int plaintext_pad_len;
4247 unsigned int plaintext_len;
4248 const uint8_t *ciphertext;
4249 uint8_t ciphertext_buffer[2048];
4250 struct rte_cryptodev_info dev_info;
4252 struct rte_cryptodev_sym_capability_idx cap_idx;
4254 /* Check if device supports ZUC EEA3 */
4255 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4256 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4258 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4262 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4263 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
4264 printf("Device doesn't support scatter-gather. "
4269 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4271 /* Append data which is padded to a multiple */
4272 /* of the algorithms block size */
4273 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4275 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4276 plaintext_pad_len, 10, 0);
4278 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4279 tdata->plaintext.data);
4281 /* Create ZUC session */
4282 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4283 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4284 RTE_CRYPTO_CIPHER_ZUC_EEA3,
4285 tdata->key.data, tdata->key.len);
4289 /* Clear mbuf payload */
4291 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4293 /* Create ZUC operation */
4294 retval = create_wireless_algo_cipher_operation(tdata->iv.data,
4295 tdata->iv.len, tdata->plaintext.len,
4296 (tdata->iv.len << 3),
4297 RTE_CRYPTO_CIPHER_ZUC_EEA3);
4301 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4303 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4305 ut_params->obuf = ut_params->op->sym->m_dst;
4306 if (ut_params->obuf)
4307 ciphertext = rte_pktmbuf_read(ut_params->obuf,
4308 tdata->iv.len, plaintext_len, ciphertext_buffer);
4310 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
4311 tdata->iv.len, plaintext_len, ciphertext_buffer);
4314 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4317 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4319 tdata->ciphertext.data,
4320 tdata->validCipherLenInBits.len,
4321 "ZUC Ciphertext data not as expected");
4327 test_zuc_authentication(const struct wireless_test_data *tdata)
4329 struct crypto_testsuite_params *ts_params = &testsuite_params;
4330 struct crypto_unittest_params *ut_params = &unittest_params;
4333 unsigned plaintext_pad_len;
4334 unsigned plaintext_len;
4337 struct rte_cryptodev_sym_capability_idx cap_idx;
4339 /* Check if device supports ZUC EIA3 */
4340 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4341 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4343 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4347 /* Create ZUC session */
4348 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
4349 tdata->key.data, tdata->key.len,
4350 tdata->aad.len, tdata->digest.len,
4351 RTE_CRYPTO_AUTH_OP_GENERATE,
4352 RTE_CRYPTO_AUTH_ZUC_EIA3);
4356 /* alloc mbuf and set payload */
4357 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4359 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4360 rte_pktmbuf_tailroom(ut_params->ibuf));
4362 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4363 /* Append data which is padded to a multiple of */
4364 /* the algorithms block size */
4365 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4366 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4368 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4370 /* Create ZUC operation */
4371 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
4372 tdata->aad.data, tdata->aad.len,
4373 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4374 RTE_CRYPTO_AUTH_ZUC_EIA3,
4375 tdata->validAuthLenInBits.len,
4376 (tdata->aad.len << 3));
4380 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4382 ut_params->obuf = ut_params->op->sym->m_src;
4383 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4384 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4385 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
4388 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4391 DIGEST_BYTE_LENGTH_KASUMI_F9,
4392 "ZUC Generated auth tag not as expected");
4398 test_kasumi_encryption_test_case_1(void)
4400 return test_kasumi_encryption(&kasumi_test_case_1);
4404 test_kasumi_encryption_test_case_1_sgl(void)
4406 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
4410 test_kasumi_encryption_test_case_1_oop(void)
4412 return test_kasumi_encryption_oop(&kasumi_test_case_1);
4416 test_kasumi_encryption_test_case_1_oop_sgl(void)
4418 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
4422 test_kasumi_encryption_test_case_2(void)
4424 return test_kasumi_encryption(&kasumi_test_case_2);
4428 test_kasumi_encryption_test_case_3(void)
4430 return test_kasumi_encryption(&kasumi_test_case_3);
4434 test_kasumi_encryption_test_case_4(void)
4436 return test_kasumi_encryption(&kasumi_test_case_4);
4440 test_kasumi_encryption_test_case_5(void)
4442 return test_kasumi_encryption(&kasumi_test_case_5);
4446 test_kasumi_decryption_test_case_1(void)
4448 return test_kasumi_decryption(&kasumi_test_case_1);
4452 test_kasumi_decryption_test_case_1_oop(void)
4454 return test_kasumi_decryption_oop(&kasumi_test_case_1);
4458 test_kasumi_decryption_test_case_2(void)
4460 return test_kasumi_decryption(&kasumi_test_case_2);
4464 test_kasumi_decryption_test_case_3(void)
4466 return test_kasumi_decryption(&kasumi_test_case_3);
4470 test_kasumi_decryption_test_case_4(void)
4472 return test_kasumi_decryption(&kasumi_test_case_4);
4476 test_kasumi_decryption_test_case_5(void)
4478 return test_kasumi_decryption(&kasumi_test_case_5);
4481 test_snow3g_encryption_test_case_1(void)
4483 return test_snow3g_encryption(&snow3g_test_case_1);
4487 test_snow3g_encryption_test_case_1_oop(void)
4489 return test_snow3g_encryption_oop(&snow3g_test_case_1);
4493 test_snow3g_encryption_test_case_1_oop_sgl(void)
4495 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
4500 test_snow3g_encryption_test_case_1_offset_oop(void)
4502 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
4506 test_snow3g_encryption_test_case_2(void)
4508 return test_snow3g_encryption(&snow3g_test_case_2);
4512 test_snow3g_encryption_test_case_3(void)
4514 return test_snow3g_encryption(&snow3g_test_case_3);
4518 test_snow3g_encryption_test_case_4(void)
4520 return test_snow3g_encryption(&snow3g_test_case_4);
4524 test_snow3g_encryption_test_case_5(void)
4526 return test_snow3g_encryption(&snow3g_test_case_5);
4530 test_snow3g_decryption_test_case_1(void)
4532 return test_snow3g_decryption(&snow3g_test_case_1);
4536 test_snow3g_decryption_test_case_1_oop(void)
4538 return test_snow3g_decryption_oop(&snow3g_test_case_1);
4542 test_snow3g_decryption_test_case_2(void)
4544 return test_snow3g_decryption(&snow3g_test_case_2);
4548 test_snow3g_decryption_test_case_3(void)
4550 return test_snow3g_decryption(&snow3g_test_case_3);
4554 test_snow3g_decryption_test_case_4(void)
4556 return test_snow3g_decryption(&snow3g_test_case_4);
4560 test_snow3g_decryption_test_case_5(void)
4562 return test_snow3g_decryption(&snow3g_test_case_5);
4565 test_snow3g_cipher_auth_test_case_1(void)
4567 return test_snow3g_cipher_auth(&snow3g_test_case_3);
4571 test_snow3g_auth_cipher_test_case_1(void)
4573 return test_snow3g_auth_cipher(&snow3g_test_case_6);
4577 test_kasumi_auth_cipher_test_case_1(void)
4579 return test_kasumi_auth_cipher(&kasumi_test_case_3);
4583 test_kasumi_cipher_auth_test_case_1(void)
4585 return test_kasumi_cipher_auth(&kasumi_test_case_6);
4589 test_zuc_encryption_test_case_1(void)
4591 return test_zuc_encryption(&zuc_test_case_cipher_193b);
4595 test_zuc_encryption_test_case_2(void)
4597 return test_zuc_encryption(&zuc_test_case_cipher_800b);
4601 test_zuc_encryption_test_case_3(void)
4603 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
4607 test_zuc_encryption_test_case_4(void)
4609 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
4613 test_zuc_encryption_test_case_5(void)
4615 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
4619 test_zuc_encryption_test_case_6_sgl(void)
4621 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
4625 test_zuc_hash_generate_test_case_1(void)
4627 return test_zuc_authentication(&zuc_test_case_auth_1b);
4631 test_zuc_hash_generate_test_case_2(void)
4633 return test_zuc_authentication(&zuc_test_case_auth_90b);
4637 test_zuc_hash_generate_test_case_3(void)
4639 return test_zuc_authentication(&zuc_test_case_auth_577b);
4643 test_zuc_hash_generate_test_case_4(void)
4645 return test_zuc_authentication(&zuc_test_case_auth_2079b);
4649 test_zuc_hash_generate_test_case_5(void)
4651 return test_zuc_authentication(&zuc_test_auth_5670b);
4655 test_zuc_hash_generate_test_case_6(void)
4657 return test_zuc_authentication(&zuc_test_case_auth_128b);
4661 test_zuc_hash_generate_test_case_7(void)
4663 return test_zuc_authentication(&zuc_test_case_auth_2080b);
4667 test_zuc_hash_generate_test_case_8(void)
4669 return test_zuc_authentication(&zuc_test_case_auth_584b);
4673 test_zuc_cipher_auth_test_case_1(void)
4675 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
4679 test_zuc_cipher_auth_test_case_2(void)
4681 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
4685 test_3DES_chain_qat_all(void)
4687 struct crypto_testsuite_params *ts_params = &testsuite_params;
4690 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4691 ts_params->op_mpool, ts_params->valid_devs[0],
4692 RTE_CRYPTODEV_QAT_SYM_PMD,
4693 BLKCIPHER_3DES_CHAIN_TYPE);
4695 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4697 return TEST_SUCCESS;
4701 test_DES_cipheronly_qat_all(void)
4703 struct crypto_testsuite_params *ts_params = &testsuite_params;
4706 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4707 ts_params->op_mpool, ts_params->valid_devs[0],
4708 RTE_CRYPTODEV_QAT_SYM_PMD,
4709 BLKCIPHER_DES_CIPHERONLY_TYPE);
4711 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4713 return TEST_SUCCESS;
4717 test_DES_docsis_openssl_all(void)
4719 struct crypto_testsuite_params *ts_params = &testsuite_params;
4722 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4723 ts_params->op_mpool, ts_params->valid_devs[0],
4724 RTE_CRYPTODEV_OPENSSL_PMD,
4725 BLKCIPHER_DES_DOCSIS_TYPE);
4727 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4729 return TEST_SUCCESS;
4733 test_3DES_chain_dpaa2_sec_all(void)
4735 struct crypto_testsuite_params *ts_params = &testsuite_params;
4738 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4739 ts_params->op_mpool, ts_params->valid_devs[0],
4740 RTE_CRYPTODEV_DPAA2_SEC_PMD,
4741 BLKCIPHER_3DES_CHAIN_TYPE);
4743 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4745 return TEST_SUCCESS;
4749 test_3DES_cipheronly_dpaa2_sec_all(void)
4751 struct crypto_testsuite_params *ts_params = &testsuite_params;
4754 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4755 ts_params->op_mpool, ts_params->valid_devs[0],
4756 RTE_CRYPTODEV_DPAA2_SEC_PMD,
4757 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4759 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4761 return TEST_SUCCESS;
4765 test_3DES_cipheronly_qat_all(void)
4767 struct crypto_testsuite_params *ts_params = &testsuite_params;
4770 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4771 ts_params->op_mpool, ts_params->valid_devs[0],
4772 RTE_CRYPTODEV_QAT_SYM_PMD,
4773 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4775 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4777 return TEST_SUCCESS;
4781 test_3DES_chain_openssl_all(void)
4783 struct crypto_testsuite_params *ts_params = &testsuite_params;
4786 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4787 ts_params->op_mpool, ts_params->valid_devs[0],
4788 RTE_CRYPTODEV_OPENSSL_PMD,
4789 BLKCIPHER_3DES_CHAIN_TYPE);
4791 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4793 return TEST_SUCCESS;
4797 test_3DES_cipheronly_openssl_all(void)
4799 struct crypto_testsuite_params *ts_params = &testsuite_params;
4802 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4803 ts_params->op_mpool, ts_params->valid_devs[0],
4804 RTE_CRYPTODEV_OPENSSL_PMD,
4805 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4807 TEST_ASSERT_EQUAL(status, 0, "Test failed");
4809 return TEST_SUCCESS;
4812 /* ***** AES-GCM Tests ***** */
4815 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
4816 const uint8_t *key, const uint8_t key_len,
4817 const uint8_t aad_len, const uint8_t auth_len,
4818 enum rte_crypto_auth_operation auth_op)
4820 uint8_t cipher_key[key_len];
4822 struct crypto_unittest_params *ut_params = &unittest_params;
4824 memcpy(cipher_key, key, key_len);
4826 /* Setup Cipher Parameters */
4827 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4828 ut_params->cipher_xform.next = NULL;
4830 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4831 ut_params->auth_xform.auth.op = auth_op;
4832 ut_params->cipher_xform.cipher.op = op;
4833 ut_params->cipher_xform.cipher.key.data = cipher_key;
4834 ut_params->cipher_xform.cipher.key.length = key_len;
4836 TEST_HEXDUMP(stdout, "key:", key, key_len);
4838 /* Setup Authentication Parameters */
4839 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4840 ut_params->auth_xform.next = NULL;
4842 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4844 ut_params->auth_xform.auth.digest_length = auth_len;
4845 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
4846 ut_params->auth_xform.auth.key.length = 0;
4847 ut_params->auth_xform.auth.key.data = NULL;
4849 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4850 ut_params->cipher_xform.next = &ut_params->auth_xform;
4852 /* Create Crypto session*/
4853 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4854 &ut_params->cipher_xform);
4855 } else {/* Create Crypto session*/
4856 ut_params->auth_xform.next = &ut_params->cipher_xform;
4857 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4858 &ut_params->auth_xform);
4861 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4867 create_gcm_xforms(struct rte_crypto_op *op,
4868 enum rte_crypto_cipher_operation cipher_op,
4869 uint8_t *key, const uint8_t key_len,
4870 const uint8_t aad_len, const uint8_t auth_len,
4871 enum rte_crypto_auth_operation auth_op)
4873 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2),
4874 "failed to allocate space for crypto transforms");
4876 struct rte_crypto_sym_op *sym_op = op->sym;
4878 /* Setup Cipher Parameters */
4879 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4880 sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4881 sym_op->xform->cipher.op = cipher_op;
4882 sym_op->xform->cipher.key.data = key;
4883 sym_op->xform->cipher.key.length = key_len;
4885 TEST_HEXDUMP(stdout, "key:", key, key_len);
4887 /* Setup Authentication Parameters */
4888 sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
4889 sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4890 sym_op->xform->next->auth.op = auth_op;
4891 sym_op->xform->next->auth.digest_length = auth_len;
4892 sym_op->xform->next->auth.add_auth_data_length = aad_len;
4893 sym_op->xform->next->auth.key.length = 0;
4894 sym_op->xform->next->auth.key.data = NULL;
4895 sym_op->xform->next->next = NULL;
4901 create_gcm_operation(enum rte_crypto_cipher_operation op,
4902 const struct gcm_test_data *tdata)
4904 struct crypto_testsuite_params *ts_params = &testsuite_params;
4905 struct crypto_unittest_params *ut_params = &unittest_params;
4907 uint8_t *plaintext, *ciphertext;
4908 unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len;
4910 /* Generate Crypto op data structure */
4911 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4912 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4913 TEST_ASSERT_NOT_NULL(ut_params->op,
4914 "Failed to allocate symmetric crypto operation struct");
4916 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4918 /* Append aad data */
4919 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
4920 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4922 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
4923 "no room to append aad");
4925 sym_op->auth.aad.length = tdata->aad.len;
4926 sym_op->auth.aad.phys_addr =
4927 rte_pktmbuf_mtophys(ut_params->ibuf);
4928 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
4929 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
4930 sym_op->auth.aad.length);
4933 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
4934 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
4935 ut_params->ibuf, iv_pad_len);
4936 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
4938 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
4939 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
4940 sym_op->cipher.iv.length = tdata->iv.len;
4942 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
4943 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data,
4944 sym_op->cipher.iv.length);
4946 /* Append plaintext/ciphertext */
4947 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4948 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4949 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4951 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
4953 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4954 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
4955 tdata->plaintext.len);
4957 if (ut_params->obuf) {
4958 ciphertext = (uint8_t *)rte_pktmbuf_append(
4960 plaintext_pad_len + aad_pad_len +
4962 TEST_ASSERT_NOT_NULL(ciphertext,
4963 "no room to append ciphertext");
4965 memset(ciphertext + aad_pad_len + iv_pad_len, 0,
4966 tdata->ciphertext.len);
4969 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4970 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4972 TEST_ASSERT_NOT_NULL(ciphertext,
4973 "no room to append ciphertext");
4975 memcpy(ciphertext, tdata->ciphertext.data,
4976 tdata->ciphertext.len);
4977 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
4978 tdata->ciphertext.len);
4980 if (ut_params->obuf) {
4981 plaintext = (uint8_t *)rte_pktmbuf_append(
4983 plaintext_pad_len + aad_pad_len +
4985 TEST_ASSERT_NOT_NULL(plaintext,
4986 "no room to append plaintext");
4988 memset(plaintext + aad_pad_len + iv_pad_len, 0,
4989 tdata->plaintext.len);
4993 /* Append digest data */
4994 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4995 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4996 ut_params->obuf ? ut_params->obuf :
4998 tdata->auth_tag.len);
4999 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5000 "no room to append digest");
5001 memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len);
5002 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5003 ut_params->obuf ? ut_params->obuf :
5006 aad_pad_len + iv_pad_len);
5007 sym_op->auth.digest.length = tdata->auth_tag.len;
5009 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5010 ut_params->ibuf, tdata->auth_tag.len);
5011 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5012 "no room to append digest");
5013 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5015 plaintext_pad_len + aad_pad_len + iv_pad_len);
5016 sym_op->auth.digest.length = tdata->auth_tag.len;
5018 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
5019 tdata->auth_tag.len);
5020 TEST_HEXDUMP(stdout, "digest:",
5021 sym_op->auth.digest.data,
5022 sym_op->auth.digest.length);
5025 sym_op->cipher.data.length = tdata->plaintext.len;
5026 sym_op->cipher.data.offset = aad_pad_len + iv_pad_len;
5028 sym_op->auth.data.length = tdata->plaintext.len;
5029 sym_op->auth.data.offset = aad_pad_len + iv_pad_len;
5035 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
5037 struct crypto_testsuite_params *ts_params = &testsuite_params;
5038 struct crypto_unittest_params *ut_params = &unittest_params;
5041 uint8_t *ciphertext, *auth_tag;
5042 uint16_t plaintext_pad_len;
5045 /* Create GCM session */
5046 retval = create_gcm_session(ts_params->valid_devs[0],
5047 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5048 tdata->key.data, tdata->key.len,
5049 tdata->aad.len, tdata->auth_tag.len,
5050 RTE_CRYPTO_AUTH_OP_GENERATE);
5054 if (tdata->aad.len > MBUF_SIZE) {
5055 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5056 /* Populate full size of add data */
5057 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5058 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5060 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5062 /* clear mbuf payload */
5063 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5064 rte_pktmbuf_tailroom(ut_params->ibuf));
5066 /* Create GCM operation */
5067 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5071 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5073 ut_params->op->sym->m_src = ut_params->ibuf;
5075 /* Process crypto operation */
5076 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5077 ut_params->op), "failed to process sym crypto op");
5079 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5080 "crypto op processing failed");
5082 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5084 if (ut_params->op->sym->m_dst) {
5085 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5087 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5088 uint8_t *, plaintext_pad_len);
5090 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5092 ut_params->op->sym->cipher.data.offset);
5093 auth_tag = ciphertext + plaintext_pad_len;
5096 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5097 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5100 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5102 tdata->ciphertext.data,
5103 tdata->ciphertext.len,
5104 "GCM Ciphertext data not as expected");
5106 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5108 tdata->auth_tag.data,
5109 tdata->auth_tag.len,
5110 "GCM Generated auth tag not as expected");
5117 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
5119 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
5123 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
5125 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
5129 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
5131 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
5135 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
5137 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
5141 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
5143 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
5147 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
5149 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
5153 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
5155 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
5159 test_mb_AES_GCM_auth_encryption_test_case_256_1(void)
5161 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
5165 test_mb_AES_GCM_auth_encryption_test_case_256_2(void)
5167 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
5171 test_mb_AES_GCM_auth_encryption_test_case_256_3(void)
5173 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
5177 test_mb_AES_GCM_auth_encryption_test_case_256_4(void)
5179 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
5183 test_mb_AES_GCM_auth_encryption_test_case_256_5(void)
5185 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
5189 test_mb_AES_GCM_auth_encryption_test_case_256_6(void)
5191 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
5195 test_mb_AES_GCM_auth_encryption_test_case_256_7(void)
5197 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
5201 test_mb_AES_GCM_auth_encryption_test_case_aad_1(void)
5203 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
5207 test_mb_AES_GCM_auth_encryption_test_case_aad_2(void)
5209 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
5213 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
5215 struct crypto_testsuite_params *ts_params = &testsuite_params;
5216 struct crypto_unittest_params *ut_params = &unittest_params;
5222 /* Create GCM session */
5223 retval = create_gcm_session(ts_params->valid_devs[0],
5224 RTE_CRYPTO_CIPHER_OP_DECRYPT,
5225 tdata->key.data, tdata->key.len,
5226 tdata->aad.len, tdata->auth_tag.len,
5227 RTE_CRYPTO_AUTH_OP_VERIFY);
5231 /* alloc mbuf and set payload */
5232 if (tdata->aad.len > MBUF_SIZE) {
5233 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5234 /* Populate full size of add data */
5235 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5236 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5238 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5240 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5241 rte_pktmbuf_tailroom(ut_params->ibuf));
5243 /* Create GCM operation */
5244 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5248 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5250 ut_params->op->sym->m_src = ut_params->ibuf;
5252 /* Process crypto operation */
5253 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5254 ut_params->op), "failed to process sym crypto op");
5256 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5257 "crypto op processing failed");
5259 if (ut_params->op->sym->m_dst)
5260 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5263 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5265 ut_params->op->sym->cipher.data.offset);
5267 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5270 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5272 tdata->plaintext.data,
5273 tdata->plaintext.len,
5274 "GCM plaintext data not as expected");
5276 TEST_ASSERT_EQUAL(ut_params->op->status,
5277 RTE_CRYPTO_OP_STATUS_SUCCESS,
5278 "GCM authentication failed");
5283 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
5285 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
5289 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
5291 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
5295 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
5297 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
5301 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
5303 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
5307 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
5309 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
5313 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
5315 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
5319 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
5321 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
5325 test_mb_AES_GCM_auth_decryption_test_case_256_1(void)
5327 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
5331 test_mb_AES_GCM_auth_decryption_test_case_256_2(void)
5333 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
5337 test_mb_AES_GCM_auth_decryption_test_case_256_3(void)
5339 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
5343 test_mb_AES_GCM_auth_decryption_test_case_256_4(void)
5345 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
5349 test_mb_AES_GCM_auth_decryption_test_case_256_5(void)
5351 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
5355 test_mb_AES_GCM_auth_decryption_test_case_256_6(void)
5357 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
5361 test_mb_AES_GCM_auth_decryption_test_case_256_7(void)
5363 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
5367 test_mb_AES_GCM_auth_decryption_test_case_aad_1(void)
5369 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
5373 test_mb_AES_GCM_auth_decryption_test_case_aad_2(void)
5375 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
5379 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
5381 struct crypto_testsuite_params *ts_params = &testsuite_params;
5382 struct crypto_unittest_params *ut_params = &unittest_params;
5385 uint8_t *ciphertext, *auth_tag;
5386 uint16_t plaintext_pad_len;
5388 /* Create GCM session */
5389 retval = create_gcm_session(ts_params->valid_devs[0],
5390 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5391 tdata->key.data, tdata->key.len,
5392 tdata->aad.len, tdata->auth_tag.len,
5393 RTE_CRYPTO_AUTH_OP_GENERATE);
5397 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5398 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5400 /* clear mbuf payload */
5401 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5402 rte_pktmbuf_tailroom(ut_params->ibuf));
5403 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5404 rte_pktmbuf_tailroom(ut_params->obuf));
5406 /* Create GCM operation */
5407 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5411 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5413 ut_params->op->sym->m_src = ut_params->ibuf;
5414 ut_params->op->sym->m_dst = ut_params->obuf;
5416 /* Process crypto operation */
5417 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5418 ut_params->op), "failed to process sym crypto op");
5420 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5421 "crypto op processing failed");
5423 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5425 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5426 ut_params->op->sym->cipher.data.offset);
5427 auth_tag = ciphertext + plaintext_pad_len;
5429 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5430 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5433 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5435 tdata->ciphertext.data,
5436 tdata->ciphertext.len,
5437 "GCM Ciphertext data not as expected");
5439 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5441 tdata->auth_tag.data,
5442 tdata->auth_tag.len,
5443 "GCM Generated auth tag not as expected");
5450 test_mb_AES_GCM_authenticated_encryption_oop(void)
5452 return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
5456 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
5458 struct crypto_testsuite_params *ts_params = &testsuite_params;
5459 struct crypto_unittest_params *ut_params = &unittest_params;
5464 /* Create GCM session */
5465 retval = create_gcm_session(ts_params->valid_devs[0],
5466 RTE_CRYPTO_CIPHER_OP_DECRYPT,
5467 tdata->key.data, tdata->key.len,
5468 tdata->aad.len, tdata->auth_tag.len,
5469 RTE_CRYPTO_AUTH_OP_VERIFY);
5473 /* alloc mbuf and set payload */
5474 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5475 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5477 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5478 rte_pktmbuf_tailroom(ut_params->ibuf));
5479 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5480 rte_pktmbuf_tailroom(ut_params->obuf));
5482 /* Create GCM operation */
5483 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5487 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5489 ut_params->op->sym->m_src = ut_params->ibuf;
5490 ut_params->op->sym->m_dst = ut_params->obuf;
5492 /* Process crypto operation */
5493 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5494 ut_params->op), "failed to process sym crypto op");
5496 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5497 "crypto op processing failed");
5499 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5500 ut_params->op->sym->cipher.data.offset);
5502 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5505 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5507 tdata->plaintext.data,
5508 tdata->plaintext.len,
5509 "GCM plaintext data not as expected");
5511 TEST_ASSERT_EQUAL(ut_params->op->status,
5512 RTE_CRYPTO_OP_STATUS_SUCCESS,
5513 "GCM authentication failed");
5518 test_mb_AES_GCM_authenticated_decryption_oop(void)
5520 return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
5524 test_AES_GCM_authenticated_encryption_sessionless(
5525 const struct gcm_test_data *tdata)
5527 struct crypto_testsuite_params *ts_params = &testsuite_params;
5528 struct crypto_unittest_params *ut_params = &unittest_params;
5531 uint8_t *ciphertext, *auth_tag;
5532 uint16_t plaintext_pad_len;
5533 uint8_t key[tdata->key.len + 1];
5535 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5537 /* clear mbuf payload */
5538 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5539 rte_pktmbuf_tailroom(ut_params->ibuf));
5541 /* Create GCM operation */
5542 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5546 /* Create GCM xforms */
5547 memcpy(key, tdata->key.data, tdata->key.len);
5548 retval = create_gcm_xforms(ut_params->op,
5549 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5550 key, tdata->key.len,
5551 tdata->aad.len, tdata->auth_tag.len,
5552 RTE_CRYPTO_AUTH_OP_GENERATE);
5556 ut_params->op->sym->m_src = ut_params->ibuf;
5558 TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5559 RTE_CRYPTO_SYM_OP_SESSIONLESS,
5560 "crypto op session type not sessionless");
5562 /* Process crypto operation */
5563 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5564 ut_params->op), "failed to process sym crypto op");
5566 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5568 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5569 "crypto op status not success");
5571 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5573 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5574 ut_params->op->sym->cipher.data.offset);
5575 auth_tag = ciphertext + plaintext_pad_len;
5577 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5578 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5581 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5583 tdata->ciphertext.data,
5584 tdata->ciphertext.len,
5585 "GCM Ciphertext data not as expected");
5587 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5589 tdata->auth_tag.data,
5590 tdata->auth_tag.len,
5591 "GCM Generated auth tag not as expected");
5598 test_mb_AES_GCM_authenticated_encryption_sessionless(void)
5600 return test_AES_GCM_authenticated_encryption_sessionless(
5605 test_AES_GCM_authenticated_decryption_sessionless(
5606 const struct gcm_test_data *tdata)
5608 struct crypto_testsuite_params *ts_params = &testsuite_params;
5609 struct crypto_unittest_params *ut_params = &unittest_params;
5613 uint8_t key[tdata->key.len + 1];
5615 /* alloc mbuf and set payload */
5616 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5618 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5619 rte_pktmbuf_tailroom(ut_params->ibuf));
5621 /* Create GCM operation */
5622 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5626 /* Create GCM xforms */
5627 memcpy(key, tdata->key.data, tdata->key.len);
5628 retval = create_gcm_xforms(ut_params->op,
5629 RTE_CRYPTO_CIPHER_OP_DECRYPT,
5630 key, tdata->key.len,
5631 tdata->aad.len, tdata->auth_tag.len,
5632 RTE_CRYPTO_AUTH_OP_VERIFY);
5636 ut_params->op->sym->m_src = ut_params->ibuf;
5638 TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5639 RTE_CRYPTO_SYM_OP_SESSIONLESS,
5640 "crypto op session type not sessionless");
5642 /* Process crypto operation */
5643 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5644 ut_params->op), "failed to process sym crypto op");
5646 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5648 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5649 "crypto op status not success");
5651 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5652 ut_params->op->sym->cipher.data.offset);
5654 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5657 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5659 tdata->plaintext.data,
5660 tdata->plaintext.len,
5661 "GCM plaintext data not as expected");
5663 TEST_ASSERT_EQUAL(ut_params->op->status,
5664 RTE_CRYPTO_OP_STATUS_SUCCESS,
5665 "GCM authentication failed");
5670 test_mb_AES_GCM_authenticated_decryption_sessionless(void)
5672 return test_AES_GCM_authenticated_decryption_sessionless(
5679 struct crypto_testsuite_params *ts_params = &testsuite_params;
5680 struct rte_cryptodev_stats stats;
5681 struct rte_cryptodev *dev;
5682 cryptodev_stats_get_t temp_pfn;
5684 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5685 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
5686 &stats) == -ENODEV),
5687 "rte_cryptodev_stats_get invalid dev failed");
5688 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
5689 "rte_cryptodev_stats_get invalid Param failed");
5690 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
5691 temp_pfn = dev->dev_ops->stats_get;
5692 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
5693 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
5695 "rte_cryptodev_stats_get invalid Param failed");
5696 dev->dev_ops->stats_get = temp_pfn;
5698 /* Test expected values */
5700 test_AES_CBC_HMAC_SHA1_encrypt_digest();
5702 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5704 "rte_cryptodev_stats_get failed");
5705 TEST_ASSERT((stats.enqueued_count == 1),
5706 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5707 TEST_ASSERT((stats.dequeued_count == 1),
5708 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5709 TEST_ASSERT((stats.enqueue_err_count == 0),
5710 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5711 TEST_ASSERT((stats.dequeue_err_count == 0),
5712 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5714 /* invalid device but should ignore and not reset device stats*/
5715 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
5716 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5718 "rte_cryptodev_stats_get failed");
5719 TEST_ASSERT((stats.enqueued_count == 1),
5720 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5722 /* check that a valid reset clears stats */
5723 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5724 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5726 "rte_cryptodev_stats_get failed");
5727 TEST_ASSERT((stats.enqueued_count == 0),
5728 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5729 TEST_ASSERT((stats.dequeued_count == 0),
5730 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5732 return TEST_SUCCESS;
5735 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
5736 struct crypto_unittest_params *ut_params,
5737 enum rte_crypto_auth_operation op,
5738 const struct HMAC_MD5_vector *test_case)
5742 memcpy(key, test_case->key.data, test_case->key.len);
5744 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5745 ut_params->auth_xform.next = NULL;
5746 ut_params->auth_xform.auth.op = op;
5748 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
5750 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
5751 ut_params->auth_xform.auth.add_auth_data_length = 0;
5752 ut_params->auth_xform.auth.key.length = test_case->key.len;
5753 ut_params->auth_xform.auth.key.data = key;
5755 ut_params->sess = rte_cryptodev_sym_session_create(
5756 ts_params->valid_devs[0], &ut_params->auth_xform);
5758 if (ut_params->sess == NULL)
5761 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5763 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5764 rte_pktmbuf_tailroom(ut_params->ibuf));
5769 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
5770 const struct HMAC_MD5_vector *test_case,
5771 uint8_t **plaintext)
5773 uint16_t plaintext_pad_len;
5775 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5777 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5780 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5782 memcpy(*plaintext, test_case->plaintext.data,
5783 test_case->plaintext.len);
5785 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5786 ut_params->ibuf, MD5_DIGEST_LEN);
5787 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5788 "no room to append digest");
5789 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5790 ut_params->ibuf, plaintext_pad_len);
5791 sym_op->auth.digest.length = MD5_DIGEST_LEN;
5793 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5794 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
5795 test_case->auth_tag.len);
5798 sym_op->auth.data.offset = 0;
5799 sym_op->auth.data.length = test_case->plaintext.len;
5801 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5802 ut_params->op->sym->m_src = ut_params->ibuf;
5808 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
5810 uint16_t plaintext_pad_len;
5811 uint8_t *plaintext, *auth_tag;
5813 struct crypto_testsuite_params *ts_params = &testsuite_params;
5814 struct crypto_unittest_params *ut_params = &unittest_params;
5816 if (MD5_HMAC_create_session(ts_params, ut_params,
5817 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
5820 /* Generate Crypto op data structure */
5821 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5822 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5823 TEST_ASSERT_NOT_NULL(ut_params->op,
5824 "Failed to allocate symmetric crypto operation struct");
5826 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5829 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5832 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5833 ut_params->op), "failed to process sym crypto op");
5835 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5836 "crypto op processing failed");
5838 if (ut_params->op->sym->m_dst) {
5839 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5840 uint8_t *, plaintext_pad_len);
5842 auth_tag = plaintext + plaintext_pad_len;
5845 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5847 test_case->auth_tag.data,
5848 test_case->auth_tag.len,
5849 "HMAC_MD5 generated tag not as expected");
5851 return TEST_SUCCESS;
5855 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
5859 struct crypto_testsuite_params *ts_params = &testsuite_params;
5860 struct crypto_unittest_params *ut_params = &unittest_params;
5862 if (MD5_HMAC_create_session(ts_params, ut_params,
5863 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
5867 /* Generate Crypto op data structure */
5868 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5869 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5870 TEST_ASSERT_NOT_NULL(ut_params->op,
5871 "Failed to allocate symmetric crypto operation struct");
5873 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5876 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5877 ut_params->op), "failed to process sym crypto op");
5879 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5880 "HMAC_MD5 crypto op processing failed");
5882 return TEST_SUCCESS;
5886 test_MD5_HMAC_generate_case_1(void)
5888 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
5892 test_MD5_HMAC_verify_case_1(void)
5894 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
5898 test_MD5_HMAC_generate_case_2(void)
5900 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
5904 test_MD5_HMAC_verify_case_2(void)
5906 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
5910 test_multi_session(void)
5912 struct crypto_testsuite_params *ts_params = &testsuite_params;
5913 struct crypto_unittest_params *ut_params = &unittest_params;
5915 struct rte_cryptodev_info dev_info;
5916 struct rte_cryptodev_sym_session **sessions;
5920 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
5921 aes_cbc_key, hmac_sha512_key);
5924 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5926 sessions = rte_malloc(NULL,
5927 (sizeof(struct rte_cryptodev_sym_session *) *
5928 dev_info.sym.max_nb_sessions) + 1, 0);
5930 /* Create multiple crypto sessions*/
5931 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
5932 sessions[i] = rte_cryptodev_sym_session_create(
5933 ts_params->valid_devs[0],
5934 &ut_params->auth_xform);
5935 TEST_ASSERT_NOT_NULL(sessions[i],
5936 "Session creation failed at session number %u",
5939 /* Attempt to send a request on each session */
5940 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
5944 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
5945 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
5947 "Failed to perform decrypt on request number %u.", i);
5948 /* free crypto operation structure */
5950 rte_crypto_op_free(ut_params->op);
5953 * free mbuf - both obuf and ibuf are usually the same,
5954 * so check if they point at the same address is necessary,
5955 * to avoid freeing the mbuf twice.
5957 if (ut_params->obuf) {
5958 rte_pktmbuf_free(ut_params->obuf);
5959 if (ut_params->ibuf == ut_params->obuf)
5960 ut_params->ibuf = 0;
5961 ut_params->obuf = 0;
5963 if (ut_params->ibuf) {
5964 rte_pktmbuf_free(ut_params->ibuf);
5965 ut_params->ibuf = 0;
5969 /* Next session create should fail */
5970 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
5971 &ut_params->auth_xform);
5972 TEST_ASSERT_NULL(sessions[i],
5973 "Session creation succeeded unexpectedly!");
5975 for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
5976 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
5981 return TEST_SUCCESS;
5984 struct multi_session_params {
5985 struct crypto_unittest_params ut_params;
5986 uint8_t *cipher_key;
5988 const uint8_t *cipher;
5989 const uint8_t *digest;
5993 #define MB_SESSION_NUMBER 3
5996 test_multi_session_random_usage(void)
5998 struct crypto_testsuite_params *ts_params = &testsuite_params;
5999 struct rte_cryptodev_info dev_info;
6000 struct rte_cryptodev_sym_session **sessions;
6002 struct multi_session_params ut_paramz[] = {
6005 .cipher_key = ms_aes_cbc_key0,
6006 .hmac_key = ms_hmac_key0,
6007 .cipher = ms_aes_cbc_cipher0,
6008 .digest = ms_hmac_digest0,
6009 .iv = ms_aes_cbc_iv0
6012 .cipher_key = ms_aes_cbc_key1,
6013 .hmac_key = ms_hmac_key1,
6014 .cipher = ms_aes_cbc_cipher1,
6015 .digest = ms_hmac_digest1,
6016 .iv = ms_aes_cbc_iv1
6019 .cipher_key = ms_aes_cbc_key2,
6020 .hmac_key = ms_hmac_key2,
6021 .cipher = ms_aes_cbc_cipher2,
6022 .digest = ms_hmac_digest2,
6023 .iv = ms_aes_cbc_iv2
6028 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6030 sessions = rte_malloc(NULL,
6031 (sizeof(struct rte_cryptodev_sym_session *)
6032 * dev_info.sym.max_nb_sessions) + 1, 0);
6034 for (i = 0; i < MB_SESSION_NUMBER; i++) {
6035 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
6036 sizeof(struct crypto_unittest_params));
6038 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
6039 &ut_paramz[i].ut_params,
6040 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
6042 /* Create multiple crypto sessions*/
6043 sessions[i] = rte_cryptodev_sym_session_create(
6044 ts_params->valid_devs[0],
6045 &ut_paramz[i].ut_params.auth_xform);
6047 TEST_ASSERT_NOT_NULL(sessions[i],
6048 "Session creation failed at session number %u",
6054 for (i = 0; i < 40000; i++) {
6056 j = rand() % MB_SESSION_NUMBER;
6058 TEST_ASSERT_SUCCESS(
6059 test_AES_CBC_HMAC_SHA512_decrypt_perform(
6061 &ut_paramz[j].ut_params,
6062 ts_params, ut_paramz[j].cipher,
6063 ut_paramz[j].digest,
6065 "Failed to perform decrypt on request number %u.", i);
6067 if (ut_paramz[j].ut_params.op)
6068 rte_crypto_op_free(ut_paramz[j].ut_params.op);
6071 * free mbuf - both obuf and ibuf are usually the same,
6072 * so check if they point at the same address is necessary,
6073 * to avoid freeing the mbuf twice.
6075 if (ut_paramz[j].ut_params.obuf) {
6076 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
6077 if (ut_paramz[j].ut_params.ibuf
6078 == ut_paramz[j].ut_params.obuf)
6079 ut_paramz[j].ut_params.ibuf = 0;
6080 ut_paramz[j].ut_params.obuf = 0;
6082 if (ut_paramz[j].ut_params.ibuf) {
6083 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
6084 ut_paramz[j].ut_params.ibuf = 0;
6088 for (i = 0; i < MB_SESSION_NUMBER; i++)
6089 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
6094 return TEST_SUCCESS;
6098 test_null_cipher_only_operation(void)
6100 struct crypto_testsuite_params *ts_params = &testsuite_params;
6101 struct crypto_unittest_params *ut_params = &unittest_params;
6103 /* Generate test mbuf data and space for digest */
6104 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6105 catch_22_quote, QUOTE_512_BYTES, 0);
6107 /* Setup Cipher Parameters */
6108 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6109 ut_params->cipher_xform.next = NULL;
6111 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6112 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6114 /* Create Crypto session*/
6115 ut_params->sess = rte_cryptodev_sym_session_create(
6116 ts_params->valid_devs[0], &ut_params->cipher_xform);
6117 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6119 /* Generate Crypto op data structure */
6120 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6121 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6122 TEST_ASSERT_NOT_NULL(ut_params->op,
6123 "Failed to allocate symmetric crypto operation struct");
6125 /* Set crypto operation data parameters */
6126 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6128 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6130 /* set crypto operation source mbuf */
6131 sym_op->m_src = ut_params->ibuf;
6133 sym_op->cipher.data.offset = 0;
6134 sym_op->cipher.data.length = QUOTE_512_BYTES;
6136 /* Process crypto operation */
6137 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6139 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6141 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6142 "crypto operation processing failed");
6145 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6146 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6149 "Ciphertext data not as expected");
6151 return TEST_SUCCESS;
6155 test_null_auth_only_operation(void)
6157 struct crypto_testsuite_params *ts_params = &testsuite_params;
6158 struct crypto_unittest_params *ut_params = &unittest_params;
6160 /* Generate test mbuf data and space for digest */
6161 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6162 catch_22_quote, QUOTE_512_BYTES, 0);
6164 /* Setup HMAC Parameters */
6165 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6166 ut_params->auth_xform.next = NULL;
6168 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6169 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6171 /* Create Crypto session*/
6172 ut_params->sess = rte_cryptodev_sym_session_create(
6173 ts_params->valid_devs[0], &ut_params->auth_xform);
6174 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6176 /* Generate Crypto op data structure */
6177 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6178 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6179 TEST_ASSERT_NOT_NULL(ut_params->op,
6180 "Failed to allocate symmetric crypto operation struct");
6182 /* Set crypto operation data parameters */
6183 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6185 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6187 sym_op->m_src = ut_params->ibuf;
6189 sym_op->auth.data.offset = 0;
6190 sym_op->auth.data.length = QUOTE_512_BYTES;
6192 /* Process crypto operation */
6193 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6195 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6197 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6198 "crypto operation processing failed");
6200 return TEST_SUCCESS;
6204 test_null_cipher_auth_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 Cipher Parameters */
6214 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6215 ut_params->cipher_xform.next = &ut_params->auth_xform;
6217 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6218 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6220 /* Setup HMAC Parameters */
6221 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6222 ut_params->auth_xform.next = NULL;
6224 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6225 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6227 /* Create Crypto session*/
6228 ut_params->sess = rte_cryptodev_sym_session_create(
6229 ts_params->valid_devs[0], &ut_params->cipher_xform);
6230 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6232 /* Generate Crypto op data structure */
6233 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6234 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6235 TEST_ASSERT_NOT_NULL(ut_params->op,
6236 "Failed to allocate symmetric crypto operation struct");
6238 /* Set crypto operation data parameters */
6239 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6241 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6243 sym_op->m_src = ut_params->ibuf;
6245 sym_op->cipher.data.offset = 0;
6246 sym_op->cipher.data.length = QUOTE_512_BYTES;
6248 sym_op->auth.data.offset = 0;
6249 sym_op->auth.data.length = QUOTE_512_BYTES;
6251 /* Process crypto operation */
6252 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6254 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6256 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6257 "crypto operation processing failed");
6260 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6261 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6264 "Ciphertext data not as expected");
6266 return TEST_SUCCESS;
6270 test_null_auth_cipher_operation(void)
6272 struct crypto_testsuite_params *ts_params = &testsuite_params;
6273 struct crypto_unittest_params *ut_params = &unittest_params;
6275 /* Generate test mbuf data and space for digest */
6276 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6277 catch_22_quote, QUOTE_512_BYTES, 0);
6279 /* Setup Cipher Parameters */
6280 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6281 ut_params->cipher_xform.next = NULL;
6283 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6284 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6286 /* Setup HMAC Parameters */
6287 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6288 ut_params->auth_xform.next = &ut_params->cipher_xform;
6290 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6291 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6293 /* Create Crypto session*/
6294 ut_params->sess = rte_cryptodev_sym_session_create(
6295 ts_params->valid_devs[0], &ut_params->cipher_xform);
6296 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6298 /* Generate Crypto op data structure */
6299 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6300 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6301 TEST_ASSERT_NOT_NULL(ut_params->op,
6302 "Failed to allocate symmetric crypto operation struct");
6304 /* Set crypto operation data parameters */
6305 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6307 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6309 sym_op->m_src = ut_params->ibuf;
6311 sym_op->cipher.data.offset = 0;
6312 sym_op->cipher.data.length = QUOTE_512_BYTES;
6314 sym_op->auth.data.offset = 0;
6315 sym_op->auth.data.length = QUOTE_512_BYTES;
6317 /* Process crypto operation */
6318 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6320 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6322 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6323 "crypto operation processing failed");
6326 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6327 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6330 "Ciphertext data not as expected");
6332 return TEST_SUCCESS;
6337 test_null_invalid_operation(void)
6339 struct crypto_testsuite_params *ts_params = &testsuite_params;
6340 struct crypto_unittest_params *ut_params = &unittest_params;
6342 /* Setup Cipher Parameters */
6343 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6344 ut_params->cipher_xform.next = NULL;
6346 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
6347 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6349 /* Create Crypto session*/
6350 ut_params->sess = rte_cryptodev_sym_session_create(
6351 ts_params->valid_devs[0], &ut_params->cipher_xform);
6352 TEST_ASSERT_NULL(ut_params->sess,
6353 "Session creation succeeded unexpectedly");
6356 /* Setup HMAC Parameters */
6357 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6358 ut_params->auth_xform.next = NULL;
6360 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
6361 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6363 /* Create Crypto session*/
6364 ut_params->sess = rte_cryptodev_sym_session_create(
6365 ts_params->valid_devs[0], &ut_params->auth_xform);
6366 TEST_ASSERT_NULL(ut_params->sess,
6367 "Session creation succeeded unexpectedly");
6369 return TEST_SUCCESS;
6373 #define NULL_BURST_LENGTH (32)
6376 test_null_burst_operation(void)
6378 struct crypto_testsuite_params *ts_params = &testsuite_params;
6379 struct crypto_unittest_params *ut_params = &unittest_params;
6381 unsigned i, burst_len = NULL_BURST_LENGTH;
6383 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
6384 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
6386 /* Setup Cipher Parameters */
6387 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6388 ut_params->cipher_xform.next = &ut_params->auth_xform;
6390 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6391 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6393 /* Setup HMAC Parameters */
6394 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6395 ut_params->auth_xform.next = NULL;
6397 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6398 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6400 /* Create Crypto session*/
6401 ut_params->sess = rte_cryptodev_sym_session_create(
6402 ts_params->valid_devs[0], &ut_params->cipher_xform);
6403 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6405 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
6406 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
6407 burst_len, "failed to generate burst of crypto ops");
6409 /* Generate an operation for each mbuf in burst */
6410 for (i = 0; i < burst_len; i++) {
6411 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6413 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
6415 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
6419 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
6421 burst[i]->sym->m_src = m;
6424 /* Process crypto operation */
6425 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
6426 0, burst, burst_len),
6428 "Error enqueuing burst");
6430 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
6431 0, burst_dequeued, burst_len),
6433 "Error dequeuing burst");
6436 for (i = 0; i < burst_len; i++) {
6438 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
6439 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
6441 "data not as expected");
6443 rte_pktmbuf_free(burst[i]->sym->m_src);
6444 rte_crypto_op_free(burst[i]);
6447 return TEST_SUCCESS;
6451 generate_gmac_large_plaintext(uint8_t *data)
6455 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
6456 memcpy(&data[i], &data[0], 32);
6460 create_gmac_operation(enum rte_crypto_auth_operation op,
6461 const struct gmac_test_data *tdata)
6463 struct crypto_testsuite_params *ts_params = &testsuite_params;
6464 struct crypto_unittest_params *ut_params = &unittest_params;
6465 struct rte_crypto_sym_op *sym_op;
6467 unsigned iv_pad_len;
6468 unsigned aad_pad_len;
6470 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
6471 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6474 * Runtime generate the large plain text instead of use hard code
6475 * plain text vector. It is done to avoid create huge source file
6476 * with the test vector.
6478 if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6479 generate_gmac_large_plaintext(tdata->aad.data);
6481 /* Generate Crypto op data structure */
6482 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6483 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6484 TEST_ASSERT_NOT_NULL(ut_params->op,
6485 "Failed to allocate symmetric crypto operation struct");
6487 sym_op = ut_params->op->sym;
6488 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6490 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
6491 "no room to append aad");
6493 sym_op->auth.aad.length = tdata->aad.len;
6494 sym_op->auth.aad.phys_addr =
6495 rte_pktmbuf_mtophys(ut_params->ibuf);
6496 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
6498 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6499 ut_params->ibuf, tdata->gmac_tag.len);
6500 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6501 "no room to append digest");
6503 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6504 ut_params->ibuf, aad_pad_len);
6505 sym_op->auth.digest.length = tdata->gmac_tag.len;
6507 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6508 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
6509 tdata->gmac_tag.len);
6510 TEST_HEXDUMP(stdout, "digest:",
6511 sym_op->auth.digest.data,
6512 sym_op->auth.digest.length);
6515 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6516 ut_params->ibuf, iv_pad_len);
6517 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
6519 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
6520 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6521 sym_op->cipher.iv.length = tdata->iv.len;
6523 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
6525 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
6527 sym_op->cipher.data.length = 0;
6528 sym_op->cipher.data.offset = 0;
6530 sym_op->auth.data.offset = 0;
6531 sym_op->auth.data.length = 0;
6536 static int create_gmac_session(uint8_t dev_id,
6537 enum rte_crypto_cipher_operation op,
6538 const struct gmac_test_data *tdata,
6539 enum rte_crypto_auth_operation auth_op)
6541 uint8_t cipher_key[tdata->key.len];
6543 struct crypto_unittest_params *ut_params = &unittest_params;
6545 memcpy(cipher_key, tdata->key.data, tdata->key.len);
6547 /* For GMAC we setup cipher parameters */
6548 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6549 ut_params->cipher_xform.next = NULL;
6550 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
6551 ut_params->cipher_xform.cipher.op = op;
6552 ut_params->cipher_xform.cipher.key.data = cipher_key;
6553 ut_params->cipher_xform.cipher.key.length = tdata->key.len;
6555 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6556 ut_params->auth_xform.next = NULL;
6558 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
6559 ut_params->auth_xform.auth.op = auth_op;
6560 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
6561 ut_params->auth_xform.auth.add_auth_data_length = 0;
6562 ut_params->auth_xform.auth.key.length = 0;
6563 ut_params->auth_xform.auth.key.data = NULL;
6565 ut_params->cipher_xform.next = &ut_params->auth_xform;
6567 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6568 &ut_params->cipher_xform);
6570 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6576 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
6578 struct crypto_testsuite_params *ts_params = &testsuite_params;
6579 struct crypto_unittest_params *ut_params = &unittest_params;
6583 uint8_t *auth_tag, *p;
6584 uint16_t aad_pad_len;
6586 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6587 "No GMAC length in the source data");
6589 retval = create_gmac_session(ts_params->valid_devs[0],
6590 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6591 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
6596 if (tdata->aad.len > MBUF_SIZE)
6597 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6599 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6600 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6601 "Failed to allocate input buffer in mempool");
6603 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6604 rte_pktmbuf_tailroom(ut_params->ibuf));
6606 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6608 p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
6610 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
6616 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6618 ut_params->op->sym->m_src = ut_params->ibuf;
6620 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6621 ut_params->op), "failed to process sym crypto op");
6623 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6624 "crypto op processing failed");
6626 if (ut_params->op->sym->m_dst) {
6627 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6628 uint8_t *, aad_pad_len);
6630 auth_tag = p + aad_pad_len;
6633 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
6635 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6637 tdata->gmac_tag.data,
6638 tdata->gmac_tag.len,
6639 "GMAC Generated auth tag not as expected");
6645 test_AES_GMAC_authentication_test_case_1(void)
6647 return test_AES_GMAC_authentication(&gmac_test_case_1);
6651 test_AES_GMAC_authentication_test_case_2(void)
6653 return test_AES_GMAC_authentication(&gmac_test_case_2);
6657 test_AES_GMAC_authentication_test_case_3(void)
6659 return test_AES_GMAC_authentication(&gmac_test_case_3);
6663 test_AES_GMAC_authentication_test_case_4(void)
6665 return test_AES_GMAC_authentication(&gmac_test_case_4);
6669 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
6671 struct crypto_testsuite_params *ts_params = &testsuite_params;
6672 struct crypto_unittest_params *ut_params = &unittest_params;
6675 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6676 "No GMAC length in the source data");
6678 retval = create_gmac_session(ts_params->valid_devs[0],
6679 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6680 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
6685 if (tdata->aad.len > MBUF_SIZE)
6686 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6688 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6689 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6690 "Failed to allocate input buffer in mempool");
6692 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6693 rte_pktmbuf_tailroom(ut_params->ibuf));
6695 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
6701 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6703 ut_params->op->sym->m_src = ut_params->ibuf;
6705 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6706 ut_params->op), "failed to process sym crypto op");
6708 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6709 "crypto op processing failed");
6716 test_AES_GMAC_authentication_verify_test_case_1(void)
6718 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
6722 test_AES_GMAC_authentication_verify_test_case_2(void)
6724 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
6728 test_AES_GMAC_authentication_verify_test_case_3(void)
6730 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
6734 test_AES_GMAC_authentication_verify_test_case_4(void)
6736 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
6739 struct test_crypto_vector {
6740 enum rte_crypto_cipher_algorithm crypto_algo;
6753 const uint8_t *data;
6758 const uint8_t *data;
6762 enum rte_crypto_auth_algorithm auth_algo;
6770 const uint8_t *data;
6780 static const struct test_crypto_vector
6781 hmac_sha1_test_crypto_vector = {
6782 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6784 .data = plaintext_hash,
6789 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6790 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6791 0xDE, 0xF4, 0xDE, 0xAD
6797 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
6798 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
6799 0x3F, 0x91, 0x64, 0x59
6805 static const struct test_crypto_vector
6806 aes128_gmac_test_vector = {
6807 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
6808 .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
6810 .data = plaintext_hash,
6815 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6816 0x08, 0x09, 0x0A, 0x0B
6822 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6823 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
6829 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
6830 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
6836 static const struct test_crypto_vector
6837 aes128cbc_hmac_sha1_test_vector = {
6838 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
6841 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
6842 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
6848 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6849 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
6854 .data = plaintext_hash,
6858 .data = ciphertext512_aes128cbc,
6861 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6864 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6865 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6866 0xDE, 0xF4, 0xDE, 0xAD
6872 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
6873 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6874 0x18, 0x8C, 0x1D, 0x32
6881 data_corruption(uint8_t *data)
6887 tag_corruption(uint8_t *data, unsigned int tag_offset)
6889 data[tag_offset] += 1;
6893 create_auth_session(struct crypto_unittest_params *ut_params,
6895 const struct test_crypto_vector *reference,
6896 enum rte_crypto_auth_operation auth_op)
6898 uint8_t auth_key[reference->auth_key.len + 1];
6900 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6902 /* Setup Authentication Parameters */
6903 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6904 ut_params->auth_xform.auth.op = auth_op;
6905 ut_params->auth_xform.next = NULL;
6906 ut_params->auth_xform.auth.algo = reference->auth_algo;
6907 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6908 ut_params->auth_xform.auth.key.data = auth_key;
6909 ut_params->auth_xform.auth.digest_length = reference->digest.len;
6910 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6912 /* Create Crypto session*/
6913 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6914 &ut_params->auth_xform);
6916 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6922 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
6924 const struct test_crypto_vector *reference,
6925 enum rte_crypto_auth_operation auth_op,
6926 enum rte_crypto_cipher_operation cipher_op)
6928 uint8_t cipher_key[reference->cipher_key.len + 1];
6929 uint8_t auth_key[reference->auth_key.len + 1];
6931 memcpy(cipher_key, reference->cipher_key.data,
6932 reference->cipher_key.len);
6933 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6935 /* Setup Authentication Parameters */
6936 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6937 ut_params->auth_xform.auth.op = auth_op;
6938 ut_params->auth_xform.next = &ut_params->cipher_xform;
6939 ut_params->auth_xform.auth.algo = reference->auth_algo;
6940 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6941 ut_params->auth_xform.auth.key.data = auth_key;
6942 ut_params->auth_xform.auth.digest_length = reference->digest.len;
6943 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6945 /* Setup Cipher Parameters */
6946 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6947 ut_params->cipher_xform.next = NULL;
6948 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
6949 ut_params->cipher_xform.cipher.op = cipher_op;
6950 ut_params->cipher_xform.cipher.key.data = cipher_key;
6951 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
6953 /* Create Crypto session*/
6954 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6955 &ut_params->auth_xform);
6957 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6963 create_auth_operation(struct crypto_testsuite_params *ts_params,
6964 struct crypto_unittest_params *ut_params,
6965 const struct test_crypto_vector *reference,
6966 unsigned int auth_generate)
6968 /* Generate Crypto op data structure */
6969 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6970 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6971 TEST_ASSERT_NOT_NULL(ut_params->op,
6972 "Failed to allocate pktmbuf offload");
6974 /* Set crypto operation data parameters */
6975 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6977 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6979 /* set crypto operation source mbuf */
6980 sym_op->m_src = ut_params->ibuf;
6983 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6984 ut_params->ibuf, reference->digest.len);
6986 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6987 "no room to append auth tag");
6989 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6990 ut_params->ibuf, reference->plaintext.len);
6991 sym_op->auth.digest.length = reference->digest.len;
6994 memset(sym_op->auth.digest.data, 0, reference->digest.len);
6996 memcpy(sym_op->auth.digest.data,
6997 reference->digest.data,
6998 reference->digest.len);
7000 TEST_HEXDUMP(stdout, "digest:",
7001 sym_op->auth.digest.data,
7002 sym_op->auth.digest.length);
7004 sym_op->auth.data.length = reference->plaintext.len;
7005 sym_op->auth.data.offset = 0;
7011 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
7012 struct crypto_unittest_params *ut_params,
7013 const struct test_crypto_vector *reference,
7014 unsigned int auth_generate)
7016 /* Generate Crypto op data structure */
7017 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7018 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7019 TEST_ASSERT_NOT_NULL(ut_params->op,
7020 "Failed to allocate pktmbuf offload");
7022 /* Set crypto operation data parameters */
7023 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7025 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7027 /* set crypto operation source mbuf */
7028 sym_op->m_src = ut_params->ibuf;
7031 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7032 reference->aad.len);
7033 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
7034 memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
7036 TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
7038 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7039 sym_op->auth.aad.length = reference->aad.len;
7042 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7043 ut_params->ibuf, reference->digest.len);
7045 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7046 "no room to append auth tag");
7048 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7049 ut_params->ibuf, reference->ciphertext.len);
7050 sym_op->auth.digest.length = reference->digest.len;
7053 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7055 memcpy(sym_op->auth.digest.data,
7056 reference->digest.data,
7057 reference->digest.len);
7059 TEST_HEXDUMP(stdout, "digest:",
7060 sym_op->auth.digest.data,
7061 sym_op->auth.digest.length);
7063 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7064 ut_params->ibuf, reference->iv.len);
7065 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
7067 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7068 sym_op->cipher.iv.length = reference->iv.len;
7070 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
7072 sym_op->cipher.data.length = 0;
7073 sym_op->cipher.data.offset = 0;
7075 sym_op->auth.data.length = 0;
7076 sym_op->auth.data.offset = 0;
7082 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
7083 struct crypto_unittest_params *ut_params,
7084 const struct test_crypto_vector *reference,
7085 unsigned int auth_generate)
7087 /* Generate Crypto op data structure */
7088 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7089 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7090 TEST_ASSERT_NOT_NULL(ut_params->op,
7091 "Failed to allocate pktmbuf offload");
7093 /* Set crypto operation data parameters */
7094 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7096 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7098 /* set crypto operation source mbuf */
7099 sym_op->m_src = ut_params->ibuf;
7102 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7103 ut_params->ibuf, reference->digest.len);
7105 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7106 "no room to append auth tag");
7108 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7109 ut_params->ibuf, reference->ciphertext.len);
7110 sym_op->auth.digest.length = reference->digest.len;
7113 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7115 memcpy(sym_op->auth.digest.data,
7116 reference->digest.data,
7117 reference->digest.len);
7119 TEST_HEXDUMP(stdout, "digest:",
7120 sym_op->auth.digest.data,
7121 sym_op->auth.digest.length);
7123 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7124 ut_params->ibuf, reference->iv.len);
7125 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
7127 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7128 sym_op->cipher.iv.length = reference->iv.len;
7130 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
7132 sym_op->cipher.data.length = reference->ciphertext.len;
7133 sym_op->cipher.data.offset = reference->iv.len;
7135 sym_op->auth.data.length = reference->ciphertext.len;
7136 sym_op->auth.data.offset = reference->iv.len;
7142 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7143 struct crypto_unittest_params *ut_params,
7144 const struct test_crypto_vector *reference)
7146 return create_auth_operation(ts_params, ut_params, reference, 0);
7150 create_auth_verify_GMAC_operation(
7151 struct crypto_testsuite_params *ts_params,
7152 struct crypto_unittest_params *ut_params,
7153 const struct test_crypto_vector *reference)
7155 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
7159 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7160 struct crypto_unittest_params *ut_params,
7161 const struct test_crypto_vector *reference)
7163 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
7167 test_authentication_verify_fail_when_data_corruption(
7168 struct crypto_testsuite_params *ts_params,
7169 struct crypto_unittest_params *ut_params,
7170 const struct test_crypto_vector *reference,
7171 unsigned int data_corrupted)
7177 /* Create session */
7178 retval = create_auth_session(ut_params,
7179 ts_params->valid_devs[0],
7181 RTE_CRYPTO_AUTH_OP_VERIFY);
7185 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7186 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7187 "Failed to allocate input buffer in mempool");
7189 /* clear mbuf payload */
7190 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7191 rte_pktmbuf_tailroom(ut_params->ibuf));
7193 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7194 reference->plaintext.len);
7195 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7196 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7198 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7200 /* Create operation */
7201 retval = create_auth_verify_operation(ts_params, ut_params, reference);
7207 data_corruption(plaintext);
7209 tag_corruption(plaintext, reference->plaintext.len);
7211 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7213 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7214 TEST_ASSERT_EQUAL(ut_params->op->status,
7215 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7216 "authentication not failed");
7218 ut_params->obuf = ut_params->op->sym->m_src;
7219 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7225 test_authentication_verify_GMAC_fail_when_corruption(
7226 struct crypto_testsuite_params *ts_params,
7227 struct crypto_unittest_params *ut_params,
7228 const struct test_crypto_vector *reference,
7229 unsigned int data_corrupted)
7233 /* Create session */
7234 retval = create_auth_cipher_session(ut_params,
7235 ts_params->valid_devs[0],
7237 RTE_CRYPTO_AUTH_OP_VERIFY,
7238 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7242 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7243 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7244 "Failed to allocate input buffer in mempool");
7246 /* clear mbuf payload */
7247 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7248 rte_pktmbuf_tailroom(ut_params->ibuf));
7250 /* Create operation */
7251 retval = create_auth_verify_GMAC_operation(ts_params,
7259 data_corruption(ut_params->op->sym->auth.aad.data);
7261 tag_corruption(ut_params->op->sym->auth.aad.data,
7262 reference->aad.len);
7264 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7266 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7267 TEST_ASSERT_EQUAL(ut_params->op->status,
7268 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7269 "authentication not failed");
7271 ut_params->obuf = ut_params->op->sym->m_src;
7272 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7278 test_authenticated_decryption_fail_when_corruption(
7279 struct crypto_testsuite_params *ts_params,
7280 struct crypto_unittest_params *ut_params,
7281 const struct test_crypto_vector *reference,
7282 unsigned int data_corrupted)
7286 uint8_t *ciphertext;
7288 /* Create session */
7289 retval = create_auth_cipher_session(ut_params,
7290 ts_params->valid_devs[0],
7292 RTE_CRYPTO_AUTH_OP_VERIFY,
7293 RTE_CRYPTO_CIPHER_OP_DECRYPT);
7297 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7298 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7299 "Failed to allocate input buffer in mempool");
7301 /* clear mbuf payload */
7302 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7303 rte_pktmbuf_tailroom(ut_params->ibuf));
7305 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7306 reference->ciphertext.len);
7307 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
7308 memcpy(ciphertext, reference->ciphertext.data,
7309 reference->ciphertext.len);
7311 /* Create operation */
7312 retval = create_cipher_auth_verify_operation(ts_params,
7320 data_corruption(ciphertext);
7322 tag_corruption(ciphertext, reference->ciphertext.len);
7324 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7327 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7328 TEST_ASSERT_EQUAL(ut_params->op->status,
7329 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7330 "authentication not failed");
7332 ut_params->obuf = ut_params->op->sym->m_src;
7333 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7339 create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
7340 const struct gcm_test_data *tdata,
7341 void *digest_mem, uint64_t digest_phys)
7343 struct crypto_testsuite_params *ts_params = &testsuite_params;
7344 struct crypto_unittest_params *ut_params = &unittest_params;
7346 const unsigned int auth_tag_len = tdata->auth_tag.len;
7347 const unsigned int iv_len = tdata->iv.len;
7348 const unsigned int aad_len = tdata->aad.len;
7350 unsigned int iv_pad_len = 0;
7352 /* Generate Crypto op data structure */
7353 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7354 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7355 TEST_ASSERT_NOT_NULL(ut_params->op,
7356 "Failed to allocate symmetric crypto operation struct");
7358 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7360 sym_op->auth.digest.data = digest_mem;
7362 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7363 "no room to append digest");
7365 sym_op->auth.digest.phys_addr = digest_phys;
7366 sym_op->auth.digest.length = auth_tag_len;
7368 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
7369 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
7371 TEST_HEXDUMP(stdout, "digest:",
7372 sym_op->auth.digest.data,
7373 sym_op->auth.digest.length);
7376 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
7378 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7379 ut_params->ibuf, iv_pad_len);
7381 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
7382 "no room to prepend iv");
7384 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
7385 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7386 sym_op->cipher.iv.length = iv_len;
7388 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len);
7390 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
7391 ut_params->ibuf, aad_len);
7392 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
7393 "no room to prepend aad");
7394 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
7396 sym_op->auth.aad.length = aad_len;
7398 memset(sym_op->auth.aad.data, 0, aad_len);
7399 rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
7401 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
7402 TEST_HEXDUMP(stdout, "aad:",
7403 sym_op->auth.aad.data, aad_len);
7405 sym_op->cipher.data.length = tdata->plaintext.len;
7406 sym_op->cipher.data.offset = aad_len + iv_pad_len;
7408 sym_op->auth.data.offset = aad_len + iv_pad_len;
7409 sym_op->auth.data.length = tdata->plaintext.len;
7414 #define SGL_MAX_NO 16
7417 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
7418 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
7420 struct crypto_testsuite_params *ts_params = &testsuite_params;
7421 struct crypto_unittest_params *ut_params = &unittest_params;
7422 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
7425 int to_trn_tbl[SGL_MAX_NO];
7427 unsigned int trn_data = 0;
7428 uint8_t *plaintext, *ciphertext, *auth_tag;
7430 if (fragsz > tdata->plaintext.len)
7431 fragsz = tdata->plaintext.len;
7433 uint16_t plaintext_len = fragsz;
7434 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7436 if (fragsz_oop > tdata->plaintext.len)
7437 frag_size_oop = tdata->plaintext.len;
7440 void *digest_mem = NULL;
7442 uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16)
7445 if (tdata->plaintext.len % fragsz != 0) {
7446 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
7449 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
7454 * For out-op-place we need to alloc another mbuf
7457 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7458 rte_pktmbuf_append(ut_params->obuf,
7459 frag_size_oop + prepend_len);
7460 buf_oop = ut_params->obuf;
7463 /* Create GCM session */
7464 retval = create_gcm_session(ts_params->valid_devs[0],
7465 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7466 tdata->key.data, tdata->key.len,
7467 tdata->aad.len, tdata->auth_tag.len,
7468 RTE_CRYPTO_AUTH_OP_GENERATE);
7472 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7474 /* clear mbuf payload */
7475 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7476 rte_pktmbuf_tailroom(ut_params->ibuf));
7478 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7481 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7483 trn_data += plaintext_len;
7485 buf = ut_params->ibuf;
7488 * Loop until no more fragments
7491 while (trn_data < tdata->plaintext.len) {
7493 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
7494 (tdata->plaintext.len - trn_data) : fragsz;
7496 to_trn_tbl[ecx++] = to_trn;
7498 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7501 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7502 rte_pktmbuf_tailroom(buf));
7505 if (oop && !fragsz_oop) {
7506 buf_last_oop = buf_oop->next =
7507 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7508 buf_oop = buf_oop->next;
7509 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7510 0, rte_pktmbuf_tailroom(buf_oop));
7511 rte_pktmbuf_append(buf_oop, to_trn);
7514 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7517 memcpy(plaintext, tdata->plaintext.data + trn_data,
7520 if (trn_data == tdata->plaintext.len) {
7523 digest_mem = rte_pktmbuf_append(buf_oop,
7524 tdata->auth_tag.len);
7526 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
7527 tdata->auth_tag.len);
7531 uint64_t digest_phys = 0;
7533 ut_params->ibuf->nb_segs = segs;
7536 if (fragsz_oop && oop) {
7540 if (frag_size_oop == tdata->plaintext.len) {
7541 digest_mem = rte_pktmbuf_append(ut_params->obuf,
7542 tdata->auth_tag.len);
7544 digest_phys = rte_pktmbuf_mtophys_offset(
7546 tdata->plaintext.len + prepend_len);
7549 trn_data = frag_size_oop;
7550 while (trn_data < tdata->plaintext.len) {
7553 (tdata->plaintext.len - trn_data <
7555 (tdata->plaintext.len - trn_data) :
7558 to_trn_tbl[ecx++] = to_trn;
7560 buf_last_oop = buf_oop->next =
7561 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7562 buf_oop = buf_oop->next;
7563 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7564 0, rte_pktmbuf_tailroom(buf_oop));
7565 rte_pktmbuf_append(buf_oop, to_trn);
7569 if (trn_data == tdata->plaintext.len) {
7570 digest_mem = rte_pktmbuf_append(buf_oop,
7571 tdata->auth_tag.len);
7575 ut_params->obuf->nb_segs = segs;
7579 * Place digest at the end of the last buffer
7582 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
7583 if (oop && buf_last_oop)
7584 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
7586 if (!digest_mem && !oop) {
7587 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7588 + tdata->auth_tag.len);
7589 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
7590 tdata->plaintext.len);
7593 /* Create GCM opertaion */
7594 retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7595 tdata, digest_mem, digest_phys);
7600 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7602 ut_params->op->sym->m_src = ut_params->ibuf;
7604 ut_params->op->sym->m_dst = ut_params->obuf;
7606 /* Process crypto operation */
7607 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7608 ut_params->op), "failed to process sym crypto op");
7610 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7611 "crypto op processing failed");
7614 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7615 uint8_t *, prepend_len);
7617 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7618 uint8_t *, prepend_len);
7622 fragsz = fragsz_oop;
7624 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7626 tdata->ciphertext.data,
7628 "GCM Ciphertext data not as expected");
7630 buf = ut_params->op->sym->m_src->next;
7632 buf = ut_params->op->sym->m_dst->next;
7634 unsigned int off = fragsz;
7638 ciphertext = rte_pktmbuf_mtod(buf,
7641 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7643 tdata->ciphertext.data + off,
7645 "GCM Ciphertext data not as expected");
7647 off += to_trn_tbl[ecx++];
7651 auth_tag = digest_mem;
7652 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7654 tdata->auth_tag.data,
7655 tdata->auth_tag.len,
7656 "GCM Generated auth tag not as expected");
7662 #define OUT_OF_PLACE 1
7665 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
7667 return test_AES_GCM_authenticated_encryption_SGL(
7668 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
7672 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
7674 return test_AES_GCM_authenticated_encryption_SGL(
7675 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
7679 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
7681 return test_AES_GCM_authenticated_encryption_SGL(
7682 &gcm_test_case_8, OUT_OF_PLACE, 400,
7683 gcm_test_case_8.plaintext.len);
7687 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
7690 return test_AES_GCM_authenticated_encryption_SGL(
7691 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
7695 test_authentication_verify_fail_when_data_corrupted(
7696 struct crypto_testsuite_params *ts_params,
7697 struct crypto_unittest_params *ut_params,
7698 const struct test_crypto_vector *reference)
7700 return test_authentication_verify_fail_when_data_corruption(
7701 ts_params, ut_params, reference, 1);
7705 test_authentication_verify_fail_when_tag_corrupted(
7706 struct crypto_testsuite_params *ts_params,
7707 struct crypto_unittest_params *ut_params,
7708 const struct test_crypto_vector *reference)
7710 return test_authentication_verify_fail_when_data_corruption(
7711 ts_params, ut_params, reference, 0);
7715 test_authentication_verify_GMAC_fail_when_data_corrupted(
7716 struct crypto_testsuite_params *ts_params,
7717 struct crypto_unittest_params *ut_params,
7718 const struct test_crypto_vector *reference)
7720 return test_authentication_verify_GMAC_fail_when_corruption(
7721 ts_params, ut_params, reference, 1);
7725 test_authentication_verify_GMAC_fail_when_tag_corrupted(
7726 struct crypto_testsuite_params *ts_params,
7727 struct crypto_unittest_params *ut_params,
7728 const struct test_crypto_vector *reference)
7730 return test_authentication_verify_GMAC_fail_when_corruption(
7731 ts_params, ut_params, reference, 0);
7735 test_authenticated_decryption_fail_when_data_corrupted(
7736 struct crypto_testsuite_params *ts_params,
7737 struct crypto_unittest_params *ut_params,
7738 const struct test_crypto_vector *reference)
7740 return test_authenticated_decryption_fail_when_corruption(
7741 ts_params, ut_params, reference, 1);
7745 test_authenticated_decryption_fail_when_tag_corrupted(
7746 struct crypto_testsuite_params *ts_params,
7747 struct crypto_unittest_params *ut_params,
7748 const struct test_crypto_vector *reference)
7750 return test_authenticated_decryption_fail_when_corruption(
7751 ts_params, ut_params, reference, 0);
7755 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
7757 return test_authentication_verify_fail_when_data_corrupted(
7758 &testsuite_params, &unittest_params,
7759 &hmac_sha1_test_crypto_vector);
7763 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
7765 return test_authentication_verify_fail_when_tag_corrupted(
7766 &testsuite_params, &unittest_params,
7767 &hmac_sha1_test_crypto_vector);
7771 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
7773 return test_authentication_verify_GMAC_fail_when_data_corrupted(
7774 &testsuite_params, &unittest_params,
7775 &aes128_gmac_test_vector);
7779 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
7781 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
7782 &testsuite_params, &unittest_params,
7783 &aes128_gmac_test_vector);
7787 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
7789 return test_authenticated_decryption_fail_when_data_corrupted(
7792 &aes128cbc_hmac_sha1_test_vector);
7796 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
7798 return test_authenticated_decryption_fail_when_tag_corrupted(
7801 &aes128cbc_hmac_sha1_test_vector);
7804 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
7806 /* global AESNI slave IDs for the scheduler test */
7807 uint8_t aesni_ids[2];
7810 test_scheduler_attach_slave_op(void)
7812 struct crypto_testsuite_params *ts_params = &testsuite_params;
7813 uint8_t sched_id = ts_params->valid_devs[0];
7814 uint32_t nb_devs, i, nb_devs_attached = 0;
7818 /* create 2 AESNI_MB if necessary */
7819 nb_devs = rte_cryptodev_count_devtype(
7820 RTE_CRYPTODEV_AESNI_MB_PMD);
7822 for (i = nb_devs; i < 2; i++) {
7823 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
7824 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
7826 ret = rte_vdev_init(vdev_name, NULL);
7828 TEST_ASSERT(ret == 0,
7829 "Failed to create instance %u of"
7831 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7835 /* attach 2 AESNI_MB cdevs */
7836 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
7838 struct rte_cryptodev_info info;
7840 rte_cryptodev_info_get(i, &info);
7841 if (info.dev_type != RTE_CRYPTODEV_AESNI_MB_PMD)
7844 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
7847 TEST_ASSERT(ret == 0,
7848 "Failed to attach device %u of pmd : %s", i,
7849 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7851 aesni_ids[nb_devs_attached] = (uint8_t)i;
7860 test_scheduler_detach_slave_op(void)
7862 struct crypto_testsuite_params *ts_params = &testsuite_params;
7863 uint8_t sched_id = ts_params->valid_devs[0];
7867 for (i = 0; i < 2; i++) {
7868 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
7870 TEST_ASSERT(ret == 0,
7871 "Failed to detach device %u", aesni_ids[i]);
7878 test_scheduler_mode_op(void)
7880 struct crypto_testsuite_params *ts_params = &testsuite_params;
7881 uint8_t sched_id = ts_params->valid_devs[0];
7882 struct rte_cryptodev_scheduler_ops op = {0};
7883 struct rte_cryptodev_scheduler dummy_scheduler = {
7884 .description = "dummy scheduler to test mode",
7885 .name = "dummy scheduler",
7886 .mode = CDEV_SCHED_MODE_USERDEFINED,
7891 /* set user defined mode */
7892 ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
7894 TEST_ASSERT(ret == 0,
7895 "Failed to set cdev %u to user defined mode", sched_id);
7897 /* set round robin mode */
7898 ret = rte_cryptodev_scheduler_mode_set(sched_id,
7899 CDEV_SCHED_MODE_ROUNDROBIN);
7900 TEST_ASSERT(ret == 0,
7901 "Failed to set cdev %u to round-robin mode", sched_id);
7902 TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) ==
7903 CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
7909 static struct unit_test_suite cryptodev_scheduler_testsuite = {
7910 .suite_name = "Crypto Device Scheduler Unit Test Suite",
7911 .setup = testsuite_setup,
7912 .teardown = testsuite_teardown,
7913 .unit_test_cases = {
7914 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
7915 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
7916 TEST_CASE_ST(ut_setup, ut_teardown,
7917 test_AES_chain_scheduler_all),
7918 TEST_CASE_ST(ut_setup, ut_teardown,
7919 test_AES_cipheronly_scheduler_all),
7920 TEST_CASE_ST(ut_setup, ut_teardown,
7921 test_authonly_scheduler_all),
7922 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
7923 TEST_CASES_END() /**< NULL terminate unit test array */
7927 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
7929 static struct unit_test_suite cryptodev_qat_testsuite = {
7930 .suite_name = "Crypto QAT Unit Test Suite",
7931 .setup = testsuite_setup,
7932 .teardown = testsuite_teardown,
7933 .unit_test_cases = {
7934 TEST_CASE_ST(ut_setup, ut_teardown,
7935 test_device_configure_invalid_dev_id),
7936 TEST_CASE_ST(ut_setup, ut_teardown,
7937 test_device_configure_invalid_queue_pair_ids),
7938 TEST_CASE_ST(ut_setup, ut_teardown,
7939 test_queue_pair_descriptor_setup),
7940 TEST_CASE_ST(ut_setup, ut_teardown,
7941 test_multi_session),
7943 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
7944 TEST_CASE_ST(ut_setup, ut_teardown,
7945 test_AES_cipheronly_qat_all),
7946 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
7947 TEST_CASE_ST(ut_setup, ut_teardown,
7948 test_3DES_cipheronly_qat_all),
7949 TEST_CASE_ST(ut_setup, ut_teardown,
7950 test_DES_cipheronly_qat_all),
7951 TEST_CASE_ST(ut_setup, ut_teardown,
7952 test_AES_docsis_qat_all),
7953 TEST_CASE_ST(ut_setup, ut_teardown,
7954 test_DES_docsis_qat_all),
7955 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
7957 /** AES GCM Authenticated Encryption */
7958 TEST_CASE_ST(ut_setup, ut_teardown,
7959 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
7960 TEST_CASE_ST(ut_setup, ut_teardown,
7961 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
7962 TEST_CASE_ST(ut_setup, ut_teardown,
7963 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
7964 TEST_CASE_ST(ut_setup, ut_teardown,
7965 test_mb_AES_GCM_authenticated_encryption_test_case_1),
7966 TEST_CASE_ST(ut_setup, ut_teardown,
7967 test_mb_AES_GCM_authenticated_encryption_test_case_2),
7968 TEST_CASE_ST(ut_setup, ut_teardown,
7969 test_mb_AES_GCM_authenticated_encryption_test_case_3),
7970 TEST_CASE_ST(ut_setup, ut_teardown,
7971 test_mb_AES_GCM_authenticated_encryption_test_case_4),
7972 TEST_CASE_ST(ut_setup, ut_teardown,
7973 test_mb_AES_GCM_authenticated_encryption_test_case_5),
7974 TEST_CASE_ST(ut_setup, ut_teardown,
7975 test_mb_AES_GCM_authenticated_encryption_test_case_6),
7976 TEST_CASE_ST(ut_setup, ut_teardown,
7977 test_mb_AES_GCM_authenticated_encryption_test_case_7),
7979 /** AES GCM Authenticated Decryption */
7980 TEST_CASE_ST(ut_setup, ut_teardown,
7981 test_mb_AES_GCM_authenticated_decryption_test_case_1),
7982 TEST_CASE_ST(ut_setup, ut_teardown,
7983 test_mb_AES_GCM_authenticated_decryption_test_case_2),
7984 TEST_CASE_ST(ut_setup, ut_teardown,
7985 test_mb_AES_GCM_authenticated_decryption_test_case_3),
7986 TEST_CASE_ST(ut_setup, ut_teardown,
7987 test_mb_AES_GCM_authenticated_decryption_test_case_4),
7988 TEST_CASE_ST(ut_setup, ut_teardown,
7989 test_mb_AES_GCM_authenticated_decryption_test_case_5),
7990 TEST_CASE_ST(ut_setup, ut_teardown,
7991 test_mb_AES_GCM_authenticated_decryption_test_case_6),
7992 TEST_CASE_ST(ut_setup, ut_teardown,
7993 test_mb_AES_GCM_authenticated_decryption_test_case_7),
7995 /** AES GMAC Authentication */
7996 TEST_CASE_ST(ut_setup, ut_teardown,
7997 test_AES_GMAC_authentication_test_case_1),
7998 TEST_CASE_ST(ut_setup, ut_teardown,
7999 test_AES_GMAC_authentication_verify_test_case_1),
8000 TEST_CASE_ST(ut_setup, ut_teardown,
8001 test_AES_GMAC_authentication_test_case_2),
8002 TEST_CASE_ST(ut_setup, ut_teardown,
8003 test_AES_GMAC_authentication_verify_test_case_2),
8004 TEST_CASE_ST(ut_setup, ut_teardown,
8005 test_AES_GMAC_authentication_test_case_3),
8006 TEST_CASE_ST(ut_setup, ut_teardown,
8007 test_AES_GMAC_authentication_verify_test_case_3),
8009 /** SNOW 3G encrypt only (UEA2) */
8010 TEST_CASE_ST(ut_setup, ut_teardown,
8011 test_snow3g_encryption_test_case_1),
8012 TEST_CASE_ST(ut_setup, ut_teardown,
8013 test_snow3g_encryption_test_case_2),
8014 TEST_CASE_ST(ut_setup, ut_teardown,
8015 test_snow3g_encryption_test_case_3),
8016 TEST_CASE_ST(ut_setup, ut_teardown,
8017 test_snow3g_encryption_test_case_4),
8018 TEST_CASE_ST(ut_setup, ut_teardown,
8019 test_snow3g_encryption_test_case_5),
8021 TEST_CASE_ST(ut_setup, ut_teardown,
8022 test_snow3g_encryption_test_case_1_oop),
8023 TEST_CASE_ST(ut_setup, ut_teardown,
8024 test_snow3g_decryption_test_case_1_oop),
8026 /** SNOW 3G decrypt only (UEA2) */
8027 TEST_CASE_ST(ut_setup, ut_teardown,
8028 test_snow3g_decryption_test_case_1),
8029 TEST_CASE_ST(ut_setup, ut_teardown,
8030 test_snow3g_decryption_test_case_2),
8031 TEST_CASE_ST(ut_setup, ut_teardown,
8032 test_snow3g_decryption_test_case_3),
8033 TEST_CASE_ST(ut_setup, ut_teardown,
8034 test_snow3g_decryption_test_case_4),
8035 TEST_CASE_ST(ut_setup, ut_teardown,
8036 test_snow3g_decryption_test_case_5),
8037 TEST_CASE_ST(ut_setup, ut_teardown,
8038 test_snow3g_hash_generate_test_case_1),
8039 TEST_CASE_ST(ut_setup, ut_teardown,
8040 test_snow3g_hash_generate_test_case_2),
8041 TEST_CASE_ST(ut_setup, ut_teardown,
8042 test_snow3g_hash_generate_test_case_3),
8043 TEST_CASE_ST(ut_setup, ut_teardown,
8044 test_snow3g_hash_verify_test_case_1),
8045 TEST_CASE_ST(ut_setup, ut_teardown,
8046 test_snow3g_hash_verify_test_case_2),
8047 TEST_CASE_ST(ut_setup, ut_teardown,
8048 test_snow3g_hash_verify_test_case_3),
8049 TEST_CASE_ST(ut_setup, ut_teardown,
8050 test_snow3g_cipher_auth_test_case_1),
8051 TEST_CASE_ST(ut_setup, ut_teardown,
8052 test_snow3g_auth_cipher_test_case_1),
8054 /** ZUC encrypt only (EEA3) */
8055 TEST_CASE_ST(ut_setup, ut_teardown,
8056 test_zuc_encryption_test_case_1),
8057 TEST_CASE_ST(ut_setup, ut_teardown,
8058 test_zuc_encryption_test_case_2),
8059 TEST_CASE_ST(ut_setup, ut_teardown,
8060 test_zuc_encryption_test_case_3),
8061 TEST_CASE_ST(ut_setup, ut_teardown,
8062 test_zuc_encryption_test_case_4),
8063 TEST_CASE_ST(ut_setup, ut_teardown,
8064 test_zuc_encryption_test_case_5),
8066 /** ZUC authenticate (EIA3) */
8067 TEST_CASE_ST(ut_setup, ut_teardown,
8068 test_zuc_hash_generate_test_case_6),
8069 TEST_CASE_ST(ut_setup, ut_teardown,
8070 test_zuc_hash_generate_test_case_7),
8071 TEST_CASE_ST(ut_setup, ut_teardown,
8072 test_zuc_hash_generate_test_case_8),
8074 /** ZUC alg-chain (EEA3/EIA3) */
8075 TEST_CASE_ST(ut_setup, ut_teardown,
8076 test_zuc_cipher_auth_test_case_1),
8077 TEST_CASE_ST(ut_setup, ut_teardown,
8078 test_zuc_cipher_auth_test_case_2),
8080 /** HMAC_MD5 Authentication */
8081 TEST_CASE_ST(ut_setup, ut_teardown,
8082 test_MD5_HMAC_generate_case_1),
8083 TEST_CASE_ST(ut_setup, ut_teardown,
8084 test_MD5_HMAC_verify_case_1),
8085 TEST_CASE_ST(ut_setup, ut_teardown,
8086 test_MD5_HMAC_generate_case_2),
8087 TEST_CASE_ST(ut_setup, ut_teardown,
8088 test_MD5_HMAC_verify_case_2),
8091 TEST_CASE_ST(ut_setup, ut_teardown,
8092 test_null_auth_only_operation),
8093 TEST_CASE_ST(ut_setup, ut_teardown,
8094 test_null_cipher_only_operation),
8095 TEST_CASE_ST(ut_setup, ut_teardown,
8096 test_null_cipher_auth_operation),
8097 TEST_CASE_ST(ut_setup, ut_teardown,
8098 test_null_auth_cipher_operation),
8100 TEST_CASE_ST(ut_setup, ut_teardown,
8101 test_kasumi_hash_generate_test_case_6),
8104 TEST_CASE_ST(ut_setup, ut_teardown,
8105 test_kasumi_encryption_test_case_1),
8106 TEST_CASE_ST(ut_setup, ut_teardown,
8107 test_kasumi_encryption_test_case_3),
8108 TEST_CASE_ST(ut_setup, ut_teardown,
8109 test_kasumi_auth_cipher_test_case_1),
8110 TEST_CASE_ST(ut_setup, ut_teardown,
8111 test_kasumi_cipher_auth_test_case_1),
8113 /** Negative tests */
8114 TEST_CASE_ST(ut_setup, ut_teardown,
8115 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8116 TEST_CASE_ST(ut_setup, ut_teardown,
8117 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8118 TEST_CASE_ST(ut_setup, ut_teardown,
8119 authentication_verify_AES128_GMAC_fail_data_corrupt),
8120 TEST_CASE_ST(ut_setup, ut_teardown,
8121 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8122 TEST_CASE_ST(ut_setup, ut_teardown,
8123 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8124 TEST_CASE_ST(ut_setup, ut_teardown,
8125 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8127 TEST_CASES_END() /**< NULL terminate unit test array */
8131 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
8132 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
8133 .setup = testsuite_setup,
8134 .teardown = testsuite_teardown,
8135 .unit_test_cases = {
8136 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
8137 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
8138 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
8139 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
8141 TEST_CASES_END() /**< NULL terminate unit test array */
8145 static struct unit_test_suite cryptodev_openssl_testsuite = {
8146 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
8147 .setup = testsuite_setup,
8148 .teardown = testsuite_teardown,
8149 .unit_test_cases = {
8150 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
8151 TEST_CASE_ST(ut_setup, ut_teardown,
8152 test_multi_session_random_usage),
8153 TEST_CASE_ST(ut_setup, ut_teardown,
8154 test_AES_chain_openssl_all),
8155 TEST_CASE_ST(ut_setup, ut_teardown,
8156 test_AES_cipheronly_openssl_all),
8157 TEST_CASE_ST(ut_setup, ut_teardown,
8158 test_3DES_chain_openssl_all),
8159 TEST_CASE_ST(ut_setup, ut_teardown,
8160 test_3DES_cipheronly_openssl_all),
8161 TEST_CASE_ST(ut_setup, ut_teardown,
8162 test_DES_docsis_openssl_all),
8163 TEST_CASE_ST(ut_setup, ut_teardown,
8164 test_authonly_openssl_all),
8166 /** AES GCM Authenticated Encryption */
8167 TEST_CASE_ST(ut_setup, ut_teardown,
8168 test_mb_AES_GCM_authenticated_encryption_test_case_1),
8169 TEST_CASE_ST(ut_setup, ut_teardown,
8170 test_mb_AES_GCM_authenticated_encryption_test_case_2),
8171 TEST_CASE_ST(ut_setup, ut_teardown,
8172 test_mb_AES_GCM_authenticated_encryption_test_case_3),
8173 TEST_CASE_ST(ut_setup, ut_teardown,
8174 test_mb_AES_GCM_authenticated_encryption_test_case_4),
8175 TEST_CASE_ST(ut_setup, ut_teardown,
8176 test_mb_AES_GCM_authenticated_encryption_test_case_5),
8177 TEST_CASE_ST(ut_setup, ut_teardown,
8178 test_mb_AES_GCM_authenticated_encryption_test_case_6),
8179 TEST_CASE_ST(ut_setup, ut_teardown,
8180 test_mb_AES_GCM_authenticated_encryption_test_case_7),
8182 /** AES GCM Authenticated Decryption */
8183 TEST_CASE_ST(ut_setup, ut_teardown,
8184 test_mb_AES_GCM_authenticated_decryption_test_case_1),
8185 TEST_CASE_ST(ut_setup, ut_teardown,
8186 test_mb_AES_GCM_authenticated_decryption_test_case_2),
8187 TEST_CASE_ST(ut_setup, ut_teardown,
8188 test_mb_AES_GCM_authenticated_decryption_test_case_3),
8189 TEST_CASE_ST(ut_setup, ut_teardown,
8190 test_mb_AES_GCM_authenticated_decryption_test_case_4),
8191 TEST_CASE_ST(ut_setup, ut_teardown,
8192 test_mb_AES_GCM_authenticated_decryption_test_case_5),
8193 TEST_CASE_ST(ut_setup, ut_teardown,
8194 test_mb_AES_GCM_authenticated_decryption_test_case_6),
8195 TEST_CASE_ST(ut_setup, ut_teardown,
8196 test_mb_AES_GCM_authenticated_decryption_test_case_7),
8198 /** AES GMAC Authentication */
8199 TEST_CASE_ST(ut_setup, ut_teardown,
8200 test_AES_GMAC_authentication_test_case_1),
8201 TEST_CASE_ST(ut_setup, ut_teardown,
8202 test_AES_GMAC_authentication_verify_test_case_1),
8203 TEST_CASE_ST(ut_setup, ut_teardown,
8204 test_AES_GMAC_authentication_test_case_2),
8205 TEST_CASE_ST(ut_setup, ut_teardown,
8206 test_AES_GMAC_authentication_verify_test_case_2),
8207 TEST_CASE_ST(ut_setup, ut_teardown,
8208 test_AES_GMAC_authentication_test_case_3),
8209 TEST_CASE_ST(ut_setup, ut_teardown,
8210 test_AES_GMAC_authentication_verify_test_case_3),
8211 TEST_CASE_ST(ut_setup, ut_teardown,
8212 test_AES_GMAC_authentication_test_case_4),
8213 TEST_CASE_ST(ut_setup, ut_teardown,
8214 test_AES_GMAC_authentication_verify_test_case_4),
8216 /** Scatter-Gather */
8217 TEST_CASE_ST(ut_setup, ut_teardown,
8218 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8220 /** Negative tests */
8221 TEST_CASE_ST(ut_setup, ut_teardown,
8222 authentication_verify_HMAC_SHA1_fail_data_corrupt),
8223 TEST_CASE_ST(ut_setup, ut_teardown,
8224 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8225 TEST_CASE_ST(ut_setup, ut_teardown,
8226 authentication_verify_AES128_GMAC_fail_data_corrupt),
8227 TEST_CASE_ST(ut_setup, ut_teardown,
8228 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8229 TEST_CASE_ST(ut_setup, ut_teardown,
8230 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8231 TEST_CASE_ST(ut_setup, ut_teardown,
8232 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8234 TEST_CASES_END() /**< NULL terminate unit test array */
8238 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
8239 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
8240 .setup = testsuite_setup,
8241 .teardown = testsuite_teardown,
8242 .unit_test_cases = {
8243 /** AES GCM Authenticated Encryption */
8244 TEST_CASE_ST(ut_setup, ut_teardown,
8245 test_mb_AES_GCM_authenticated_encryption_test_case_1),
8246 TEST_CASE_ST(ut_setup, ut_teardown,
8247 test_mb_AES_GCM_authenticated_encryption_test_case_2),
8248 TEST_CASE_ST(ut_setup, ut_teardown,
8249 test_mb_AES_GCM_authenticated_encryption_test_case_3),
8250 TEST_CASE_ST(ut_setup, ut_teardown,
8251 test_mb_AES_GCM_authenticated_encryption_test_case_4),
8252 TEST_CASE_ST(ut_setup, ut_teardown,
8253 test_mb_AES_GCM_authenticated_encryption_test_case_5),
8254 TEST_CASE_ST(ut_setup, ut_teardown,
8255 test_mb_AES_GCM_authenticated_encryption_test_case_6),
8256 TEST_CASE_ST(ut_setup, ut_teardown,
8257 test_mb_AES_GCM_authenticated_encryption_test_case_7),
8259 /** AES GCM Authenticated Decryption */
8260 TEST_CASE_ST(ut_setup, ut_teardown,
8261 test_mb_AES_GCM_authenticated_decryption_test_case_1),
8262 TEST_CASE_ST(ut_setup, ut_teardown,
8263 test_mb_AES_GCM_authenticated_decryption_test_case_2),
8264 TEST_CASE_ST(ut_setup, ut_teardown,
8265 test_mb_AES_GCM_authenticated_decryption_test_case_3),
8266 TEST_CASE_ST(ut_setup, ut_teardown,
8267 test_mb_AES_GCM_authenticated_decryption_test_case_4),
8268 TEST_CASE_ST(ut_setup, ut_teardown,
8269 test_mb_AES_GCM_authenticated_decryption_test_case_5),
8270 TEST_CASE_ST(ut_setup, ut_teardown,
8271 test_mb_AES_GCM_authenticated_decryption_test_case_6),
8272 TEST_CASE_ST(ut_setup, ut_teardown,
8273 test_mb_AES_GCM_authenticated_decryption_test_case_7),
8275 /** AES GCM Authenticated Encryption 256 bits key */
8276 TEST_CASE_ST(ut_setup, ut_teardown,
8277 test_mb_AES_GCM_auth_encryption_test_case_256_1),
8278 TEST_CASE_ST(ut_setup, ut_teardown,
8279 test_mb_AES_GCM_auth_encryption_test_case_256_2),
8280 TEST_CASE_ST(ut_setup, ut_teardown,
8281 test_mb_AES_GCM_auth_encryption_test_case_256_3),
8282 TEST_CASE_ST(ut_setup, ut_teardown,
8283 test_mb_AES_GCM_auth_encryption_test_case_256_4),
8284 TEST_CASE_ST(ut_setup, ut_teardown,
8285 test_mb_AES_GCM_auth_encryption_test_case_256_5),
8286 TEST_CASE_ST(ut_setup, ut_teardown,
8287 test_mb_AES_GCM_auth_encryption_test_case_256_6),
8288 TEST_CASE_ST(ut_setup, ut_teardown,
8289 test_mb_AES_GCM_auth_encryption_test_case_256_7),
8291 /** AES GCM Authenticated Decryption 256 bits key */
8292 TEST_CASE_ST(ut_setup, ut_teardown,
8293 test_mb_AES_GCM_auth_decryption_test_case_256_1),
8294 TEST_CASE_ST(ut_setup, ut_teardown,
8295 test_mb_AES_GCM_auth_decryption_test_case_256_2),
8296 TEST_CASE_ST(ut_setup, ut_teardown,
8297 test_mb_AES_GCM_auth_decryption_test_case_256_3),
8298 TEST_CASE_ST(ut_setup, ut_teardown,
8299 test_mb_AES_GCM_auth_decryption_test_case_256_4),
8300 TEST_CASE_ST(ut_setup, ut_teardown,
8301 test_mb_AES_GCM_auth_decryption_test_case_256_5),
8302 TEST_CASE_ST(ut_setup, ut_teardown,
8303 test_mb_AES_GCM_auth_decryption_test_case_256_6),
8304 TEST_CASE_ST(ut_setup, ut_teardown,
8305 test_mb_AES_GCM_auth_decryption_test_case_256_7),
8307 /** AES GCM Authenticated Encryption big aad size */
8308 TEST_CASE_ST(ut_setup, ut_teardown,
8309 test_mb_AES_GCM_auth_encryption_test_case_aad_1),
8310 TEST_CASE_ST(ut_setup, ut_teardown,
8311 test_mb_AES_GCM_auth_encryption_test_case_aad_2),
8313 /** AES GCM Authenticated Decryption big aad size */
8314 TEST_CASE_ST(ut_setup, ut_teardown,
8315 test_mb_AES_GCM_auth_decryption_test_case_aad_1),
8316 TEST_CASE_ST(ut_setup, ut_teardown,
8317 test_mb_AES_GCM_auth_decryption_test_case_aad_2),
8319 /** AES GMAC Authentication */
8320 TEST_CASE_ST(ut_setup, ut_teardown,
8321 test_AES_GMAC_authentication_test_case_1),
8322 TEST_CASE_ST(ut_setup, ut_teardown,
8323 test_AES_GMAC_authentication_verify_test_case_1),
8324 TEST_CASE_ST(ut_setup, ut_teardown,
8325 test_AES_GMAC_authentication_test_case_3),
8326 TEST_CASE_ST(ut_setup, ut_teardown,
8327 test_AES_GMAC_authentication_verify_test_case_3),
8328 TEST_CASE_ST(ut_setup, ut_teardown,
8329 test_AES_GMAC_authentication_test_case_4),
8330 TEST_CASE_ST(ut_setup, ut_teardown,
8331 test_AES_GMAC_authentication_verify_test_case_4),
8333 /** Negative tests */
8334 TEST_CASE_ST(ut_setup, ut_teardown,
8335 authentication_verify_AES128_GMAC_fail_data_corrupt),
8336 TEST_CASE_ST(ut_setup, ut_teardown,
8337 authentication_verify_AES128_GMAC_fail_tag_corrupt),
8339 /** Out of place tests */
8340 TEST_CASE_ST(ut_setup, ut_teardown,
8341 test_mb_AES_GCM_authenticated_encryption_oop),
8342 TEST_CASE_ST(ut_setup, ut_teardown,
8343 test_mb_AES_GCM_authenticated_decryption_oop),
8345 /** Session-less tests */
8346 TEST_CASE_ST(ut_setup, ut_teardown,
8347 test_mb_AES_GCM_authenticated_encryption_sessionless),
8348 TEST_CASE_ST(ut_setup, ut_teardown,
8349 test_mb_AES_GCM_authenticated_decryption_sessionless),
8351 /** Scatter-Gather */
8352 TEST_CASE_ST(ut_setup, ut_teardown,
8353 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8355 TEST_CASES_END() /**< NULL terminate unit test array */
8359 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
8360 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
8361 .setup = testsuite_setup,
8362 .teardown = testsuite_teardown,
8363 .unit_test_cases = {
8364 /** KASUMI encrypt only (UEA1) */
8365 TEST_CASE_ST(ut_setup, ut_teardown,
8366 test_kasumi_encryption_test_case_1),
8367 TEST_CASE_ST(ut_setup, ut_teardown,
8368 test_kasumi_encryption_test_case_1_sgl),
8369 TEST_CASE_ST(ut_setup, ut_teardown,
8370 test_kasumi_encryption_test_case_2),
8371 TEST_CASE_ST(ut_setup, ut_teardown,
8372 test_kasumi_encryption_test_case_3),
8373 TEST_CASE_ST(ut_setup, ut_teardown,
8374 test_kasumi_encryption_test_case_4),
8375 TEST_CASE_ST(ut_setup, ut_teardown,
8376 test_kasumi_encryption_test_case_5),
8377 /** KASUMI decrypt only (UEA1) */
8378 TEST_CASE_ST(ut_setup, ut_teardown,
8379 test_kasumi_decryption_test_case_1),
8380 TEST_CASE_ST(ut_setup, ut_teardown,
8381 test_kasumi_decryption_test_case_2),
8382 TEST_CASE_ST(ut_setup, ut_teardown,
8383 test_kasumi_decryption_test_case_3),
8384 TEST_CASE_ST(ut_setup, ut_teardown,
8385 test_kasumi_decryption_test_case_4),
8386 TEST_CASE_ST(ut_setup, ut_teardown,
8387 test_kasumi_decryption_test_case_5),
8389 TEST_CASE_ST(ut_setup, ut_teardown,
8390 test_kasumi_encryption_test_case_1_oop),
8391 TEST_CASE_ST(ut_setup, ut_teardown,
8392 test_kasumi_encryption_test_case_1_oop_sgl),
8395 TEST_CASE_ST(ut_setup, ut_teardown,
8396 test_kasumi_decryption_test_case_1_oop),
8398 /** KASUMI hash only (UIA1) */
8399 TEST_CASE_ST(ut_setup, ut_teardown,
8400 test_kasumi_hash_generate_test_case_1),
8401 TEST_CASE_ST(ut_setup, ut_teardown,
8402 test_kasumi_hash_generate_test_case_2),
8403 TEST_CASE_ST(ut_setup, ut_teardown,
8404 test_kasumi_hash_generate_test_case_3),
8405 TEST_CASE_ST(ut_setup, ut_teardown,
8406 test_kasumi_hash_generate_test_case_4),
8407 TEST_CASE_ST(ut_setup, ut_teardown,
8408 test_kasumi_hash_generate_test_case_5),
8409 TEST_CASE_ST(ut_setup, ut_teardown,
8410 test_kasumi_hash_generate_test_case_6),
8411 TEST_CASE_ST(ut_setup, ut_teardown,
8412 test_kasumi_hash_verify_test_case_1),
8413 TEST_CASE_ST(ut_setup, ut_teardown,
8414 test_kasumi_hash_verify_test_case_2),
8415 TEST_CASE_ST(ut_setup, ut_teardown,
8416 test_kasumi_hash_verify_test_case_3),
8417 TEST_CASE_ST(ut_setup, ut_teardown,
8418 test_kasumi_hash_verify_test_case_4),
8419 TEST_CASE_ST(ut_setup, ut_teardown,
8420 test_kasumi_hash_verify_test_case_5),
8421 TEST_CASE_ST(ut_setup, ut_teardown,
8422 test_kasumi_auth_cipher_test_case_1),
8423 TEST_CASE_ST(ut_setup, ut_teardown,
8424 test_kasumi_cipher_auth_test_case_1),
8425 TEST_CASES_END() /**< NULL terminate unit test array */
8428 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
8429 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
8430 .setup = testsuite_setup,
8431 .teardown = testsuite_teardown,
8432 .unit_test_cases = {
8433 /** SNOW 3G encrypt only (UEA2) */
8434 TEST_CASE_ST(ut_setup, ut_teardown,
8435 test_snow3g_encryption_test_case_1),
8436 TEST_CASE_ST(ut_setup, ut_teardown,
8437 test_snow3g_encryption_test_case_2),
8438 TEST_CASE_ST(ut_setup, ut_teardown,
8439 test_snow3g_encryption_test_case_3),
8440 TEST_CASE_ST(ut_setup, ut_teardown,
8441 test_snow3g_encryption_test_case_4),
8442 TEST_CASE_ST(ut_setup, ut_teardown,
8443 test_snow3g_encryption_test_case_5),
8445 TEST_CASE_ST(ut_setup, ut_teardown,
8446 test_snow3g_encryption_test_case_1_oop),
8447 TEST_CASE_ST(ut_setup, ut_teardown,
8448 test_snow3g_encryption_test_case_1_oop_sgl),
8449 TEST_CASE_ST(ut_setup, ut_teardown,
8450 test_snow3g_decryption_test_case_1_oop),
8452 TEST_CASE_ST(ut_setup, ut_teardown,
8453 test_snow3g_encryption_test_case_1_offset_oop),
8455 /** SNOW 3G decrypt only (UEA2) */
8456 TEST_CASE_ST(ut_setup, ut_teardown,
8457 test_snow3g_decryption_test_case_1),
8458 TEST_CASE_ST(ut_setup, ut_teardown,
8459 test_snow3g_decryption_test_case_2),
8460 TEST_CASE_ST(ut_setup, ut_teardown,
8461 test_snow3g_decryption_test_case_3),
8462 TEST_CASE_ST(ut_setup, ut_teardown,
8463 test_snow3g_decryption_test_case_4),
8464 TEST_CASE_ST(ut_setup, ut_teardown,
8465 test_snow3g_decryption_test_case_5),
8466 TEST_CASE_ST(ut_setup, ut_teardown,
8467 test_snow3g_hash_generate_test_case_1),
8468 TEST_CASE_ST(ut_setup, ut_teardown,
8469 test_snow3g_hash_generate_test_case_2),
8470 TEST_CASE_ST(ut_setup, ut_teardown,
8471 test_snow3g_hash_generate_test_case_3),
8472 /* Tests with buffers which length is not byte-aligned */
8473 TEST_CASE_ST(ut_setup, ut_teardown,
8474 test_snow3g_hash_generate_test_case_4),
8475 TEST_CASE_ST(ut_setup, ut_teardown,
8476 test_snow3g_hash_generate_test_case_5),
8477 TEST_CASE_ST(ut_setup, ut_teardown,
8478 test_snow3g_hash_generate_test_case_6),
8479 TEST_CASE_ST(ut_setup, ut_teardown,
8480 test_snow3g_hash_verify_test_case_1),
8481 TEST_CASE_ST(ut_setup, ut_teardown,
8482 test_snow3g_hash_verify_test_case_2),
8483 TEST_CASE_ST(ut_setup, ut_teardown,
8484 test_snow3g_hash_verify_test_case_3),
8485 /* Tests with buffers which length is not byte-aligned */
8486 TEST_CASE_ST(ut_setup, ut_teardown,
8487 test_snow3g_hash_verify_test_case_4),
8488 TEST_CASE_ST(ut_setup, ut_teardown,
8489 test_snow3g_hash_verify_test_case_5),
8490 TEST_CASE_ST(ut_setup, ut_teardown,
8491 test_snow3g_hash_verify_test_case_6),
8492 TEST_CASE_ST(ut_setup, ut_teardown,
8493 test_snow3g_cipher_auth_test_case_1),
8494 TEST_CASE_ST(ut_setup, ut_teardown,
8495 test_snow3g_auth_cipher_test_case_1),
8497 TEST_CASES_END() /**< NULL terminate unit test array */
8501 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
8502 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
8503 .setup = testsuite_setup,
8504 .teardown = testsuite_teardown,
8505 .unit_test_cases = {
8506 /** ZUC encrypt only (EEA3) */
8507 TEST_CASE_ST(ut_setup, ut_teardown,
8508 test_zuc_encryption_test_case_1),
8509 TEST_CASE_ST(ut_setup, ut_teardown,
8510 test_zuc_encryption_test_case_2),
8511 TEST_CASE_ST(ut_setup, ut_teardown,
8512 test_zuc_encryption_test_case_3),
8513 TEST_CASE_ST(ut_setup, ut_teardown,
8514 test_zuc_encryption_test_case_4),
8515 TEST_CASE_ST(ut_setup, ut_teardown,
8516 test_zuc_encryption_test_case_5),
8517 TEST_CASE_ST(ut_setup, ut_teardown,
8518 test_zuc_hash_generate_test_case_1),
8519 TEST_CASE_ST(ut_setup, ut_teardown,
8520 test_zuc_hash_generate_test_case_2),
8521 TEST_CASE_ST(ut_setup, ut_teardown,
8522 test_zuc_hash_generate_test_case_3),
8523 TEST_CASE_ST(ut_setup, ut_teardown,
8524 test_zuc_hash_generate_test_case_4),
8525 TEST_CASE_ST(ut_setup, ut_teardown,
8526 test_zuc_hash_generate_test_case_5),
8527 TEST_CASE_ST(ut_setup, ut_teardown,
8528 test_zuc_encryption_test_case_6_sgl),
8529 TEST_CASES_END() /**< NULL terminate unit test array */
8533 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
8534 .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
8535 .setup = testsuite_setup,
8536 .teardown = testsuite_teardown,
8537 .unit_test_cases = {
8538 TEST_CASE_ST(ut_setup, ut_teardown,
8539 test_device_configure_invalid_dev_id),
8540 TEST_CASE_ST(ut_setup, ut_teardown,
8541 test_multi_session),
8543 TEST_CASE_ST(ut_setup, ut_teardown,
8544 test_AES_chain_dpaa2_sec_all),
8545 TEST_CASE_ST(ut_setup, ut_teardown,
8546 test_3DES_chain_dpaa2_sec_all),
8547 TEST_CASE_ST(ut_setup, ut_teardown,
8548 test_AES_cipheronly_dpaa2_sec_all),
8549 TEST_CASE_ST(ut_setup, ut_teardown,
8550 test_3DES_cipheronly_dpaa2_sec_all),
8552 /** HMAC_MD5 Authentication */
8553 TEST_CASE_ST(ut_setup, ut_teardown,
8554 test_MD5_HMAC_generate_case_1),
8555 TEST_CASE_ST(ut_setup, ut_teardown,
8556 test_MD5_HMAC_verify_case_1),
8557 TEST_CASE_ST(ut_setup, ut_teardown,
8558 test_MD5_HMAC_generate_case_2),
8559 TEST_CASE_ST(ut_setup, ut_teardown,
8560 test_MD5_HMAC_verify_case_2),
8562 TEST_CASES_END() /**< NULL terminate unit test array */
8566 static struct unit_test_suite cryptodev_null_testsuite = {
8567 .suite_name = "Crypto Device NULL Unit Test Suite",
8568 .setup = testsuite_setup,
8569 .teardown = testsuite_teardown,
8570 .unit_test_cases = {
8571 TEST_CASE_ST(ut_setup, ut_teardown,
8572 test_null_auth_only_operation),
8573 TEST_CASE_ST(ut_setup, ut_teardown,
8574 test_null_cipher_only_operation),
8575 TEST_CASE_ST(ut_setup, ut_teardown,
8576 test_null_cipher_auth_operation),
8577 TEST_CASE_ST(ut_setup, ut_teardown,
8578 test_null_auth_cipher_operation),
8579 TEST_CASE_ST(ut_setup, ut_teardown,
8580 test_null_invalid_operation),
8581 TEST_CASE_ST(ut_setup, ut_teardown,
8582 test_null_burst_operation),
8584 TEST_CASES_END() /**< NULL terminate unit test array */
8588 static struct unit_test_suite cryptodev_armv8_testsuite = {
8589 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
8590 .setup = testsuite_setup,
8591 .teardown = testsuite_teardown,
8592 .unit_test_cases = {
8593 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
8595 /** Negative tests */
8596 TEST_CASE_ST(ut_setup, ut_teardown,
8597 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8598 TEST_CASE_ST(ut_setup, ut_teardown,
8599 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8601 TEST_CASES_END() /**< NULL terminate unit test array */
8606 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
8608 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
8609 return unit_test_suite_runner(&cryptodev_qat_testsuite);
8613 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
8615 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
8617 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
8621 test_cryptodev_openssl(void)
8623 gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
8625 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
8629 test_cryptodev_aesni_gcm(void)
8631 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
8633 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
8637 test_cryptodev_null(void)
8639 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
8641 return unit_test_suite_runner(&cryptodev_null_testsuite);
8645 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
8647 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
8649 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
8653 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
8655 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
8657 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
8661 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
8663 gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
8665 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
8669 test_cryptodev_armv8(void)
8671 gbl_cryptodev_type = RTE_CRYPTODEV_ARMV8_PMD;
8673 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
8676 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
8679 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
8681 gbl_cryptodev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
8682 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
8685 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
8690 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
8692 gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD;
8693 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
8696 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
8697 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
8698 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
8699 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
8700 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
8701 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
8702 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
8703 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
8704 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
8705 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);