4 * Copyright(c) 2015-2016 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>
44 #include "test_cryptodev.h"
46 #include "test_cryptodev_blockcipher.h"
47 #include "test_cryptodev_aes_test_vectors.h"
48 #include "test_cryptodev_des_test_vectors.h"
49 #include "test_cryptodev_hash_test_vectors.h"
50 #include "test_cryptodev_kasumi_test_vectors.h"
51 #include "test_cryptodev_kasumi_hash_test_vectors.h"
52 #include "test_cryptodev_snow3g_test_vectors.h"
53 #include "test_cryptodev_snow3g_hash_test_vectors.h"
54 #include "test_cryptodev_zuc_test_vectors.h"
55 #include "test_cryptodev_zuc_hash_test_vectors.h"
56 #include "test_cryptodev_gcm_test_vectors.h"
57 #include "test_cryptodev_hmac_test_vectors.h"
59 static enum rte_cryptodev_type gbl_cryptodev_type;
61 struct crypto_testsuite_params {
62 struct rte_mempool *mbuf_pool;
63 struct rte_mempool *large_mbuf_pool;
64 struct rte_mempool *op_mpool;
65 struct rte_cryptodev_config conf;
66 struct rte_cryptodev_qp_conf qp_conf;
68 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
69 uint8_t valid_dev_count;
72 struct crypto_unittest_params {
73 struct rte_crypto_sym_xform cipher_xform;
74 struct rte_crypto_sym_xform auth_xform;
76 struct rte_cryptodev_sym_session *sess;
78 struct rte_crypto_op *op;
80 struct rte_mbuf *obuf, *ibuf;
85 #define ALIGN_POW2_ROUNDUP(num, align) \
86 (((num) + (align) - 1) & ~((align) - 1))
89 * Forward declarations.
92 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
93 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
97 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
98 struct crypto_unittest_params *ut_params,
99 struct crypto_testsuite_params *ts_param,
100 const uint8_t *cipher,
101 const uint8_t *digest,
104 static struct rte_mbuf *
105 setup_test_string(struct rte_mempool *mpool,
106 const char *string, size_t len, uint8_t blocksize)
108 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
109 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
111 memset(m->buf_addr, 0, m->buf_len);
113 char *dst = rte_pktmbuf_append(m, t_len);
120 rte_memcpy(dst, string, t_len);
122 memset(dst, 0, t_len);
128 /* Get number of bytes in X bits (rounding up) */
130 ceil_byte_length(uint32_t num_bits)
133 return ((num_bits >> 3) + 1);
135 return (num_bits >> 3);
138 static struct rte_crypto_op *
139 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
141 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
142 printf("Error sending packet for encryption");
148 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
154 static struct crypto_testsuite_params testsuite_params = { NULL };
155 static struct crypto_unittest_params unittest_params;
158 testsuite_setup(void)
160 struct crypto_testsuite_params *ts_params = &testsuite_params;
161 struct rte_cryptodev_info info;
162 unsigned i, nb_devs, dev_id;
166 memset(ts_params, 0, sizeof(*ts_params));
168 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
169 if (ts_params->mbuf_pool == NULL) {
170 /* Not already created so create */
171 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
173 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
175 if (ts_params->mbuf_pool == NULL) {
176 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
181 ts_params->large_mbuf_pool = rte_mempool_lookup(
182 "CRYPTO_LARGE_MBUFPOOL");
183 if (ts_params->large_mbuf_pool == NULL) {
184 /* Not already created so create */
185 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
186 "CRYPTO_LARGE_MBUFPOOL",
189 if (ts_params->large_mbuf_pool == NULL) {
191 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
196 ts_params->op_mpool = rte_crypto_op_pool_create(
197 "MBUF_CRYPTO_SYM_OP_POOL",
198 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
199 NUM_MBUFS, MBUF_CACHE_SIZE,
201 sizeof(struct rte_crypto_sym_xform),
203 if (ts_params->op_mpool == NULL) {
204 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
208 /* Create 2 AESNI MB devices if required */
209 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
210 #ifndef RTE_LIBRTE_PMD_AESNI_MB
211 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
212 " enabled in config file to run this testsuite.\n");
215 nb_devs = rte_cryptodev_count_devtype(
216 RTE_CRYPTODEV_AESNI_MB_PMD);
218 for (i = nb_devs; i < 2; i++) {
219 ret = rte_eal_vdev_init(
220 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
222 TEST_ASSERT(ret == 0,
223 "Failed to create instance %u of"
225 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
230 /* Create 2 AESNI GCM devices if required */
231 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
232 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
233 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
234 " enabled in config file to run this testsuite.\n");
237 nb_devs = rte_cryptodev_count_devtype(
238 RTE_CRYPTODEV_AESNI_GCM_PMD);
240 for (i = nb_devs; i < 2; i++) {
241 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
242 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
243 "Failed to create instance %u of"
245 i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
250 /* Create 2 SNOW 3G devices 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 for (i = nb_devs; i < 2; i++) {
260 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
261 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
262 "Failed to create instance %u of"
264 i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
269 /* Create 2 KASUMI devices if required */
270 if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
271 #ifndef RTE_LIBRTE_PMD_KASUMI
272 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
273 " enabled in config file to run this testsuite.\n");
276 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
278 for (i = nb_devs; i < 2; i++) {
279 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
280 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
281 "Failed to create instance %u of"
283 i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
288 /* Create 2 ZUC devices if required */
289 if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
290 #ifndef RTE_LIBRTE_PMD_ZUC
291 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
292 " enabled in config file to run this testsuite.\n");
295 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
297 for (i = nb_devs; i < 2; i++) {
298 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
299 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
300 "Failed to create instance %u of"
302 i, RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
307 /* Create 2 NULL devices if required */
308 if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
309 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
310 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
311 " enabled in config file to run this testsuite.\n");
314 nb_devs = rte_cryptodev_count_devtype(
315 RTE_CRYPTODEV_NULL_PMD);
317 for (i = nb_devs; i < 2; i++) {
318 int dev_id = rte_eal_vdev_init(
319 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
321 TEST_ASSERT(dev_id >= 0,
322 "Failed to create instance %u of"
324 i, RTE_STR(CRYPTODEV_NAME_NULL_PMD));
329 /* Create 2 OPENSSL devices if required */
330 if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
331 #ifndef RTE_LIBRTE_PMD_OPENSSL
332 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
333 " enabled in config file to run this testsuite.\n");
336 nb_devs = rte_cryptodev_count_devtype(
337 RTE_CRYPTODEV_OPENSSL_PMD);
339 for (i = nb_devs; i < 2; i++) {
340 ret = rte_eal_vdev_init(
341 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
344 TEST_ASSERT(ret == 0, "Failed to create "
345 "instance %u of pmd : %s", i,
346 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
351 #ifndef RTE_LIBRTE_PMD_QAT
352 if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
353 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
354 "in config file to run this testsuite.\n");
359 nb_devs = rte_cryptodev_count();
361 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
365 /* Create list of valid crypto devs */
366 for (i = 0; i < nb_devs; i++) {
367 rte_cryptodev_info_get(i, &info);
368 if (info.dev_type == gbl_cryptodev_type)
369 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
372 if (ts_params->valid_dev_count < 1)
375 /* Set up all the qps on the first of the valid devices found */
377 dev_id = ts_params->valid_devs[0];
379 rte_cryptodev_info_get(dev_id, &info);
381 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
382 ts_params->conf.socket_id = SOCKET_ID_ANY;
383 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
385 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
387 "Failed to configure cryptodev %u with %u qps",
388 dev_id, ts_params->conf.nb_queue_pairs);
390 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
392 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
393 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
394 dev_id, qp_id, &ts_params->qp_conf,
395 rte_cryptodev_socket_id(dev_id)),
396 "Failed to setup queue pair %u on cryptodev %u",
404 testsuite_teardown(void)
406 struct crypto_testsuite_params *ts_params = &testsuite_params;
408 if (ts_params->mbuf_pool != NULL) {
409 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
410 rte_mempool_avail_count(ts_params->mbuf_pool));
413 if (ts_params->op_mpool != NULL) {
414 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
415 rte_mempool_avail_count(ts_params->op_mpool));
423 struct crypto_testsuite_params *ts_params = &testsuite_params;
424 struct crypto_unittest_params *ut_params = &unittest_params;
428 /* Clear unit test parameters before running test */
429 memset(ut_params, 0, sizeof(*ut_params));
431 /* Reconfigure device to default parameters */
432 ts_params->conf.socket_id = SOCKET_ID_ANY;
433 ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
435 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
437 "Failed to configure cryptodev %u",
438 ts_params->valid_devs[0]);
440 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
441 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
442 ts_params->valid_devs[0], qp_id,
444 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
445 "Failed to setup queue pair %u on cryptodev %u",
446 qp_id, ts_params->valid_devs[0]);
450 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
452 /* Start the device */
453 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
454 "Failed to start cryptodev %u",
455 ts_params->valid_devs[0]);
463 struct crypto_testsuite_params *ts_params = &testsuite_params;
464 struct crypto_unittest_params *ut_params = &unittest_params;
465 struct rte_cryptodev_stats stats;
467 /* free crypto session structure */
468 if (ut_params->sess) {
469 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
471 ut_params->sess = NULL;
474 /* free crypto operation structure */
476 rte_crypto_op_free(ut_params->op);
479 * free mbuf - both obuf and ibuf are usually the same,
480 * so check if they point at the same address is necessary,
481 * to avoid freeing the mbuf twice.
483 if (ut_params->obuf) {
484 rte_pktmbuf_free(ut_params->obuf);
485 if (ut_params->ibuf == ut_params->obuf)
489 if (ut_params->ibuf) {
490 rte_pktmbuf_free(ut_params->ibuf);
494 if (ts_params->mbuf_pool != NULL)
495 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
496 rte_mempool_avail_count(ts_params->mbuf_pool));
498 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
500 /* Stop the device */
501 rte_cryptodev_stop(ts_params->valid_devs[0]);
505 test_device_configure_invalid_dev_id(void)
507 struct crypto_testsuite_params *ts_params = &testsuite_params;
508 uint16_t dev_id, num_devs = 0;
510 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
511 "Need at least %d devices for test", 1);
513 /* valid dev_id values */
514 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
516 /* Stop the device in case it's started so it can be configured */
517 rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
519 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
520 "Failed test for rte_cryptodev_configure: "
521 "invalid dev_num %u", dev_id);
523 /* invalid dev_id values */
526 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
527 "Failed test for rte_cryptodev_configure: "
528 "invalid dev_num %u", dev_id);
532 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
533 "Failed test for rte_cryptodev_configure:"
534 "invalid dev_num %u", dev_id);
540 test_device_configure_invalid_queue_pair_ids(void)
542 struct crypto_testsuite_params *ts_params = &testsuite_params;
543 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
545 /* Stop the device in case it's started so it can be configured */
546 rte_cryptodev_stop(ts_params->valid_devs[0]);
548 /* valid - one queue pairs */
549 ts_params->conf.nb_queue_pairs = 1;
551 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
553 "Failed to configure cryptodev: dev_id %u, qp_id %u",
554 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
557 /* valid - max value queue pairs */
558 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
560 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
562 "Failed to configure cryptodev: dev_id %u, qp_id %u",
563 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
566 /* invalid - zero queue pairs */
567 ts_params->conf.nb_queue_pairs = 0;
569 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
571 "Failed test for rte_cryptodev_configure, dev_id %u,"
573 ts_params->valid_devs[0],
574 ts_params->conf.nb_queue_pairs);
577 /* invalid - max value supported by field queue pairs */
578 ts_params->conf.nb_queue_pairs = UINT16_MAX;
580 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
582 "Failed test for rte_cryptodev_configure, dev_id %u,"
584 ts_params->valid_devs[0],
585 ts_params->conf.nb_queue_pairs);
588 /* invalid - max value + 1 queue pairs */
589 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
591 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
593 "Failed test for rte_cryptodev_configure, dev_id %u,"
595 ts_params->valid_devs[0],
596 ts_params->conf.nb_queue_pairs);
598 /* revert to original testsuite value */
599 ts_params->conf.nb_queue_pairs = orig_nb_qps;
605 test_queue_pair_descriptor_setup(void)
607 struct crypto_testsuite_params *ts_params = &testsuite_params;
608 struct rte_cryptodev_info dev_info;
609 struct rte_cryptodev_qp_conf qp_conf = {
610 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
615 /* Stop the device in case it's started so it can be configured */
616 rte_cryptodev_stop(ts_params->valid_devs[0]);
619 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
621 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
623 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
624 &ts_params->conf), "Failed to configure cryptodev %u",
625 ts_params->valid_devs[0]);
629 * Test various ring sizes on this device. memzones can't be
630 * freed so are re-used if ring is released and re-created.
632 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
634 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
635 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
636 ts_params->valid_devs[0], qp_id, &qp_conf,
637 rte_cryptodev_socket_id(
638 ts_params->valid_devs[0])),
640 "rte_cryptodev_queue_pair_setup: num_inflights "
641 "%u on qp %u on cryptodev %u",
642 qp_conf.nb_descriptors, qp_id,
643 ts_params->valid_devs[0]);
646 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
648 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
649 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
650 ts_params->valid_devs[0], qp_id, &qp_conf,
651 rte_cryptodev_socket_id(
652 ts_params->valid_devs[0])),
654 " rte_cryptodev_queue_pair_setup: num_inflights"
655 " %u on qp %u on cryptodev %u",
656 qp_conf.nb_descriptors, qp_id,
657 ts_params->valid_devs[0]);
660 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
662 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
663 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
664 ts_params->valid_devs[0], qp_id, &qp_conf,
665 rte_cryptodev_socket_id(
666 ts_params->valid_devs[0])),
668 "rte_cryptodev_queue_pair_setup: num_inflights"
669 " %u on qp %u on cryptodev %u",
670 qp_conf.nb_descriptors, qp_id,
671 ts_params->valid_devs[0]);
674 /* invalid number of descriptors - max supported + 2 */
675 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
677 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
678 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
679 ts_params->valid_devs[0], qp_id, &qp_conf,
680 rte_cryptodev_socket_id(
681 ts_params->valid_devs[0])),
682 "Unexpectedly passed test for "
683 "rte_cryptodev_queue_pair_setup:"
684 "num_inflights %u on qp %u on cryptodev %u",
685 qp_conf.nb_descriptors, qp_id,
686 ts_params->valid_devs[0]);
689 /* invalid number of descriptors - max value of parameter */
690 qp_conf.nb_descriptors = UINT32_MAX-1;
692 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
693 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
694 ts_params->valid_devs[0], qp_id, &qp_conf,
695 rte_cryptodev_socket_id(
696 ts_params->valid_devs[0])),
697 "Unexpectedly passed test for "
698 "rte_cryptodev_queue_pair_setup:"
699 "num_inflights %u on qp %u on cryptodev %u",
700 qp_conf.nb_descriptors, qp_id,
701 ts_params->valid_devs[0]);
704 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
706 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
707 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
708 ts_params->valid_devs[0], qp_id, &qp_conf,
709 rte_cryptodev_socket_id(
710 ts_params->valid_devs[0])),
712 " rte_cryptodev_queue_pair_setup:"
713 "num_inflights %u on qp %u on cryptodev %u",
714 qp_conf.nb_descriptors, qp_id,
715 ts_params->valid_devs[0]);
718 /* invalid number of descriptors - max supported + 1 */
719 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
721 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
722 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
723 ts_params->valid_devs[0], qp_id, &qp_conf,
724 rte_cryptodev_socket_id(
725 ts_params->valid_devs[0])),
726 "Unexpectedly passed test for "
727 "rte_cryptodev_queue_pair_setup:"
728 "num_inflights %u on qp %u on cryptodev %u",
729 qp_conf.nb_descriptors, qp_id,
730 ts_params->valid_devs[0]);
733 /* test invalid queue pair id */
734 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
736 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */
738 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
739 ts_params->valid_devs[0],
741 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
742 "Failed test for rte_cryptodev_queue_pair_setup:"
743 "invalid qp %u on cryptodev %u",
744 qp_id, ts_params->valid_devs[0]);
746 qp_id = 0xffff; /*invalid*/
748 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
749 ts_params->valid_devs[0],
751 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
752 "Failed test for rte_cryptodev_queue_pair_setup:"
753 "invalid qp %u on cryptodev %u",
754 qp_id, ts_params->valid_devs[0]);
759 /* ***** Plaintext data for tests ***** */
761 const char catch_22_quote_1[] =
762 "There was only one catch and that was Catch-22, which "
763 "specified that a concern for one's safety in the face of "
764 "dangers that were real and immediate was the process of a "
765 "rational mind. Orr was crazy and could be grounded. All he "
766 "had to do was ask; and as soon as he did, he would no longer "
767 "be crazy and would have to fly more missions. Orr would be "
768 "crazy to fly more missions and sane if he didn't, but if he "
769 "was sane he had to fly them. If he flew them he was crazy "
770 "and didn't have to; but if he didn't want to he was sane and "
771 "had to. Yossarian was moved very deeply by the absolute "
772 "simplicity of this clause of Catch-22 and let out a "
773 "respectful whistle. \"That's some catch, that Catch-22\", he "
774 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
776 const char catch_22_quote[] =
777 "What a lousy earth! He wondered how many people were "
778 "destitute that same night even in his own prosperous country, "
779 "how many homes were shanties, how many husbands were drunk "
780 "and wives socked, and how many children were bullied, abused, "
781 "or abandoned. How many families hungered for food they could "
782 "not afford to buy? How many hearts were broken? How many "
783 "suicides would take place that same night, how many people "
784 "would go insane? How many cockroaches and landlords would "
785 "triumph? How many winners were losers, successes failures, "
786 "and rich men poor men? How many wise guys were stupid? How "
787 "many happy endings were unhappy endings? How many honest men "
788 "were liars, brave men cowards, loyal men traitors, how many "
789 "sainted men were corrupt, how many people in positions of "
790 "trust had sold their souls to bodyguards, how many had never "
791 "had souls? How many straight-and-narrow paths were crooked "
792 "paths? How many best families were worst families and how "
793 "many good people were bad people? When you added them all up "
794 "and then subtracted, you might be left with only the children, "
795 "and perhaps with Albert Einstein and an old violinist or "
796 "sculptor somewhere.";
798 #define QUOTE_480_BYTES (480)
799 #define QUOTE_512_BYTES (512)
800 #define QUOTE_768_BYTES (768)
801 #define QUOTE_1024_BYTES (1024)
805 /* ***** SHA1 Hash Tests ***** */
807 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
809 static uint8_t hmac_sha1_key[] = {
810 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
811 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
812 0xDE, 0xF4, 0xDE, 0xAD };
814 /* ***** SHA224 Hash Tests ***** */
816 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
819 /* ***** AES-CBC Cipher Tests ***** */
821 #define CIPHER_KEY_LENGTH_AES_CBC (16)
822 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
824 static uint8_t aes_cbc_key[] = {
825 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
826 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
828 static uint8_t aes_cbc_iv[] = {
829 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
830 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
833 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
835 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
836 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
837 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
838 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
839 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
840 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
841 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
842 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
843 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
844 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
845 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
846 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
847 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
848 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
849 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
850 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
851 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
852 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
853 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
854 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
855 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
856 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
857 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
858 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
859 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
860 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
861 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
862 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
863 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
864 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
865 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
866 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
867 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
868 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
869 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
870 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
871 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
872 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
873 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
874 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
875 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
876 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
877 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
878 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
879 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
880 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
881 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
882 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
883 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
884 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
885 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
886 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
887 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
888 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
889 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
890 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
891 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
892 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
893 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
894 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
895 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
896 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
897 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
898 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
899 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
902 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
903 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
904 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
905 0x18, 0x8c, 0x1d, 0x32
909 /* Multisession Vector context Test */
911 static uint8_t ms_aes_cbc_key0[] = {
912 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
913 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
916 static uint8_t ms_aes_cbc_iv0[] = {
917 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
918 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
921 static const uint8_t ms_aes_cbc_cipher0[] = {
922 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
923 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
924 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
925 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
926 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
927 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
928 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
929 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
930 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
931 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
932 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
933 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
934 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
935 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
936 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
937 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
938 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
939 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
940 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
941 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
942 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
943 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
944 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
945 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
946 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
947 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
948 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
949 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
950 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
951 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
952 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
953 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
954 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
955 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
956 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
957 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
958 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
959 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
960 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
961 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
962 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
963 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
964 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
965 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
966 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
967 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
968 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
969 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
970 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
971 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
972 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
973 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
974 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
975 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
976 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
977 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
978 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
979 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
980 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
981 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
982 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
983 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
984 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
985 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
989 static uint8_t ms_hmac_key0[] = {
990 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
991 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
992 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
993 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
994 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
995 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
996 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
997 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1000 static const uint8_t ms_hmac_digest0[] = {
1001 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1002 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1003 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1004 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1005 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1006 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1007 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1008 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1012 /* Begin session 1 */
1014 static uint8_t ms_aes_cbc_key1[] = {
1015 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1016 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1019 static uint8_t ms_aes_cbc_iv1[] = {
1020 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1021 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1024 static const uint8_t ms_aes_cbc_cipher1[] = {
1025 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1026 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1027 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1028 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1029 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1030 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1031 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1032 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1033 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1034 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1035 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1036 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1037 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1038 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1039 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1040 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1041 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1042 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1043 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1044 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1045 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1046 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1047 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1048 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1049 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1050 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1051 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1052 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1053 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1054 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1055 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1056 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1057 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1058 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1059 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1060 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1061 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1062 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1063 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1064 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1065 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1066 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1067 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1068 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1069 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1070 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1071 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1072 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1073 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1074 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1075 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1076 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1077 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1078 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1079 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1080 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1081 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1082 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1083 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1084 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1085 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1086 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1087 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1088 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1092 static uint8_t ms_hmac_key1[] = {
1093 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1094 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1095 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1096 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1097 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1098 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1099 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1100 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1103 static const uint8_t ms_hmac_digest1[] = {
1104 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1105 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1106 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1107 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1108 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1109 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1110 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1111 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1114 /* Begin Session 2 */
1115 static uint8_t ms_aes_cbc_key2[] = {
1116 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1117 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1120 static uint8_t ms_aes_cbc_iv2[] = {
1121 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1122 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1125 static const uint8_t ms_aes_cbc_cipher2[] = {
1126 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1127 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1128 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1129 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1130 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1131 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1132 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1133 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1134 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1135 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1136 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1137 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1138 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1139 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1140 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1141 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1142 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1143 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1144 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1145 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1146 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1147 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1148 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1149 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1150 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1151 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1152 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1153 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1154 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1155 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1156 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1157 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1158 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1159 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1160 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1161 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1162 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1163 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1164 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1165 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1166 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1167 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1168 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1169 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1170 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1171 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1172 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1173 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1174 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1175 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1176 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1177 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1178 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1179 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1180 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1181 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1182 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1183 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1184 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1185 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1186 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1187 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1188 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1189 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1192 static uint8_t ms_hmac_key2[] = {
1193 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1194 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1195 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1196 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1197 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1198 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1199 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1200 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1203 static const uint8_t ms_hmac_digest2[] = {
1204 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1205 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1206 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1207 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1208 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1209 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1210 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1211 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1218 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1220 struct crypto_testsuite_params *ts_params = &testsuite_params;
1221 struct crypto_unittest_params *ut_params = &unittest_params;
1223 /* Generate test mbuf data and space for digest */
1224 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1225 catch_22_quote, QUOTE_512_BYTES, 0);
1227 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1228 DIGEST_BYTE_LENGTH_SHA1);
1229 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1231 /* Setup Cipher Parameters */
1232 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1233 ut_params->cipher_xform.next = &ut_params->auth_xform;
1235 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1236 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1237 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1238 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1240 /* Setup HMAC Parameters */
1241 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1243 ut_params->auth_xform.next = NULL;
1245 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1246 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1247 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1248 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1249 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1251 /* Create crypto session*/
1252 ut_params->sess = rte_cryptodev_sym_session_create(
1253 ts_params->valid_devs[0],
1254 &ut_params->cipher_xform);
1255 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1257 /* Generate crypto op data structure */
1258 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1259 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1260 TEST_ASSERT_NOT_NULL(ut_params->op,
1261 "Failed to allocate symmetric crypto operation struct");
1263 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1265 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1267 /* set crypto operation source mbuf */
1268 sym_op->m_src = ut_params->ibuf;
1270 /* Set crypto operation authentication parameters */
1271 sym_op->auth.digest.data = ut_params->digest;
1272 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1273 ut_params->ibuf, QUOTE_512_BYTES);
1274 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1276 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1277 sym_op->auth.data.length = QUOTE_512_BYTES;
1279 /* Set crypto operation cipher parameters */
1280 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1281 CIPHER_IV_LENGTH_AES_CBC);
1282 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1283 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1285 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1286 CIPHER_IV_LENGTH_AES_CBC);
1288 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1289 sym_op->cipher.data.length = QUOTE_512_BYTES;
1291 /* Process crypto operation */
1292 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1293 ut_params->op), "failed to process sym crypto op");
1295 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1296 "crypto op processing failed");
1299 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1300 uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1302 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1303 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1305 "ciphertext data not as expected");
1307 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1309 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1310 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1311 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1312 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1313 DIGEST_BYTE_LENGTH_SHA1,
1314 "Generated digest data not as expected");
1316 return TEST_SUCCESS;
1319 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1321 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1323 static uint8_t hmac_sha512_key[] = {
1324 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1325 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1326 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1327 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1328 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1329 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1330 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1331 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1333 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1334 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1335 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1336 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1337 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1338 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1339 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1340 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1341 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1346 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1347 struct crypto_unittest_params *ut_params,
1348 uint8_t *cipher_key,
1352 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1353 struct crypto_unittest_params *ut_params,
1354 struct crypto_testsuite_params *ts_params,
1355 const uint8_t *cipher,
1356 const uint8_t *digest,
1361 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1362 struct crypto_unittest_params *ut_params,
1363 uint8_t *cipher_key,
1367 /* Setup Cipher Parameters */
1368 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1369 ut_params->cipher_xform.next = NULL;
1371 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1372 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1373 ut_params->cipher_xform.cipher.key.data = cipher_key;
1374 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1376 /* Setup HMAC Parameters */
1377 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1378 ut_params->auth_xform.next = &ut_params->cipher_xform;
1380 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1381 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1382 ut_params->auth_xform.auth.key.data = hmac_key;
1383 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1384 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1386 return TEST_SUCCESS;
1391 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1392 struct crypto_unittest_params *ut_params,
1393 struct crypto_testsuite_params *ts_params,
1394 const uint8_t *cipher,
1395 const uint8_t *digest,
1398 /* Generate test mbuf data and digest */
1399 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1402 QUOTE_512_BYTES, 0);
1404 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1405 DIGEST_BYTE_LENGTH_SHA512);
1406 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1408 rte_memcpy(ut_params->digest,
1410 DIGEST_BYTE_LENGTH_SHA512);
1412 /* Generate Crypto op data structure */
1413 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1414 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1415 TEST_ASSERT_NOT_NULL(ut_params->op,
1416 "Failed to allocate symmetric crypto operation struct");
1418 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1420 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1422 /* set crypto operation source mbuf */
1423 sym_op->m_src = ut_params->ibuf;
1425 sym_op->auth.digest.data = ut_params->digest;
1426 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1427 ut_params->ibuf, QUOTE_512_BYTES);
1428 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1430 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1431 sym_op->auth.data.length = QUOTE_512_BYTES;
1433 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1434 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1435 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1436 ut_params->ibuf, 0);
1437 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1439 rte_memcpy(sym_op->cipher.iv.data, iv,
1440 CIPHER_IV_LENGTH_AES_CBC);
1442 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1443 sym_op->cipher.data.length = QUOTE_512_BYTES;
1445 /* Process crypto operation */
1446 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1447 ut_params->op), "failed to process sym crypto op");
1449 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1450 "crypto op processing failed");
1452 ut_params->obuf = ut_params->op->sym->m_src;
1455 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1456 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1457 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1459 "Plaintext data not as expected");
1462 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1463 "Digest verification failed");
1465 return TEST_SUCCESS;
1469 test_AES_chain_mb_all(void)
1471 struct crypto_testsuite_params *ts_params = &testsuite_params;
1474 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1475 ts_params->op_mpool, ts_params->valid_devs[0],
1476 RTE_CRYPTODEV_AESNI_MB_PMD,
1477 BLKCIPHER_AES_CHAIN_TYPE);
1479 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1481 return TEST_SUCCESS;
1485 test_AES_chain_openssl_all(void)
1487 struct crypto_testsuite_params *ts_params = &testsuite_params;
1490 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1491 ts_params->op_mpool, ts_params->valid_devs[0],
1492 RTE_CRYPTODEV_OPENSSL_PMD,
1493 BLKCIPHER_AES_CHAIN_TYPE);
1495 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1497 return TEST_SUCCESS;
1501 test_AES_cipheronly_openssl_all(void)
1503 struct crypto_testsuite_params *ts_params = &testsuite_params;
1506 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1507 ts_params->op_mpool, ts_params->valid_devs[0],
1508 RTE_CRYPTODEV_OPENSSL_PMD,
1509 BLKCIPHER_AES_CIPHERONLY_TYPE);
1511 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1513 return TEST_SUCCESS;
1517 test_AES_chain_qat_all(void)
1519 struct crypto_testsuite_params *ts_params = &testsuite_params;
1522 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1523 ts_params->op_mpool, ts_params->valid_devs[0],
1524 RTE_CRYPTODEV_QAT_SYM_PMD,
1525 BLKCIPHER_AES_CHAIN_TYPE);
1527 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1529 return TEST_SUCCESS;
1533 test_AES_cipheronly_qat_all(void)
1535 struct crypto_testsuite_params *ts_params = &testsuite_params;
1538 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1539 ts_params->op_mpool, ts_params->valid_devs[0],
1540 RTE_CRYPTODEV_QAT_SYM_PMD,
1541 BLKCIPHER_AES_CIPHERONLY_TYPE);
1543 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1545 return TEST_SUCCESS;
1549 test_authonly_openssl_all(void)
1551 struct crypto_testsuite_params *ts_params = &testsuite_params;
1554 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1555 ts_params->op_mpool, ts_params->valid_devs[0],
1556 RTE_CRYPTODEV_OPENSSL_PMD,
1557 BLKCIPHER_AUTHONLY_TYPE);
1559 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1561 return TEST_SUCCESS;
1564 /* ***** SNOW 3G Tests ***** */
1566 create_wireless_algo_hash_session(uint8_t dev_id,
1567 const uint8_t *key, const uint8_t key_len,
1568 const uint8_t aad_len, const uint8_t auth_len,
1569 enum rte_crypto_auth_operation op,
1570 enum rte_crypto_auth_algorithm algo)
1572 uint8_t hash_key[key_len];
1574 struct crypto_unittest_params *ut_params = &unittest_params;
1576 memcpy(hash_key, key, key_len);
1578 TEST_HEXDUMP(stdout, "key:", key, key_len);
1580 /* Setup Authentication Parameters */
1581 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1582 ut_params->auth_xform.next = NULL;
1584 ut_params->auth_xform.auth.op = op;
1585 ut_params->auth_xform.auth.algo = algo;
1586 ut_params->auth_xform.auth.key.length = key_len;
1587 ut_params->auth_xform.auth.key.data = hash_key;
1588 ut_params->auth_xform.auth.digest_length = auth_len;
1589 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1590 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1591 &ut_params->auth_xform);
1592 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1597 create_wireless_algo_cipher_session(uint8_t dev_id,
1598 enum rte_crypto_cipher_operation op,
1599 enum rte_crypto_cipher_algorithm algo,
1600 const uint8_t *key, const uint8_t key_len)
1602 uint8_t cipher_key[key_len];
1604 struct crypto_unittest_params *ut_params = &unittest_params;
1606 memcpy(cipher_key, key, key_len);
1608 /* Setup Cipher Parameters */
1609 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1610 ut_params->cipher_xform.next = NULL;
1612 ut_params->cipher_xform.cipher.algo = algo;
1613 ut_params->cipher_xform.cipher.op = op;
1614 ut_params->cipher_xform.cipher.key.data = cipher_key;
1615 ut_params->cipher_xform.cipher.key.length = key_len;
1617 TEST_HEXDUMP(stdout, "key:", key, key_len);
1619 /* Create Crypto session */
1620 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1623 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1628 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1629 const unsigned cipher_len,
1630 const unsigned cipher_offset,
1631 enum rte_crypto_cipher_algorithm algo)
1633 struct crypto_testsuite_params *ts_params = &testsuite_params;
1634 struct crypto_unittest_params *ut_params = &unittest_params;
1635 unsigned iv_pad_len = 0;
1637 /* Generate Crypto op data structure */
1638 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1639 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1640 TEST_ASSERT_NOT_NULL(ut_params->op,
1641 "Failed to allocate pktmbuf offload");
1643 /* Set crypto operation data parameters */
1644 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1646 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1648 /* set crypto operation source mbuf */
1649 sym_op->m_src = ut_params->ibuf;
1652 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1653 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1655 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1657 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1660 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1662 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1663 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1664 sym_op->cipher.iv.length = iv_pad_len;
1666 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1667 sym_op->cipher.data.length = cipher_len;
1668 sym_op->cipher.data.offset = cipher_offset;
1673 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1674 const unsigned cipher_len,
1675 const unsigned cipher_offset,
1676 enum rte_crypto_cipher_algorithm algo)
1678 struct crypto_testsuite_params *ts_params = &testsuite_params;
1679 struct crypto_unittest_params *ut_params = &unittest_params;
1680 unsigned iv_pad_len = 0;
1682 /* Generate Crypto op data structure */
1683 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1684 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1685 TEST_ASSERT_NOT_NULL(ut_params->op,
1686 "Failed to allocate pktmbuf offload");
1688 /* Set crypto operation data parameters */
1689 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1691 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1693 /* set crypto operation source mbuf */
1694 sym_op->m_src = ut_params->ibuf;
1695 sym_op->m_dst = ut_params->obuf;
1698 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1699 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1701 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1702 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1705 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1707 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1708 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1709 sym_op->cipher.iv.length = iv_pad_len;
1711 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1712 sym_op->cipher.data.length = cipher_len;
1713 sym_op->cipher.data.offset = cipher_offset;
1718 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1719 enum rte_crypto_cipher_operation cipher_op,
1720 enum rte_crypto_auth_operation auth_op,
1721 enum rte_crypto_auth_algorithm auth_algo,
1722 enum rte_crypto_cipher_algorithm cipher_algo,
1723 const uint8_t *key, const uint8_t key_len,
1724 const uint8_t aad_len, const uint8_t auth_len)
1727 uint8_t cipher_auth_key[key_len];
1729 struct crypto_unittest_params *ut_params = &unittest_params;
1731 memcpy(cipher_auth_key, key, key_len);
1733 /* Setup Authentication Parameters */
1734 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1735 ut_params->auth_xform.next = NULL;
1737 ut_params->auth_xform.auth.op = auth_op;
1738 ut_params->auth_xform.auth.algo = auth_algo;
1739 ut_params->auth_xform.auth.key.length = key_len;
1740 /* Hash key = cipher key */
1741 ut_params->auth_xform.auth.key.data = cipher_auth_key;
1742 ut_params->auth_xform.auth.digest_length = auth_len;
1743 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1745 /* Setup Cipher Parameters */
1746 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1747 ut_params->cipher_xform.next = &ut_params->auth_xform;
1749 ut_params->cipher_xform.cipher.algo = cipher_algo;
1750 ut_params->cipher_xform.cipher.op = cipher_op;
1751 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1752 ut_params->cipher_xform.cipher.key.length = key_len;
1754 TEST_HEXDUMP(stdout, "key:", key, key_len);
1756 /* Create Crypto session*/
1757 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1758 &ut_params->cipher_xform);
1760 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1765 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
1766 enum rte_crypto_cipher_operation cipher_op,
1767 enum rte_crypto_auth_operation auth_op,
1768 enum rte_crypto_auth_algorithm auth_algo,
1769 enum rte_crypto_cipher_algorithm cipher_algo,
1770 const uint8_t *key, const uint8_t key_len,
1771 const uint8_t aad_len, const uint8_t auth_len)
1773 uint8_t auth_cipher_key[key_len];
1775 struct crypto_unittest_params *ut_params = &unittest_params;
1777 memcpy(auth_cipher_key, key, key_len);
1779 /* Setup Authentication Parameters */
1780 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1781 ut_params->auth_xform.auth.op = auth_op;
1782 ut_params->auth_xform.next = &ut_params->cipher_xform;
1783 ut_params->auth_xform.auth.algo = auth_algo;
1784 ut_params->auth_xform.auth.key.length = key_len;
1785 ut_params->auth_xform.auth.key.data = auth_cipher_key;
1786 ut_params->auth_xform.auth.digest_length = auth_len;
1787 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1789 /* Setup Cipher Parameters */
1790 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1791 ut_params->cipher_xform.next = NULL;
1792 ut_params->cipher_xform.cipher.algo = cipher_algo;
1793 ut_params->cipher_xform.cipher.op = cipher_op;
1794 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
1795 ut_params->cipher_xform.cipher.key.length = key_len;
1797 TEST_HEXDUMP(stdout, "key:", key, key_len);
1799 /* Create Crypto session*/
1800 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1801 &ut_params->auth_xform);
1803 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1809 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
1810 const unsigned auth_tag_len,
1811 const uint8_t *aad, const unsigned aad_len,
1812 unsigned data_pad_len,
1813 enum rte_crypto_auth_operation op,
1814 enum rte_crypto_auth_algorithm algo,
1815 const unsigned auth_len, const unsigned auth_offset)
1817 struct crypto_testsuite_params *ts_params = &testsuite_params;
1819 struct crypto_unittest_params *ut_params = &unittest_params;
1821 unsigned aad_buffer_len;
1823 /* Generate Crypto op data structure */
1824 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1825 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1826 TEST_ASSERT_NOT_NULL(ut_params->op,
1827 "Failed to allocate pktmbuf offload");
1829 /* Set crypto operation data parameters */
1830 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1832 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1834 /* set crypto operation source mbuf */
1835 sym_op->m_src = ut_params->ibuf;
1839 * Always allocate the aad up to the block size.
1840 * The cryptodev API calls out -
1841 * - the array must be big enough to hold the AAD, plus any
1842 * space to round this up to the nearest multiple of the
1843 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
1845 if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1846 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1848 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1849 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1850 ut_params->ibuf, aad_buffer_len);
1851 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1852 "no room to prepend aad");
1853 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1855 sym_op->auth.aad.length = aad_len;
1857 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1858 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1860 TEST_HEXDUMP(stdout, "aad:",
1861 sym_op->auth.aad.data, aad_len);
1864 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1865 ut_params->ibuf, auth_tag_len);
1867 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1868 "no room to append auth tag");
1869 ut_params->digest = sym_op->auth.digest.data;
1870 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1871 ut_params->ibuf, data_pad_len + aad_len);
1872 sym_op->auth.digest.length = auth_tag_len;
1873 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1874 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1876 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1878 TEST_HEXDUMP(stdout, "digest:",
1879 sym_op->auth.digest.data,
1880 sym_op->auth.digest.length);
1882 sym_op->auth.data.length = auth_len;
1883 sym_op->auth.data.offset = auth_offset;
1889 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
1890 const unsigned auth_tag_len,
1891 const uint8_t *aad, const uint8_t aad_len,
1892 unsigned data_pad_len,
1893 enum rte_crypto_auth_operation op,
1894 enum rte_crypto_auth_algorithm auth_algo,
1895 enum rte_crypto_cipher_algorithm cipher_algo,
1896 const uint8_t *iv, const uint8_t iv_len,
1897 const unsigned cipher_len, const unsigned cipher_offset,
1898 const unsigned auth_len, const unsigned auth_offset)
1900 struct crypto_testsuite_params *ts_params = &testsuite_params;
1901 struct crypto_unittest_params *ut_params = &unittest_params;
1903 unsigned iv_pad_len = 0;
1904 unsigned aad_buffer_len;
1906 /* Generate Crypto op data structure */
1907 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1908 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1909 TEST_ASSERT_NOT_NULL(ut_params->op,
1910 "Failed to allocate pktmbuf offload");
1911 /* Set crypto operation data parameters */
1912 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1914 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1916 /* set crypto operation source mbuf */
1917 sym_op->m_src = ut_params->ibuf;
1920 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1921 ut_params->ibuf, auth_tag_len);
1923 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1924 "no room to append auth tag");
1925 ut_params->digest = sym_op->auth.digest.data;
1926 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1927 ut_params->ibuf, data_pad_len);
1928 sym_op->auth.digest.length = auth_tag_len;
1929 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1930 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1932 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1934 TEST_HEXDUMP(stdout, "digest:",
1935 sym_op->auth.digest.data,
1936 sym_op->auth.digest.length);
1940 * Always allocate the aad up to the block size.
1941 * The cryptodev API calls out -
1942 * - the array must be big enough to hold the AAD, plus any
1943 * space to round this up to the nearest multiple of the
1944 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
1946 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1947 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1949 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1950 sym_op->auth.aad.data =
1951 (uint8_t *)rte_pktmbuf_prepend(
1952 ut_params->ibuf, aad_buffer_len);
1953 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1954 "no room to prepend aad");
1955 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1957 sym_op->auth.aad.length = aad_len;
1958 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1959 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1960 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
1963 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1964 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1966 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1967 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1968 ut_params->ibuf, iv_pad_len);
1970 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1971 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1972 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1973 sym_op->cipher.iv.length = iv_pad_len;
1974 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1975 sym_op->cipher.data.length = cipher_len;
1976 sym_op->cipher.data.offset = cipher_offset + auth_offset;
1977 sym_op->auth.data.length = auth_len;
1978 sym_op->auth.data.offset = auth_offset + cipher_offset;
1984 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
1985 const uint8_t *iv, const uint8_t iv_len,
1986 const uint8_t *aad, const uint8_t aad_len,
1987 unsigned data_pad_len,
1988 const unsigned cipher_len, const unsigned cipher_offset,
1989 const unsigned auth_len, const unsigned auth_offset,
1990 enum rte_crypto_auth_algorithm auth_algo,
1991 enum rte_crypto_cipher_algorithm cipher_algo)
1993 struct crypto_testsuite_params *ts_params = &testsuite_params;
1994 struct crypto_unittest_params *ut_params = &unittest_params;
1996 unsigned iv_pad_len = 0;
1997 unsigned aad_buffer_len = 0;
1999 /* Generate Crypto op data structure */
2000 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2001 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2002 TEST_ASSERT_NOT_NULL(ut_params->op,
2003 "Failed to allocate pktmbuf offload");
2005 /* Set crypto operation data parameters */
2006 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2008 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2010 /* set crypto operation source mbuf */
2011 sym_op->m_src = ut_params->ibuf;
2014 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2015 ut_params->ibuf, auth_tag_len);
2017 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2018 "no room to append auth tag");
2020 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2021 ut_params->ibuf, data_pad_len);
2022 sym_op->auth.digest.length = auth_tag_len;
2024 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2026 TEST_HEXDUMP(stdout, "digest:",
2027 sym_op->auth.digest.data,
2028 sym_op->auth.digest.length);
2032 * Always allocate the aad up to the block size.
2033 * The cryptodev API calls out -
2034 * - the array must be big enough to hold the AAD, plus any
2035 * space to round this up to the nearest multiple of the
2036 * block size (8 bytes for KASUMI 16 bytes).
2038 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2039 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2041 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2042 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2043 ut_params->ibuf, aad_buffer_len);
2044 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2045 "no room to prepend aad");
2046 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2048 sym_op->auth.aad.length = aad_len;
2049 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2050 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2051 TEST_HEXDUMP(stdout, "aad:",
2052 sym_op->auth.aad.data, aad_len);
2055 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2056 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2058 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2060 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2061 ut_params->ibuf, iv_pad_len);
2062 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2064 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2065 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2066 sym_op->cipher.iv.length = iv_pad_len;
2068 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2070 sym_op->cipher.data.length = cipher_len;
2071 sym_op->cipher.data.offset = auth_offset + cipher_offset;
2073 sym_op->auth.data.length = auth_len;
2074 sym_op->auth.data.offset = auth_offset + cipher_offset;
2080 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2082 struct crypto_testsuite_params *ts_params = &testsuite_params;
2083 struct crypto_unittest_params *ut_params = &unittest_params;
2086 unsigned plaintext_pad_len;
2087 unsigned plaintext_len;
2090 /* Create SNOW 3G session */
2091 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2092 tdata->key.data, tdata->key.len,
2093 tdata->aad.len, tdata->digest.len,
2094 RTE_CRYPTO_AUTH_OP_GENERATE,
2095 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2099 /* alloc mbuf and set payload */
2100 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2102 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2103 rte_pktmbuf_tailroom(ut_params->ibuf));
2105 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2106 /* Append data which is padded to a multiple of */
2107 /* the algorithms block size */
2108 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2109 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2111 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2113 /* Create SNOW 3G operation */
2114 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2115 tdata->aad.data, tdata->aad.len,
2116 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2117 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2118 tdata->validAuthLenInBits.len,
2119 tdata->validAuthOffsetLenInBits.len);
2123 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2125 ut_params->obuf = ut_params->op->sym->m_src;
2126 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2127 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2128 + plaintext_pad_len + tdata->aad.len;
2131 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2134 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2135 "SNOW 3G Generated auth tag not as expected");
2141 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2143 struct crypto_testsuite_params *ts_params = &testsuite_params;
2144 struct crypto_unittest_params *ut_params = &unittest_params;
2147 unsigned plaintext_pad_len;
2148 unsigned plaintext_len;
2151 /* Create SNOW 3G session */
2152 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2153 tdata->key.data, tdata->key.len,
2154 tdata->aad.len, tdata->digest.len,
2155 RTE_CRYPTO_AUTH_OP_VERIFY,
2156 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2159 /* alloc mbuf and set payload */
2160 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2162 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2163 rte_pktmbuf_tailroom(ut_params->ibuf));
2165 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2166 /* Append data which is padded to a multiple of */
2167 /* the algorithms block size */
2168 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2169 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2171 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2173 /* Create SNOW 3G operation */
2174 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2176 tdata->aad.data, tdata->aad.len,
2178 RTE_CRYPTO_AUTH_OP_VERIFY,
2179 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2180 tdata->validAuthLenInBits.len,
2181 tdata->validAuthOffsetLenInBits.len);
2185 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2187 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2188 ut_params->obuf = ut_params->op->sym->m_src;
2189 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2190 + plaintext_pad_len + tdata->aad.len;
2193 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2202 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2204 struct crypto_testsuite_params *ts_params = &testsuite_params;
2205 struct crypto_unittest_params *ut_params = &unittest_params;
2208 unsigned plaintext_pad_len;
2209 unsigned plaintext_len;
2212 /* Create KASUMI session */
2213 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2214 tdata->key.data, tdata->key.len,
2215 tdata->aad.len, tdata->digest.len,
2216 RTE_CRYPTO_AUTH_OP_GENERATE,
2217 RTE_CRYPTO_AUTH_KASUMI_F9);
2221 /* alloc mbuf and set payload */
2222 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2224 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2225 rte_pktmbuf_tailroom(ut_params->ibuf));
2227 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2228 /* Append data which is padded to a multiple of */
2229 /* the algorithms block size */
2230 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2231 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2233 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2235 /* Create KASUMI operation */
2236 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2237 tdata->aad.data, tdata->aad.len,
2238 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2239 RTE_CRYPTO_AUTH_KASUMI_F9,
2240 tdata->validAuthLenInBits.len,
2241 tdata->validAuthOffsetLenInBits.len);
2245 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2247 ut_params->obuf = ut_params->op->sym->m_src;
2248 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2249 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2250 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
2253 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2256 DIGEST_BYTE_LENGTH_KASUMI_F9,
2257 "KASUMI Generated auth tag not as expected");
2263 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2265 struct crypto_testsuite_params *ts_params = &testsuite_params;
2266 struct crypto_unittest_params *ut_params = &unittest_params;
2269 unsigned plaintext_pad_len;
2270 unsigned plaintext_len;
2273 /* Create KASUMI session */
2274 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2275 tdata->key.data, tdata->key.len,
2276 tdata->aad.len, tdata->digest.len,
2277 RTE_CRYPTO_AUTH_OP_VERIFY,
2278 RTE_CRYPTO_AUTH_KASUMI_F9);
2281 /* alloc mbuf and set payload */
2282 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2284 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2285 rte_pktmbuf_tailroom(ut_params->ibuf));
2287 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2288 /* Append data which is padded to a multiple */
2289 /* of the algorithms block size */
2290 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2291 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2293 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2295 /* Create KASUMI operation */
2296 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2298 tdata->aad.data, tdata->aad.len,
2300 RTE_CRYPTO_AUTH_OP_VERIFY,
2301 RTE_CRYPTO_AUTH_KASUMI_F9,
2302 tdata->validAuthLenInBits.len,
2303 tdata->validAuthOffsetLenInBits.len);
2307 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2309 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2310 ut_params->obuf = ut_params->op->sym->m_src;
2311 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2312 + plaintext_pad_len + tdata->aad.len;
2315 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2324 test_snow3g_hash_generate_test_case_1(void)
2326 return test_snow3g_authentication(&snow3g_hash_test_case_1);
2330 test_snow3g_hash_generate_test_case_2(void)
2332 return test_snow3g_authentication(&snow3g_hash_test_case_2);
2336 test_snow3g_hash_generate_test_case_3(void)
2338 return test_snow3g_authentication(&snow3g_hash_test_case_3);
2342 test_snow3g_hash_generate_test_case_4(void)
2344 return test_snow3g_authentication(&snow3g_hash_test_case_4);
2348 test_snow3g_hash_generate_test_case_5(void)
2350 return test_snow3g_authentication(&snow3g_hash_test_case_5);
2354 test_snow3g_hash_generate_test_case_6(void)
2356 return test_snow3g_authentication(&snow3g_hash_test_case_6);
2360 test_snow3g_hash_verify_test_case_1(void)
2362 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2367 test_snow3g_hash_verify_test_case_2(void)
2369 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2373 test_snow3g_hash_verify_test_case_3(void)
2375 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2379 test_snow3g_hash_verify_test_case_4(void)
2381 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2385 test_snow3g_hash_verify_test_case_5(void)
2387 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2391 test_snow3g_hash_verify_test_case_6(void)
2393 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2397 test_kasumi_hash_generate_test_case_1(void)
2399 return test_kasumi_authentication(&kasumi_hash_test_case_1);
2403 test_kasumi_hash_generate_test_case_2(void)
2405 return test_kasumi_authentication(&kasumi_hash_test_case_2);
2409 test_kasumi_hash_generate_test_case_3(void)
2411 return test_kasumi_authentication(&kasumi_hash_test_case_3);
2415 test_kasumi_hash_generate_test_case_4(void)
2417 return test_kasumi_authentication(&kasumi_hash_test_case_4);
2421 test_kasumi_hash_generate_test_case_5(void)
2423 return test_kasumi_authentication(&kasumi_hash_test_case_5);
2427 test_kasumi_hash_generate_test_case_6(void)
2429 return test_kasumi_authentication(&kasumi_hash_test_case_6);
2433 test_kasumi_hash_verify_test_case_1(void)
2435 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2439 test_kasumi_hash_verify_test_case_2(void)
2441 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2445 test_kasumi_hash_verify_test_case_3(void)
2447 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2451 test_kasumi_hash_verify_test_case_4(void)
2453 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2457 test_kasumi_hash_verify_test_case_5(void)
2459 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2463 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2465 struct crypto_testsuite_params *ts_params = &testsuite_params;
2466 struct crypto_unittest_params *ut_params = &unittest_params;
2469 uint8_t *plaintext, *ciphertext;
2470 unsigned plaintext_pad_len;
2471 unsigned plaintext_len;
2473 /* Create KASUMI session */
2474 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2475 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2476 RTE_CRYPTO_CIPHER_KASUMI_F8,
2477 tdata->key.data, tdata->key.len);
2481 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2483 /* Clear mbuf payload */
2484 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2485 rte_pktmbuf_tailroom(ut_params->ibuf));
2487 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2488 /* Append data which is padded to a multiple */
2489 /* of the algorithms block size */
2490 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2491 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2493 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2495 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2497 /* Create KASUMI operation */
2498 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2499 tdata->plaintext.len,
2500 tdata->validCipherOffsetLenInBits.len,
2501 RTE_CRYPTO_CIPHER_KASUMI_F8);
2505 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2507 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2509 ut_params->obuf = ut_params->op->sym->m_dst;
2510 if (ut_params->obuf)
2511 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2514 ciphertext = plaintext;
2516 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2519 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2521 tdata->ciphertext.data,
2522 tdata->validCipherLenInBits.len,
2523 "KASUMI Ciphertext data not as expected");
2528 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2530 struct crypto_testsuite_params *ts_params = &testsuite_params;
2531 struct crypto_unittest_params *ut_params = &unittest_params;
2534 uint8_t *plaintext, *ciphertext;
2535 unsigned plaintext_pad_len;
2536 unsigned plaintext_len;
2538 /* Create KASUMI session */
2539 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2540 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2541 RTE_CRYPTO_CIPHER_KASUMI_F8,
2542 tdata->key.data, tdata->key.len);
2546 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2547 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2549 /* Clear mbuf payload */
2550 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2551 rte_pktmbuf_tailroom(ut_params->ibuf));
2553 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2554 /* Append data which is padded to a multiple */
2555 /* of the algorithms block size */
2556 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2557 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2559 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2560 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2562 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2564 /* Create KASUMI operation */
2565 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2567 tdata->plaintext.len,
2568 tdata->validCipherOffsetLenInBits.len,
2569 RTE_CRYPTO_CIPHER_KASUMI_F8);
2573 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2575 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2577 ut_params->obuf = ut_params->op->sym->m_dst;
2578 if (ut_params->obuf)
2579 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2582 ciphertext = plaintext;
2584 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2587 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2589 tdata->ciphertext.data,
2590 tdata->validCipherLenInBits.len,
2591 "KASUMI Ciphertext data not as expected");
2596 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
2598 struct crypto_testsuite_params *ts_params = &testsuite_params;
2599 struct crypto_unittest_params *ut_params = &unittest_params;
2602 uint8_t *ciphertext, *plaintext;
2603 unsigned ciphertext_pad_len;
2604 unsigned ciphertext_len;
2606 /* Create KASUMI session */
2607 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2608 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2609 RTE_CRYPTO_CIPHER_KASUMI_F8,
2610 tdata->key.data, tdata->key.len);
2614 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2615 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2617 /* Clear mbuf payload */
2618 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2619 rte_pktmbuf_tailroom(ut_params->ibuf));
2621 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2622 /* Append data which is padded to a multiple */
2623 /* of the algorithms block size */
2624 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2625 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2626 ciphertext_pad_len);
2627 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2628 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2630 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2632 /* Create KASUMI operation */
2633 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2635 tdata->ciphertext.len,
2636 tdata->validCipherOffsetLenInBits.len,
2637 RTE_CRYPTO_CIPHER_KASUMI_F8);
2641 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2643 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2645 ut_params->obuf = ut_params->op->sym->m_dst;
2646 if (ut_params->obuf)
2647 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2650 plaintext = ciphertext;
2652 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2655 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2657 tdata->plaintext.data,
2658 tdata->validCipherLenInBits.len,
2659 "KASUMI Plaintext data not as expected");
2664 test_kasumi_decryption(const struct kasumi_test_data *tdata)
2666 struct crypto_testsuite_params *ts_params = &testsuite_params;
2667 struct crypto_unittest_params *ut_params = &unittest_params;
2670 uint8_t *ciphertext, *plaintext;
2671 unsigned ciphertext_pad_len;
2672 unsigned ciphertext_len;
2674 /* Create KASUMI session */
2675 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2676 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2677 RTE_CRYPTO_CIPHER_KASUMI_F8,
2678 tdata->key.data, tdata->key.len);
2682 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2684 /* Clear mbuf payload */
2685 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2686 rte_pktmbuf_tailroom(ut_params->ibuf));
2688 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2689 /* Append data which is padded to a multiple */
2690 /* of the algorithms block size */
2691 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2692 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2693 ciphertext_pad_len);
2694 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2696 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2698 /* Create KASUMI operation */
2699 retval = create_wireless_algo_cipher_operation(tdata->iv.data,
2701 tdata->ciphertext.len,
2702 tdata->validCipherOffsetLenInBits.len,
2703 RTE_CRYPTO_CIPHER_KASUMI_F8);
2707 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2709 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2711 ut_params->obuf = ut_params->op->sym->m_dst;
2712 if (ut_params->obuf)
2713 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2716 plaintext = ciphertext;
2718 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2721 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2723 tdata->plaintext.data,
2724 tdata->validCipherLenInBits.len,
2725 "KASUMI Plaintext data not as expected");
2730 test_snow3g_encryption(const struct snow3g_test_data *tdata)
2732 struct crypto_testsuite_params *ts_params = &testsuite_params;
2733 struct crypto_unittest_params *ut_params = &unittest_params;
2736 uint8_t *plaintext, *ciphertext;
2737 unsigned plaintext_pad_len;
2738 unsigned plaintext_len;
2740 /* Create SNOW 3G session */
2741 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2742 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2743 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2744 tdata->key.data, tdata->key.len);
2748 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2750 /* Clear mbuf payload */
2751 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2752 rte_pktmbuf_tailroom(ut_params->ibuf));
2754 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2755 /* Append data which is padded to a multiple of */
2756 /* the algorithms block size */
2757 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2758 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2760 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2762 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2764 /* Create SNOW 3G operation */
2765 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2766 tdata->validCipherLenInBits.len,
2767 tdata->validCipherOffsetLenInBits.len,
2768 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2772 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2774 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2776 ut_params->obuf = ut_params->op->sym->m_dst;
2777 if (ut_params->obuf)
2778 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2781 ciphertext = plaintext;
2783 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2786 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2788 tdata->ciphertext.data,
2789 tdata->validDataLenInBits.len,
2790 "SNOW 3G Ciphertext data not as expected");
2796 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
2798 struct crypto_testsuite_params *ts_params = &testsuite_params;
2799 struct crypto_unittest_params *ut_params = &unittest_params;
2800 uint8_t *plaintext, *ciphertext;
2803 unsigned plaintext_pad_len;
2804 unsigned plaintext_len;
2806 /* Create SNOW 3G session */
2807 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2808 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2809 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2810 tdata->key.data, tdata->key.len);
2814 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2815 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2817 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2818 "Failed to allocate input buffer in mempool");
2819 TEST_ASSERT_NOT_NULL(ut_params->obuf,
2820 "Failed to allocate output buffer in mempool");
2822 /* Clear mbuf payload */
2823 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2824 rte_pktmbuf_tailroom(ut_params->ibuf));
2826 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2827 /* Append data which is padded to a multiple of */
2828 /* the algorithms block size */
2829 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2830 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2832 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2833 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2835 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2837 /* Create SNOW 3G operation */
2838 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2840 tdata->validCipherLenInBits.len,
2841 tdata->validCipherOffsetLenInBits.len,
2842 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2846 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2848 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2850 ut_params->obuf = ut_params->op->sym->m_dst;
2851 if (ut_params->obuf)
2852 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2855 ciphertext = plaintext;
2857 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2860 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2862 tdata->ciphertext.data,
2863 tdata->validDataLenInBits.len,
2864 "SNOW 3G Ciphertext data not as expected");
2868 /* Shift right a buffer by "offset" bits, "offset" < 8 */
2870 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
2872 uint8_t curr_byte, prev_byte;
2873 uint32_t length_in_bytes = ceil_byte_length(length + offset);
2874 uint8_t lower_byte_mask = (1 << offset) - 1;
2877 prev_byte = buffer[0];
2878 buffer[0] >>= offset;
2880 for (i = 1; i < length_in_bytes; i++) {
2881 curr_byte = buffer[i];
2882 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
2883 (curr_byte >> offset);
2884 prev_byte = curr_byte;
2889 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
2891 struct crypto_testsuite_params *ts_params = &testsuite_params;
2892 struct crypto_unittest_params *ut_params = &unittest_params;
2893 uint8_t *plaintext, *ciphertext;
2895 uint32_t plaintext_len;
2896 uint32_t plaintext_pad_len;
2897 uint8_t extra_offset = 4;
2898 uint8_t *expected_ciphertext_shifted;
2900 /* Create SNOW 3G session */
2901 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2902 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2903 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2904 tdata->key.data, tdata->key.len);
2908 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2909 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2911 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2912 "Failed to allocate input buffer in mempool");
2913 TEST_ASSERT_NOT_NULL(ut_params->obuf,
2914 "Failed to allocate output buffer in mempool");
2916 /* Clear mbuf payload */
2917 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2918 rte_pktmbuf_tailroom(ut_params->ibuf));
2920 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
2922 * Append data which is padded to a
2923 * multiple of the algorithms block size
2925 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2927 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2930 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2932 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2933 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
2935 #ifdef RTE_APP_TEST_DEBUG
2936 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2938 /* Create SNOW 3G operation */
2939 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2941 tdata->validCipherLenInBits.len,
2942 tdata->validCipherOffsetLenInBits.len +
2944 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2948 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2950 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2952 ut_params->obuf = ut_params->op->sym->m_dst;
2953 if (ut_params->obuf)
2954 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2957 ciphertext = plaintext;
2959 #ifdef RTE_APP_TEST_DEBUG
2960 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2963 expected_ciphertext_shifted = rte_malloc(NULL,
2964 ceil_byte_length(plaintext_len + extra_offset), 0);
2966 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
2967 "failed to reserve memory for ciphertext shifted\n");
2969 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
2970 ceil_byte_length(tdata->ciphertext.len));
2971 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
2974 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
2976 expected_ciphertext_shifted,
2977 tdata->validDataLenInBits.len,
2979 "SNOW 3G Ciphertext data not as expected");
2983 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2985 struct crypto_testsuite_params *ts_params = &testsuite_params;
2986 struct crypto_unittest_params *ut_params = &unittest_params;
2990 uint8_t *plaintext, *ciphertext;
2991 unsigned ciphertext_pad_len;
2992 unsigned ciphertext_len;
2994 /* Create SNOW 3G session */
2995 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2996 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2997 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2998 tdata->key.data, tdata->key.len);
3002 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3004 /* Clear mbuf payload */
3005 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3006 rte_pktmbuf_tailroom(ut_params->ibuf));
3008 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3009 /* Append data which is padded to a multiple of */
3010 /* the algorithms block size */
3011 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3012 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3013 ciphertext_pad_len);
3014 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3016 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3018 /* Create SNOW 3G operation */
3019 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3020 tdata->validCipherLenInBits.len,
3021 tdata->validCipherOffsetLenInBits.len,
3022 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3026 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3028 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3029 ut_params->obuf = ut_params->op->sym->m_dst;
3030 if (ut_params->obuf)
3031 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3034 plaintext = ciphertext;
3036 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3039 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3040 tdata->plaintext.data,
3041 tdata->validDataLenInBits.len,
3042 "SNOW 3G Plaintext data not as expected");
3046 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3048 struct crypto_testsuite_params *ts_params = &testsuite_params;
3049 struct crypto_unittest_params *ut_params = &unittest_params;
3053 uint8_t *plaintext, *ciphertext;
3054 unsigned ciphertext_pad_len;
3055 unsigned ciphertext_len;
3057 /* Create SNOW 3G session */
3058 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3059 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3060 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3061 tdata->key.data, tdata->key.len);
3065 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3066 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3068 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3069 "Failed to allocate input buffer");
3070 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3071 "Failed to allocate output buffer");
3073 /* Clear mbuf payload */
3074 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3075 rte_pktmbuf_tailroom(ut_params->ibuf));
3077 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3078 rte_pktmbuf_tailroom(ut_params->obuf));
3080 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3081 /* Append data which is padded to a multiple of */
3082 /* the algorithms block size */
3083 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3084 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3085 ciphertext_pad_len);
3086 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3087 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3089 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3091 /* Create SNOW 3G operation */
3092 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3094 tdata->validCipherLenInBits.len,
3095 tdata->validCipherOffsetLenInBits.len,
3096 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3100 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3102 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3103 ut_params->obuf = ut_params->op->sym->m_dst;
3104 if (ut_params->obuf)
3105 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3108 plaintext = ciphertext;
3110 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3113 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3114 tdata->plaintext.data,
3115 tdata->validDataLenInBits.len,
3116 "SNOW 3G Plaintext data not as expected");
3121 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3123 struct crypto_testsuite_params *ts_params = &testsuite_params;
3124 struct crypto_unittest_params *ut_params = &unittest_params;
3128 uint8_t *plaintext, *ciphertext;
3129 unsigned plaintext_pad_len;
3130 unsigned plaintext_len;
3132 /* Create SNOW 3G session */
3133 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3134 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3135 RTE_CRYPTO_AUTH_OP_GENERATE,
3136 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3137 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3138 tdata->key.data, tdata->key.len,
3139 tdata->aad.len, tdata->digest.len);
3142 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3144 /* clear mbuf payload */
3145 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3146 rte_pktmbuf_tailroom(ut_params->ibuf));
3148 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3149 /* Append data which is padded to a multiple of */
3150 /* the algorithms block size */
3151 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3152 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3154 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3156 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3158 /* Create SNOW 3G operation */
3159 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3160 tdata->digest.len, tdata->aad.data,
3161 tdata->aad.len, /*tdata->plaintext.len,*/
3162 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3163 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3164 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3165 tdata->iv.data, tdata->iv.len,
3166 tdata->validCipherLenInBits.len,
3167 tdata->validCipherOffsetLenInBits.len,
3168 tdata->validAuthLenInBits.len,
3169 tdata->validAuthOffsetLenInBits.len
3174 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3176 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3177 ut_params->obuf = ut_params->op->sym->m_src;
3178 if (ut_params->obuf)
3179 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3180 + tdata->iv.len + tdata->aad.len;
3182 ciphertext = plaintext;
3184 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3186 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3188 tdata->ciphertext.data,
3189 tdata->validDataLenInBits.len,
3190 "SNOW 3G Ciphertext data not as expected");
3192 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3193 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3196 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3199 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3200 "SNOW 3G Generated auth tag not as expected");
3204 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3206 struct crypto_testsuite_params *ts_params = &testsuite_params;
3207 struct crypto_unittest_params *ut_params = &unittest_params;
3211 uint8_t *plaintext, *ciphertext;
3212 unsigned plaintext_pad_len;
3213 unsigned plaintext_len;
3215 /* Create SNOW 3G session */
3216 retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3217 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3218 RTE_CRYPTO_AUTH_OP_GENERATE,
3219 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3220 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3221 tdata->key.data, tdata->key.len,
3222 tdata->aad.len, tdata->digest.len);
3226 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3228 /* clear mbuf payload */
3229 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3230 rte_pktmbuf_tailroom(ut_params->ibuf));
3232 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3233 /* Append data which is padded to a multiple of */
3234 /* the algorithms block size */
3235 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3236 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3238 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3240 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3242 /* Create SNOW 3G operation */
3243 retval = create_wireless_algo_auth_cipher_operation(
3245 tdata->iv.data, tdata->iv.len,
3246 tdata->aad.data, tdata->aad.len,
3248 tdata->validCipherLenInBits.len,
3249 tdata->validCipherOffsetLenInBits.len,
3250 tdata->validAuthLenInBits.len,
3251 tdata->validAuthOffsetLenInBits.len,
3252 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3253 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3259 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3261 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3262 ut_params->obuf = ut_params->op->sym->m_src;
3263 if (ut_params->obuf)
3264 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3265 + tdata->aad.len + tdata->iv.len;
3267 ciphertext = plaintext;
3269 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3270 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3271 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3274 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3276 tdata->ciphertext.data,
3277 tdata->validDataLenInBits.len,
3278 "SNOW 3G Ciphertext data not as expected");
3281 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3284 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3285 "SNOW 3G Generated auth tag not as expected");
3290 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3292 struct crypto_testsuite_params *ts_params = &testsuite_params;
3293 struct crypto_unittest_params *ut_params = &unittest_params;
3297 uint8_t *plaintext, *ciphertext;
3298 unsigned plaintext_pad_len;
3299 unsigned plaintext_len;
3301 /* Create KASUMI session */
3302 retval = create_wireless_algo_auth_cipher_session(
3303 ts_params->valid_devs[0],
3304 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3305 RTE_CRYPTO_AUTH_OP_GENERATE,
3306 RTE_CRYPTO_AUTH_KASUMI_F9,
3307 RTE_CRYPTO_CIPHER_KASUMI_F8,
3308 tdata->key.data, tdata->key.len,
3309 tdata->aad.len, tdata->digest.len);
3312 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3314 /* clear mbuf payload */
3315 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3316 rte_pktmbuf_tailroom(ut_params->ibuf));
3318 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3319 /* Append data which is padded to a multiple of */
3320 /* the algorithms block size */
3321 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3322 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3324 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3326 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3328 /* Create KASUMI operation */
3329 retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
3330 tdata->iv.data, tdata->iv.len,
3331 tdata->aad.data, tdata->aad.len,
3333 tdata->validCipherLenInBits.len,
3334 tdata->validCipherOffsetLenInBits.len,
3335 tdata->validAuthLenInBits.len,
3336 tdata->validAuthOffsetLenInBits.len,
3337 RTE_CRYPTO_AUTH_KASUMI_F9,
3338 RTE_CRYPTO_CIPHER_KASUMI_F8
3344 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3346 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3347 ut_params->obuf = ut_params->op->sym->m_src;
3348 if (ut_params->obuf)
3349 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3350 + tdata->iv.len + tdata->aad.len;
3352 ciphertext = plaintext;
3355 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3357 tdata->ciphertext.data,
3358 tdata->validCipherLenInBits.len,
3359 "KASUMI Ciphertext data not as expected");
3360 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3361 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3364 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3367 DIGEST_BYTE_LENGTH_KASUMI_F9,
3368 "KASUMI Generated auth tag not as expected");
3373 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
3375 struct crypto_testsuite_params *ts_params = &testsuite_params;
3376 struct crypto_unittest_params *ut_params = &unittest_params;
3380 uint8_t *plaintext, *ciphertext;
3381 unsigned plaintext_pad_len;
3382 unsigned plaintext_len;
3384 /* Create KASUMI session */
3385 retval = create_wireless_algo_cipher_auth_session(
3386 ts_params->valid_devs[0],
3387 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3388 RTE_CRYPTO_AUTH_OP_GENERATE,
3389 RTE_CRYPTO_AUTH_KASUMI_F9,
3390 RTE_CRYPTO_CIPHER_KASUMI_F8,
3391 tdata->key.data, tdata->key.len,
3392 tdata->aad.len, tdata->digest.len);
3396 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3398 /* clear mbuf payload */
3399 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3400 rte_pktmbuf_tailroom(ut_params->ibuf));
3402 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3403 /* Append data which is padded to a multiple of */
3404 /* the algorithms block size */
3405 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3406 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3408 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3410 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3412 /* Create KASUMI operation */
3413 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3414 tdata->digest.len, tdata->aad.data,
3416 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3417 RTE_CRYPTO_AUTH_KASUMI_F9,
3418 RTE_CRYPTO_CIPHER_KASUMI_F8,
3419 tdata->iv.data, tdata->iv.len,
3420 tdata->validCipherLenInBits.len,
3421 tdata->validCipherOffsetLenInBits.len,
3422 tdata->validAuthLenInBits.len,
3423 tdata->validAuthOffsetLenInBits.len
3428 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3430 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3431 ut_params->obuf = ut_params->op->sym->m_src;
3432 if (ut_params->obuf)
3433 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3434 + tdata->aad.len + tdata->iv.len;
3436 ciphertext = plaintext;
3438 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3439 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3442 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3444 tdata->ciphertext.data,
3445 tdata->validCipherLenInBits.len,
3446 "KASUMI Ciphertext data not as expected");
3449 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3452 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3453 "KASUMI Generated auth tag not as expected");
3458 test_zuc_encryption(const struct zuc_test_data *tdata)
3460 struct crypto_testsuite_params *ts_params = &testsuite_params;
3461 struct crypto_unittest_params *ut_params = &unittest_params;
3464 uint8_t *plaintext, *ciphertext;
3465 unsigned plaintext_pad_len;
3466 unsigned plaintext_len;
3468 /* Create ZUC session */
3469 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3470 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3471 RTE_CRYPTO_CIPHER_ZUC_EEA3,
3472 tdata->key.data, tdata->key.len);
3476 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3478 /* Clear mbuf payload */
3479 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3480 rte_pktmbuf_tailroom(ut_params->ibuf));
3482 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3483 /* Append data which is padded to a multiple */
3484 /* of the algorithms block size */
3485 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3486 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3488 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3490 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3492 /* Create ZUC operation */
3493 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3494 tdata->plaintext.len,
3495 tdata->validCipherOffsetLenInBits.len,
3496 RTE_CRYPTO_CIPHER_ZUC_EEA3);
3500 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3502 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3504 ut_params->obuf = ut_params->op->sym->m_dst;
3505 if (ut_params->obuf)
3506 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3509 ciphertext = plaintext;
3511 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3514 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3516 tdata->ciphertext.data,
3517 tdata->validCipherLenInBits.len,
3518 "ZUC Ciphertext data not as expected");
3523 test_zuc_authentication(const struct zuc_hash_test_data *tdata)
3525 struct crypto_testsuite_params *ts_params = &testsuite_params;
3526 struct crypto_unittest_params *ut_params = &unittest_params;
3529 unsigned plaintext_pad_len;
3530 unsigned plaintext_len;
3533 /* Create ZUC session */
3534 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3535 tdata->key.data, tdata->key.len,
3536 tdata->aad.len, tdata->digest.len,
3537 RTE_CRYPTO_AUTH_OP_GENERATE,
3538 RTE_CRYPTO_AUTH_ZUC_EIA3);
3542 /* alloc mbuf and set payload */
3543 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3545 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3546 rte_pktmbuf_tailroom(ut_params->ibuf));
3548 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3549 /* Append data which is padded to a multiple of */
3550 /* the algorithms block size */
3551 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3552 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3554 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3556 /* Create ZUC operation */
3557 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3558 tdata->aad.data, tdata->aad.len,
3559 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3560 RTE_CRYPTO_AUTH_ZUC_EIA3,
3561 tdata->validAuthLenInBits.len,
3562 tdata->validAuthOffsetLenInBits.len);
3566 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3568 ut_params->obuf = ut_params->op->sym->m_src;
3569 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3570 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3571 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
3574 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3577 DIGEST_BYTE_LENGTH_KASUMI_F9,
3578 "ZUC Generated auth tag not as expected");
3584 test_kasumi_encryption_test_case_1(void)
3586 return test_kasumi_encryption(&kasumi_test_case_1);
3590 test_kasumi_encryption_test_case_1_oop(void)
3592 return test_kasumi_encryption_oop(&kasumi_test_case_1);
3596 test_kasumi_encryption_test_case_2(void)
3598 return test_kasumi_encryption(&kasumi_test_case_2);
3602 test_kasumi_encryption_test_case_3(void)
3604 return test_kasumi_encryption(&kasumi_test_case_3);
3608 test_kasumi_encryption_test_case_4(void)
3610 return test_kasumi_encryption(&kasumi_test_case_4);
3614 test_kasumi_encryption_test_case_5(void)
3616 return test_kasumi_encryption(&kasumi_test_case_5);
3620 test_kasumi_decryption_test_case_1(void)
3622 return test_kasumi_decryption(&kasumi_test_case_1);
3626 test_kasumi_decryption_test_case_1_oop(void)
3628 return test_kasumi_decryption_oop(&kasumi_test_case_1);
3632 test_kasumi_decryption_test_case_2(void)
3634 return test_kasumi_decryption(&kasumi_test_case_2);
3638 test_kasumi_decryption_test_case_3(void)
3640 return test_kasumi_decryption(&kasumi_test_case_3);
3644 test_kasumi_decryption_test_case_4(void)
3646 return test_kasumi_decryption(&kasumi_test_case_4);
3650 test_kasumi_decryption_test_case_5(void)
3652 return test_kasumi_decryption(&kasumi_test_case_5);
3655 test_snow3g_encryption_test_case_1(void)
3657 return test_snow3g_encryption(&snow3g_test_case_1);
3661 test_snow3g_encryption_test_case_1_oop(void)
3663 return test_snow3g_encryption_oop(&snow3g_test_case_1);
3667 test_snow3g_encryption_test_case_1_offset_oop(void)
3669 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
3673 test_snow3g_encryption_test_case_2(void)
3675 return test_snow3g_encryption(&snow3g_test_case_2);
3679 test_snow3g_encryption_test_case_3(void)
3681 return test_snow3g_encryption(&snow3g_test_case_3);
3685 test_snow3g_encryption_test_case_4(void)
3687 return test_snow3g_encryption(&snow3g_test_case_4);
3691 test_snow3g_encryption_test_case_5(void)
3693 return test_snow3g_encryption(&snow3g_test_case_5);
3697 test_snow3g_decryption_test_case_1(void)
3699 return test_snow3g_decryption(&snow3g_test_case_1);
3703 test_snow3g_decryption_test_case_1_oop(void)
3705 return test_snow3g_decryption_oop(&snow3g_test_case_1);
3709 test_snow3g_decryption_test_case_2(void)
3711 return test_snow3g_decryption(&snow3g_test_case_2);
3715 test_snow3g_decryption_test_case_3(void)
3717 return test_snow3g_decryption(&snow3g_test_case_3);
3721 test_snow3g_decryption_test_case_4(void)
3723 return test_snow3g_decryption(&snow3g_test_case_4);
3727 test_snow3g_decryption_test_case_5(void)
3729 return test_snow3g_decryption(&snow3g_test_case_5);
3732 test_snow3g_cipher_auth_test_case_1(void)
3734 return test_snow3g_cipher_auth(&snow3g_test_case_3);
3738 test_snow3g_auth_cipher_test_case_1(void)
3740 return test_snow3g_auth_cipher(&snow3g_test_case_6);
3744 test_kasumi_auth_cipher_test_case_1(void)
3746 return test_kasumi_auth_cipher(&kasumi_test_case_3);
3750 test_kasumi_cipher_auth_test_case_1(void)
3752 return test_kasumi_cipher_auth(&kasumi_test_case_6);
3756 test_zuc_encryption_test_case_1(void)
3758 return test_zuc_encryption(&zuc_test_case_1);
3762 test_zuc_encryption_test_case_2(void)
3764 return test_zuc_encryption(&zuc_test_case_2);
3768 test_zuc_encryption_test_case_3(void)
3770 return test_zuc_encryption(&zuc_test_case_3);
3774 test_zuc_encryption_test_case_4(void)
3776 return test_zuc_encryption(&zuc_test_case_4);
3780 test_zuc_encryption_test_case_5(void)
3782 return test_zuc_encryption(&zuc_test_case_5);
3786 test_zuc_hash_generate_test_case_1(void)
3788 return test_zuc_authentication(&zuc_hash_test_case_1);
3792 test_zuc_hash_generate_test_case_2(void)
3794 return test_zuc_authentication(&zuc_hash_test_case_2);
3798 test_zuc_hash_generate_test_case_3(void)
3800 return test_zuc_authentication(&zuc_hash_test_case_3);
3804 test_zuc_hash_generate_test_case_4(void)
3806 return test_zuc_authentication(&zuc_hash_test_case_4);
3810 test_zuc_hash_generate_test_case_5(void)
3812 return test_zuc_authentication(&zuc_hash_test_case_5);
3816 test_3DES_chain_qat_all(void)
3818 struct crypto_testsuite_params *ts_params = &testsuite_params;
3821 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3822 ts_params->op_mpool, ts_params->valid_devs[0],
3823 RTE_CRYPTODEV_QAT_SYM_PMD,
3824 BLKCIPHER_3DES_CHAIN_TYPE);
3826 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3828 return TEST_SUCCESS;
3832 test_DES_cipheronly_qat_all(void)
3834 struct crypto_testsuite_params *ts_params = &testsuite_params;
3837 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3838 ts_params->op_mpool, ts_params->valid_devs[0],
3839 RTE_CRYPTODEV_QAT_SYM_PMD,
3840 BLKCIPHER_DES_CIPHERONLY_TYPE);
3842 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3844 return TEST_SUCCESS;
3848 test_3DES_cipheronly_qat_all(void)
3850 struct crypto_testsuite_params *ts_params = &testsuite_params;
3853 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3854 ts_params->op_mpool, ts_params->valid_devs[0],
3855 RTE_CRYPTODEV_QAT_SYM_PMD,
3856 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3858 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3860 return TEST_SUCCESS;
3864 test_3DES_chain_openssl_all(void)
3866 struct crypto_testsuite_params *ts_params = &testsuite_params;
3869 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3870 ts_params->op_mpool, ts_params->valid_devs[0],
3871 RTE_CRYPTODEV_OPENSSL_PMD,
3872 BLKCIPHER_3DES_CHAIN_TYPE);
3874 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3876 return TEST_SUCCESS;
3880 test_3DES_cipheronly_openssl_all(void)
3882 struct crypto_testsuite_params *ts_params = &testsuite_params;
3885 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3886 ts_params->op_mpool, ts_params->valid_devs[0],
3887 RTE_CRYPTODEV_OPENSSL_PMD,
3888 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3890 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3892 return TEST_SUCCESS;
3895 /* ***** AES-GCM Tests ***** */
3898 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
3899 const uint8_t *key, const uint8_t key_len,
3900 const uint8_t aad_len, const uint8_t auth_len,
3901 enum rte_crypto_auth_operation auth_op)
3903 uint8_t cipher_key[key_len];
3905 struct crypto_unittest_params *ut_params = &unittest_params;
3907 memcpy(cipher_key, key, key_len);
3909 /* Setup Cipher Parameters */
3910 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3911 ut_params->cipher_xform.next = NULL;
3913 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3914 ut_params->auth_xform.auth.op = auth_op;
3915 ut_params->cipher_xform.cipher.op = op;
3916 ut_params->cipher_xform.cipher.key.data = cipher_key;
3917 ut_params->cipher_xform.cipher.key.length = key_len;
3919 TEST_HEXDUMP(stdout, "key:", key, key_len);
3921 /* Setup Authentication Parameters */
3922 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3923 ut_params->auth_xform.next = NULL;
3925 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3927 ut_params->auth_xform.auth.digest_length = auth_len;
3928 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3929 ut_params->auth_xform.auth.key.length = 0;
3930 ut_params->auth_xform.auth.key.data = NULL;
3932 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3933 ut_params->cipher_xform.next = &ut_params->auth_xform;
3935 /* Create Crypto session*/
3936 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3937 &ut_params->cipher_xform);
3938 } else {/* Create Crypto session*/
3939 ut_params->auth_xform.next = &ut_params->cipher_xform;
3940 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3941 &ut_params->auth_xform);
3944 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3950 create_gcm_operation(enum rte_crypto_cipher_operation op,
3951 const uint8_t *auth_tag, const unsigned auth_tag_len,
3952 const uint8_t *iv, const unsigned iv_len,
3953 const uint8_t *aad, const unsigned aad_len,
3954 const unsigned data_len, unsigned data_pad_len)
3956 struct crypto_testsuite_params *ts_params = &testsuite_params;
3957 struct crypto_unittest_params *ut_params = &unittest_params;
3959 unsigned iv_pad_len = 0, aad_buffer_len;
3961 /* Generate Crypto op data structure */
3962 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3963 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3964 TEST_ASSERT_NOT_NULL(ut_params->op,
3965 "Failed to allocate symmetric crypto operation struct");
3967 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3969 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3970 ut_params->ibuf, auth_tag_len);
3971 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3972 "no room to append digest");
3973 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3974 ut_params->ibuf, data_pad_len);
3975 sym_op->auth.digest.length = auth_tag_len;
3977 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3978 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3979 TEST_HEXDUMP(stdout, "digest:",
3980 sym_op->auth.digest.data,
3981 sym_op->auth.digest.length);
3985 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3987 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3988 ut_params->ibuf, iv_pad_len);
3989 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3991 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3992 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3993 sym_op->cipher.iv.length = iv_len;
3995 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3998 * Always allocate the aad up to the block size.
3999 * The cryptodev API calls out -
4000 * - the array must be big enough to hold the AAD, plus any
4001 * space to round this up to the nearest multiple of the
4002 * block size (16 bytes).
4004 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
4006 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
4007 ut_params->ibuf, aad_buffer_len);
4008 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
4009 "no room to prepend aad");
4010 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
4012 sym_op->auth.aad.length = aad_len;
4014 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
4015 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
4017 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
4018 TEST_HEXDUMP(stdout, "aad:",
4019 sym_op->auth.aad.data, aad_len);
4021 sym_op->cipher.data.length = data_len;
4022 sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
4024 sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
4025 sym_op->auth.data.length = data_len;
4031 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
4033 struct crypto_testsuite_params *ts_params = &testsuite_params;
4034 struct crypto_unittest_params *ut_params = &unittest_params;
4038 uint8_t *plaintext, *ciphertext, *auth_tag;
4039 uint16_t plaintext_pad_len;
4041 /* Create GCM session */
4042 retval = create_gcm_session(ts_params->valid_devs[0],
4043 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4044 tdata->key.data, tdata->key.len,
4045 tdata->aad.len, tdata->auth_tag.len,
4046 RTE_CRYPTO_AUTH_OP_GENERATE);
4051 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4053 /* clear mbuf payload */
4054 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4055 rte_pktmbuf_tailroom(ut_params->ibuf));
4058 * Append data which is padded to a multiple
4059 * of the algorithms block size
4061 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4063 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4065 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4067 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4069 /* Create GCM opertaion */
4070 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4071 tdata->auth_tag.data, tdata->auth_tag.len,
4072 tdata->iv.data, tdata->iv.len,
4073 tdata->aad.data, tdata->aad.len,
4074 tdata->plaintext.len, plaintext_pad_len);
4078 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4080 ut_params->op->sym->m_src = ut_params->ibuf;
4082 /* Process crypto operation */
4083 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4084 ut_params->op), "failed to process sym crypto op");
4086 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4087 "crypto op processing failed");
4089 if (ut_params->op->sym->m_dst) {
4090 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4092 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4093 uint8_t *, plaintext_pad_len);
4095 ciphertext = plaintext;
4096 auth_tag = plaintext + plaintext_pad_len;
4099 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4100 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
4103 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4105 tdata->ciphertext.data,
4106 tdata->ciphertext.len,
4107 "GCM Ciphertext data not as expected");
4109 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4111 tdata->auth_tag.data,
4112 tdata->auth_tag.len,
4113 "GCM Generated auth tag not as expected");
4120 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
4122 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
4126 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
4128 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
4132 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
4134 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
4138 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
4140 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
4144 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
4146 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
4150 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
4152 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
4156 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
4158 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
4162 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
4164 struct crypto_testsuite_params *ts_params = &testsuite_params;
4165 struct crypto_unittest_params *ut_params = &unittest_params;
4169 uint8_t *plaintext, *ciphertext;
4170 uint16_t ciphertext_pad_len;
4172 /* Create GCM session */
4173 retval = create_gcm_session(ts_params->valid_devs[0],
4174 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4175 tdata->key.data, tdata->key.len,
4176 tdata->aad.len, tdata->auth_tag.len,
4177 RTE_CRYPTO_AUTH_OP_VERIFY);
4182 /* alloc mbuf and set payload */
4183 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4185 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4186 rte_pktmbuf_tailroom(ut_params->ibuf));
4188 ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4190 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4191 ciphertext_pad_len);
4192 memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
4194 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4196 /* Create GCM opertaion */
4197 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
4198 tdata->auth_tag.data, tdata->auth_tag.len,
4199 tdata->iv.data, tdata->iv.len,
4200 tdata->aad.data, tdata->aad.len,
4201 tdata->ciphertext.len, ciphertext_pad_len);
4206 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4208 ut_params->op->sym->m_src = ut_params->ibuf;
4210 /* Process crypto operation */
4211 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4212 ut_params->op), "failed to process sym crypto op");
4214 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4215 "crypto op processing failed");
4217 if (ut_params->op->sym->m_dst)
4218 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4221 plaintext = ciphertext;
4223 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
4226 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4228 tdata->plaintext.data,
4229 tdata->plaintext.len,
4230 "GCM plaintext data not as expected");
4232 TEST_ASSERT_EQUAL(ut_params->op->status,
4233 RTE_CRYPTO_OP_STATUS_SUCCESS,
4234 "GCM authentication failed");
4239 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
4241 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
4245 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
4247 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
4251 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
4253 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
4257 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
4259 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
4263 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
4265 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
4269 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
4271 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
4275 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
4277 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
4283 struct crypto_testsuite_params *ts_params = &testsuite_params;
4284 struct rte_cryptodev_stats stats;
4285 struct rte_cryptodev *dev;
4286 cryptodev_stats_get_t temp_pfn;
4288 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4289 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
4290 &stats) == -ENODEV),
4291 "rte_cryptodev_stats_get invalid dev failed");
4292 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
4293 "rte_cryptodev_stats_get invalid Param failed");
4294 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
4295 temp_pfn = dev->dev_ops->stats_get;
4296 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
4297 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
4299 "rte_cryptodev_stats_get invalid Param failed");
4300 dev->dev_ops->stats_get = temp_pfn;
4302 /* Test expected values */
4304 test_AES_CBC_HMAC_SHA1_encrypt_digest();
4306 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4308 "rte_cryptodev_stats_get failed");
4309 TEST_ASSERT((stats.enqueued_count == 1),
4310 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4311 TEST_ASSERT((stats.dequeued_count == 1),
4312 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4313 TEST_ASSERT((stats.enqueue_err_count == 0),
4314 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4315 TEST_ASSERT((stats.dequeue_err_count == 0),
4316 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4318 /* invalid device but should ignore and not reset device stats*/
4319 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
4320 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4322 "rte_cryptodev_stats_get failed");
4323 TEST_ASSERT((stats.enqueued_count == 1),
4324 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4326 /* check that a valid reset clears stats */
4327 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4328 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4330 "rte_cryptodev_stats_get failed");
4331 TEST_ASSERT((stats.enqueued_count == 0),
4332 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4333 TEST_ASSERT((stats.dequeued_count == 0),
4334 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4336 return TEST_SUCCESS;
4339 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
4340 struct crypto_unittest_params *ut_params,
4341 enum rte_crypto_auth_operation op,
4342 const struct HMAC_MD5_vector *test_case)
4346 memcpy(key, test_case->key.data, test_case->key.len);
4348 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4349 ut_params->auth_xform.next = NULL;
4350 ut_params->auth_xform.auth.op = op;
4352 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
4354 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
4355 ut_params->auth_xform.auth.add_auth_data_length = 0;
4356 ut_params->auth_xform.auth.key.length = test_case->key.len;
4357 ut_params->auth_xform.auth.key.data = key;
4359 ut_params->sess = rte_cryptodev_sym_session_create(
4360 ts_params->valid_devs[0], &ut_params->auth_xform);
4362 if (ut_params->sess == NULL)
4365 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4367 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4368 rte_pktmbuf_tailroom(ut_params->ibuf));
4373 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
4374 const struct HMAC_MD5_vector *test_case,
4375 uint8_t **plaintext)
4377 uint16_t plaintext_pad_len;
4379 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4381 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4384 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4386 memcpy(*plaintext, test_case->plaintext.data,
4387 test_case->plaintext.len);
4389 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4390 ut_params->ibuf, MD5_DIGEST_LEN);
4391 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
4392 "no room to append digest");
4393 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4394 ut_params->ibuf, plaintext_pad_len);
4395 sym_op->auth.digest.length = MD5_DIGEST_LEN;
4397 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
4398 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
4399 test_case->auth_tag.len);
4402 sym_op->auth.data.offset = 0;
4403 sym_op->auth.data.length = test_case->plaintext.len;
4405 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4406 ut_params->op->sym->m_src = ut_params->ibuf;
4412 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
4414 uint16_t plaintext_pad_len;
4415 uint8_t *plaintext, *auth_tag;
4417 struct crypto_testsuite_params *ts_params = &testsuite_params;
4418 struct crypto_unittest_params *ut_params = &unittest_params;
4420 if (MD5_HMAC_create_session(ts_params, ut_params,
4421 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
4424 /* Generate Crypto op data structure */
4425 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4426 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4427 TEST_ASSERT_NOT_NULL(ut_params->op,
4428 "Failed to allocate symmetric crypto operation struct");
4430 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4433 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4436 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4437 ut_params->op), "failed to process sym crypto op");
4439 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4440 "crypto op processing failed");
4442 if (ut_params->op->sym->m_dst) {
4443 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4444 uint8_t *, plaintext_pad_len);
4446 auth_tag = plaintext + plaintext_pad_len;
4449 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4451 test_case->auth_tag.data,
4452 test_case->auth_tag.len,
4453 "HMAC_MD5 generated tag not as expected");
4455 return TEST_SUCCESS;
4459 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
4463 struct crypto_testsuite_params *ts_params = &testsuite_params;
4464 struct crypto_unittest_params *ut_params = &unittest_params;
4466 if (MD5_HMAC_create_session(ts_params, ut_params,
4467 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
4471 /* Generate Crypto op data structure */
4472 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4473 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4474 TEST_ASSERT_NOT_NULL(ut_params->op,
4475 "Failed to allocate symmetric crypto operation struct");
4477 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4480 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4481 ut_params->op), "failed to process sym crypto op");
4483 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4484 "HMAC_MD5 crypto op processing failed");
4486 return TEST_SUCCESS;
4490 test_MD5_HMAC_generate_case_1(void)
4492 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
4496 test_MD5_HMAC_verify_case_1(void)
4498 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
4502 test_MD5_HMAC_generate_case_2(void)
4504 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
4508 test_MD5_HMAC_verify_case_2(void)
4510 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
4514 test_multi_session(void)
4516 struct crypto_testsuite_params *ts_params = &testsuite_params;
4517 struct crypto_unittest_params *ut_params = &unittest_params;
4519 struct rte_cryptodev_info dev_info;
4520 struct rte_cryptodev_sym_session **sessions;
4524 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
4525 aes_cbc_key, hmac_sha512_key);
4528 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4530 sessions = rte_malloc(NULL,
4531 (sizeof(struct rte_cryptodev_sym_session *) *
4532 dev_info.sym.max_nb_sessions) + 1, 0);
4534 /* Create multiple crypto sessions*/
4535 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
4536 sessions[i] = rte_cryptodev_sym_session_create(
4537 ts_params->valid_devs[0],
4538 &ut_params->auth_xform);
4539 TEST_ASSERT_NOT_NULL(sessions[i],
4540 "Session creation failed at session number %u",
4543 /* Attempt to send a request on each session */
4544 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
4548 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
4549 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
4551 "Failed to perform decrypt on request number %u.", i);
4552 /* free crypto operation structure */
4554 rte_crypto_op_free(ut_params->op);
4557 * free mbuf - both obuf and ibuf are usually the same,
4558 * so check if they point at the same address is necessary,
4559 * to avoid freeing the mbuf twice.
4561 if (ut_params->obuf) {
4562 rte_pktmbuf_free(ut_params->obuf);
4563 if (ut_params->ibuf == ut_params->obuf)
4564 ut_params->ibuf = 0;
4565 ut_params->obuf = 0;
4567 if (ut_params->ibuf) {
4568 rte_pktmbuf_free(ut_params->ibuf);
4569 ut_params->ibuf = 0;
4573 /* Next session create should fail */
4574 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
4575 &ut_params->auth_xform);
4576 TEST_ASSERT_NULL(sessions[i],
4577 "Session creation succeeded unexpectedly!");
4579 for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
4580 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4585 return TEST_SUCCESS;
4588 struct multi_session_params {
4589 struct crypto_unittest_params ut_params;
4590 uint8_t *cipher_key;
4592 const uint8_t *cipher;
4593 const uint8_t *digest;
4597 #define MB_SESSION_NUMBER 3
4600 test_multi_session_random_usage(void)
4602 struct crypto_testsuite_params *ts_params = &testsuite_params;
4603 struct rte_cryptodev_info dev_info;
4604 struct rte_cryptodev_sym_session **sessions;
4606 struct multi_session_params ut_paramz[] = {
4609 .cipher_key = ms_aes_cbc_key0,
4610 .hmac_key = ms_hmac_key0,
4611 .cipher = ms_aes_cbc_cipher0,
4612 .digest = ms_hmac_digest0,
4613 .iv = ms_aes_cbc_iv0
4616 .cipher_key = ms_aes_cbc_key1,
4617 .hmac_key = ms_hmac_key1,
4618 .cipher = ms_aes_cbc_cipher1,
4619 .digest = ms_hmac_digest1,
4620 .iv = ms_aes_cbc_iv1
4623 .cipher_key = ms_aes_cbc_key2,
4624 .hmac_key = ms_hmac_key2,
4625 .cipher = ms_aes_cbc_cipher2,
4626 .digest = ms_hmac_digest2,
4627 .iv = ms_aes_cbc_iv2
4632 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4634 sessions = rte_malloc(NULL,
4635 (sizeof(struct rte_cryptodev_sym_session *)
4636 * dev_info.sym.max_nb_sessions) + 1, 0);
4638 for (i = 0; i < MB_SESSION_NUMBER; i++) {
4639 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
4640 sizeof(struct crypto_unittest_params));
4642 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
4643 &ut_paramz[i].ut_params,
4644 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
4646 /* Create multiple crypto sessions*/
4647 sessions[i] = rte_cryptodev_sym_session_create(
4648 ts_params->valid_devs[0],
4649 &ut_paramz[i].ut_params.auth_xform);
4651 TEST_ASSERT_NOT_NULL(sessions[i],
4652 "Session creation failed at session number %u",
4658 for (i = 0; i < 40000; i++) {
4660 j = rand() % MB_SESSION_NUMBER;
4662 TEST_ASSERT_SUCCESS(
4663 test_AES_CBC_HMAC_SHA512_decrypt_perform(
4665 &ut_paramz[j].ut_params,
4666 ts_params, ut_paramz[j].cipher,
4667 ut_paramz[j].digest,
4669 "Failed to perform decrypt on request number %u.", i);
4671 if (ut_paramz[j].ut_params.op)
4672 rte_crypto_op_free(ut_paramz[j].ut_params.op);
4675 * free mbuf - both obuf and ibuf are usually the same,
4676 * so check if they point at the same address is necessary,
4677 * to avoid freeing the mbuf twice.
4679 if (ut_paramz[j].ut_params.obuf) {
4680 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
4681 if (ut_paramz[j].ut_params.ibuf
4682 == ut_paramz[j].ut_params.obuf)
4683 ut_paramz[j].ut_params.ibuf = 0;
4684 ut_paramz[j].ut_params.obuf = 0;
4686 if (ut_paramz[j].ut_params.ibuf) {
4687 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
4688 ut_paramz[j].ut_params.ibuf = 0;
4692 for (i = 0; i < MB_SESSION_NUMBER; i++)
4693 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4698 return TEST_SUCCESS;
4702 test_null_cipher_only_operation(void)
4704 struct crypto_testsuite_params *ts_params = &testsuite_params;
4705 struct crypto_unittest_params *ut_params = &unittest_params;
4707 /* Generate test mbuf data and space for digest */
4708 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4709 catch_22_quote, QUOTE_512_BYTES, 0);
4711 /* Setup Cipher Parameters */
4712 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4713 ut_params->cipher_xform.next = NULL;
4715 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4716 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4718 /* Create Crypto session*/
4719 ut_params->sess = rte_cryptodev_sym_session_create(
4720 ts_params->valid_devs[0], &ut_params->cipher_xform);
4721 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4723 /* Generate Crypto op data structure */
4724 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4725 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4726 TEST_ASSERT_NOT_NULL(ut_params->op,
4727 "Failed to allocate symmetric crypto operation struct");
4729 /* Set crypto operation data parameters */
4730 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4732 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4734 /* set crypto operation source mbuf */
4735 sym_op->m_src = ut_params->ibuf;
4737 sym_op->cipher.data.offset = 0;
4738 sym_op->cipher.data.length = QUOTE_512_BYTES;
4740 /* Process crypto operation */
4741 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4743 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4745 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4746 "crypto operation processing failed");
4749 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4750 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4753 "Ciphertext data not as expected");
4755 return TEST_SUCCESS;
4759 test_null_auth_only_operation(void)
4761 struct crypto_testsuite_params *ts_params = &testsuite_params;
4762 struct crypto_unittest_params *ut_params = &unittest_params;
4764 /* Generate test mbuf data and space for digest */
4765 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4766 catch_22_quote, QUOTE_512_BYTES, 0);
4768 /* Setup HMAC Parameters */
4769 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4770 ut_params->auth_xform.next = NULL;
4772 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4773 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4775 /* Create Crypto session*/
4776 ut_params->sess = rte_cryptodev_sym_session_create(
4777 ts_params->valid_devs[0], &ut_params->auth_xform);
4778 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4780 /* Generate Crypto op data structure */
4781 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4782 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4783 TEST_ASSERT_NOT_NULL(ut_params->op,
4784 "Failed to allocate symmetric crypto operation struct");
4786 /* Set crypto operation data parameters */
4787 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4789 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4791 sym_op->m_src = ut_params->ibuf;
4793 sym_op->auth.data.offset = 0;
4794 sym_op->auth.data.length = QUOTE_512_BYTES;
4796 /* Process crypto operation */
4797 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4799 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4801 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4802 "crypto operation processing failed");
4804 return TEST_SUCCESS;
4808 test_null_cipher_auth_operation(void)
4810 struct crypto_testsuite_params *ts_params = &testsuite_params;
4811 struct crypto_unittest_params *ut_params = &unittest_params;
4813 /* Generate test mbuf data and space for digest */
4814 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4815 catch_22_quote, QUOTE_512_BYTES, 0);
4817 /* Setup Cipher Parameters */
4818 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4819 ut_params->cipher_xform.next = &ut_params->auth_xform;
4821 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4822 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4824 /* Setup HMAC Parameters */
4825 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4826 ut_params->auth_xform.next = NULL;
4828 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4829 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4831 /* Create Crypto session*/
4832 ut_params->sess = rte_cryptodev_sym_session_create(
4833 ts_params->valid_devs[0], &ut_params->cipher_xform);
4834 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4836 /* Generate Crypto op data structure */
4837 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4838 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4839 TEST_ASSERT_NOT_NULL(ut_params->op,
4840 "Failed to allocate symmetric crypto operation struct");
4842 /* Set crypto operation data parameters */
4843 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4845 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4847 sym_op->m_src = ut_params->ibuf;
4849 sym_op->cipher.data.offset = 0;
4850 sym_op->cipher.data.length = QUOTE_512_BYTES;
4852 sym_op->auth.data.offset = 0;
4853 sym_op->auth.data.length = QUOTE_512_BYTES;
4855 /* Process crypto operation */
4856 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4858 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4860 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4861 "crypto operation processing failed");
4864 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4865 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4868 "Ciphertext data not as expected");
4870 return TEST_SUCCESS;
4874 test_null_auth_cipher_operation(void)
4876 struct crypto_testsuite_params *ts_params = &testsuite_params;
4877 struct crypto_unittest_params *ut_params = &unittest_params;
4879 /* Generate test mbuf data and space for digest */
4880 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4881 catch_22_quote, QUOTE_512_BYTES, 0);
4883 /* Setup Cipher Parameters */
4884 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4885 ut_params->cipher_xform.next = NULL;
4887 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4888 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4890 /* Setup HMAC Parameters */
4891 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4892 ut_params->auth_xform.next = &ut_params->cipher_xform;
4894 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4895 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4897 /* Create Crypto session*/
4898 ut_params->sess = rte_cryptodev_sym_session_create(
4899 ts_params->valid_devs[0], &ut_params->cipher_xform);
4900 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4902 /* Generate Crypto op data structure */
4903 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4904 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4905 TEST_ASSERT_NOT_NULL(ut_params->op,
4906 "Failed to allocate symmetric crypto operation struct");
4908 /* Set crypto operation data parameters */
4909 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4911 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4913 sym_op->m_src = ut_params->ibuf;
4915 sym_op->cipher.data.offset = 0;
4916 sym_op->cipher.data.length = QUOTE_512_BYTES;
4918 sym_op->auth.data.offset = 0;
4919 sym_op->auth.data.length = QUOTE_512_BYTES;
4921 /* Process crypto operation */
4922 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4924 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4926 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4927 "crypto operation processing failed");
4930 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4931 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4934 "Ciphertext data not as expected");
4936 return TEST_SUCCESS;
4941 test_null_invalid_operation(void)
4943 struct crypto_testsuite_params *ts_params = &testsuite_params;
4944 struct crypto_unittest_params *ut_params = &unittest_params;
4946 /* Setup Cipher Parameters */
4947 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4948 ut_params->cipher_xform.next = NULL;
4950 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
4951 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4953 /* Create Crypto session*/
4954 ut_params->sess = rte_cryptodev_sym_session_create(
4955 ts_params->valid_devs[0], &ut_params->cipher_xform);
4956 TEST_ASSERT_NULL(ut_params->sess,
4957 "Session creation succeeded unexpectedly");
4960 /* Setup HMAC Parameters */
4961 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4962 ut_params->auth_xform.next = NULL;
4964 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
4965 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4967 /* Create Crypto session*/
4968 ut_params->sess = rte_cryptodev_sym_session_create(
4969 ts_params->valid_devs[0], &ut_params->auth_xform);
4970 TEST_ASSERT_NULL(ut_params->sess,
4971 "Session creation succeeded unexpectedly");
4973 return TEST_SUCCESS;
4977 #define NULL_BURST_LENGTH (32)
4980 test_null_burst_operation(void)
4982 struct crypto_testsuite_params *ts_params = &testsuite_params;
4983 struct crypto_unittest_params *ut_params = &unittest_params;
4985 unsigned i, burst_len = NULL_BURST_LENGTH;
4987 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
4988 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
4990 /* Setup Cipher Parameters */
4991 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4992 ut_params->cipher_xform.next = &ut_params->auth_xform;
4994 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4995 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4997 /* Setup HMAC Parameters */
4998 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4999 ut_params->auth_xform.next = NULL;
5001 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
5002 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5004 /* Create Crypto session*/
5005 ut_params->sess = rte_cryptodev_sym_session_create(
5006 ts_params->valid_devs[0], &ut_params->cipher_xform);
5007 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5009 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
5010 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
5011 burst_len, "failed to generate burst of crypto ops");
5013 /* Generate an operation for each mbuf in burst */
5014 for (i = 0; i < burst_len; i++) {
5015 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5017 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
5019 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
5023 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
5025 burst[i]->sym->m_src = m;
5028 /* Process crypto operation */
5029 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
5030 0, burst, burst_len),
5032 "Error enqueuing burst");
5034 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
5035 0, burst_dequeued, burst_len),
5037 "Error dequeuing burst");
5040 for (i = 0; i < burst_len; i++) {
5042 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
5043 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
5045 "data not as expected");
5047 rte_pktmbuf_free(burst[i]->sym->m_src);
5048 rte_crypto_op_free(burst[i]);
5051 return TEST_SUCCESS;
5055 generate_gmac_large_plaintext(uint8_t *data)
5059 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
5060 memcpy(&data[i], &data[0], 32);
5064 create_gmac_operation(enum rte_crypto_auth_operation op,
5065 const struct gmac_test_data *tdata)
5067 struct crypto_testsuite_params *ts_params = &testsuite_params;
5068 struct crypto_unittest_params *ut_params = &unittest_params;
5069 struct rte_crypto_sym_op *sym_op;
5071 unsigned iv_pad_len;
5072 unsigned aad_pad_len;
5074 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
5075 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5078 * Runtime generate the large plain text instead of use hard code
5079 * plain text vector. It is done to avoid create huge source file
5080 * with the test vector.
5082 if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
5083 generate_gmac_large_plaintext(tdata->aad.data);
5085 /* Generate Crypto op data structure */
5086 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5087 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5088 TEST_ASSERT_NOT_NULL(ut_params->op,
5089 "Failed to allocate symmetric crypto operation struct");
5091 sym_op = ut_params->op->sym;
5092 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5094 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
5095 "no room to append aad");
5097 sym_op->auth.aad.length = tdata->aad.len;
5098 sym_op->auth.aad.phys_addr =
5099 rte_pktmbuf_mtophys(ut_params->ibuf);
5100 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
5102 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5103 ut_params->ibuf, tdata->gmac_tag.len);
5104 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5105 "no room to append digest");
5107 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5108 ut_params->ibuf, aad_pad_len);
5109 sym_op->auth.digest.length = tdata->gmac_tag.len;
5111 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5112 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
5113 tdata->gmac_tag.len);
5114 TEST_HEXDUMP(stdout, "digest:",
5115 sym_op->auth.digest.data,
5116 sym_op->auth.digest.length);
5119 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5120 ut_params->ibuf, iv_pad_len);
5121 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5123 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
5124 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5125 sym_op->cipher.iv.length = tdata->iv.len;
5127 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
5129 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
5131 sym_op->cipher.data.length = 0;
5132 sym_op->cipher.data.offset = 0;
5134 sym_op->auth.data.offset = 0;
5135 sym_op->auth.data.length = 0;
5140 static int create_gmac_session(uint8_t dev_id,
5141 enum rte_crypto_cipher_operation op,
5142 const struct gmac_test_data *tdata,
5143 enum rte_crypto_auth_operation auth_op)
5145 uint8_t cipher_key[tdata->key.len];
5147 struct crypto_unittest_params *ut_params = &unittest_params;
5149 memcpy(cipher_key, tdata->key.data, tdata->key.len);
5151 /* For GMAC we setup cipher parameters */
5152 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5153 ut_params->cipher_xform.next = NULL;
5154 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
5155 ut_params->cipher_xform.cipher.op = op;
5156 ut_params->cipher_xform.cipher.key.data = cipher_key;
5157 ut_params->cipher_xform.cipher.key.length = tdata->key.len;
5159 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5160 ut_params->auth_xform.next = NULL;
5162 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
5163 ut_params->auth_xform.auth.op = auth_op;
5164 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
5165 ut_params->auth_xform.auth.add_auth_data_length = 0;
5166 ut_params->auth_xform.auth.key.length = 0;
5167 ut_params->auth_xform.auth.key.data = NULL;
5169 ut_params->cipher_xform.next = &ut_params->auth_xform;
5171 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5172 &ut_params->cipher_xform);
5174 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5180 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
5182 struct crypto_testsuite_params *ts_params = &testsuite_params;
5183 struct crypto_unittest_params *ut_params = &unittest_params;
5187 uint8_t *auth_tag, *p;
5188 uint16_t aad_pad_len;
5190 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5191 "No GMAC length in the source data");
5193 retval = create_gmac_session(ts_params->valid_devs[0],
5194 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5195 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
5200 if (tdata->aad.len > MBUF_SIZE)
5201 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5203 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5204 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5205 "Failed to allocate input buffer in mempool");
5207 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5208 rte_pktmbuf_tailroom(ut_params->ibuf));
5210 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5212 p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
5214 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
5220 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5222 ut_params->op->sym->m_src = ut_params->ibuf;
5224 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5225 ut_params->op), "failed to process sym crypto op");
5227 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5228 "crypto op processing failed");
5230 if (ut_params->op->sym->m_dst) {
5231 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5232 uint8_t *, aad_pad_len);
5234 auth_tag = p + aad_pad_len;
5237 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
5239 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5241 tdata->gmac_tag.data,
5242 tdata->gmac_tag.len,
5243 "GMAC Generated auth tag not as expected");
5249 test_AES_GMAC_authentication_test_case_1(void)
5251 return test_AES_GMAC_authentication(&gmac_test_case_1);
5255 test_AES_GMAC_authentication_test_case_2(void)
5257 return test_AES_GMAC_authentication(&gmac_test_case_2);
5261 test_AES_GMAC_authentication_test_case_3(void)
5263 return test_AES_GMAC_authentication(&gmac_test_case_3);
5267 test_AES_GMAC_authentication_test_case_4(void)
5269 return test_AES_GMAC_authentication(&gmac_test_case_4);
5273 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
5275 struct crypto_testsuite_params *ts_params = &testsuite_params;
5276 struct crypto_unittest_params *ut_params = &unittest_params;
5279 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5280 "No GMAC length in the source data");
5282 retval = create_gmac_session(ts_params->valid_devs[0],
5283 RTE_CRYPTO_CIPHER_OP_DECRYPT,
5284 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
5289 if (tdata->aad.len > MBUF_SIZE)
5290 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5292 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5293 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5294 "Failed to allocate input buffer in mempool");
5296 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5297 rte_pktmbuf_tailroom(ut_params->ibuf));
5299 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
5305 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5307 ut_params->op->sym->m_src = ut_params->ibuf;
5309 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5310 ut_params->op), "failed to process sym crypto op");
5312 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5313 "crypto op processing failed");
5320 test_AES_GMAC_authentication_verify_test_case_1(void)
5322 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
5326 test_AES_GMAC_authentication_verify_test_case_2(void)
5328 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
5332 test_AES_GMAC_authentication_verify_test_case_3(void)
5334 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
5338 test_AES_GMAC_authentication_verify_test_case_4(void)
5340 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
5343 struct test_crypto_vector {
5344 enum rte_crypto_cipher_algorithm crypto_algo;
5357 const uint8_t *data;
5362 const uint8_t *data;
5366 enum rte_crypto_auth_algorithm auth_algo;
5374 const uint8_t *data;
5384 static const struct test_crypto_vector
5385 hmac_sha1_test_crypto_vector = {
5386 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5388 .data = plaintext_hash,
5393 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5394 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5395 0xDE, 0xF4, 0xDE, 0xAD
5401 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
5402 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
5403 0x3F, 0x91, 0x64, 0x59
5409 static const struct test_crypto_vector
5410 aes128_gmac_test_vector = {
5411 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
5412 .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
5414 .data = plaintext_hash,
5419 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5420 0x08, 0x09, 0x0A, 0x0B
5426 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5427 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
5433 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
5434 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
5440 static const struct test_crypto_vector
5441 aes128cbc_hmac_sha1_test_vector = {
5442 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
5445 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
5446 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
5452 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5453 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
5458 .data = plaintext_hash,
5462 .data = ciphertext512_aes128cbc,
5465 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5468 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5469 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5470 0xDE, 0xF4, 0xDE, 0xAD
5476 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
5477 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5478 0x18, 0x8C, 0x1D, 0x32
5485 data_corruption(uint8_t *data)
5491 tag_corruption(uint8_t *data, unsigned int tag_offset)
5493 data[tag_offset] += 1;
5497 create_auth_session(struct crypto_unittest_params *ut_params,
5499 const struct test_crypto_vector *reference,
5500 enum rte_crypto_auth_operation auth_op)
5502 uint8_t auth_key[reference->auth_key.len + 1];
5504 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5506 /* Setup Authentication Parameters */
5507 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5508 ut_params->auth_xform.auth.op = auth_op;
5509 ut_params->auth_xform.next = NULL;
5510 ut_params->auth_xform.auth.algo = reference->auth_algo;
5511 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5512 ut_params->auth_xform.auth.key.data = auth_key;
5513 ut_params->auth_xform.auth.digest_length = reference->digest.len;
5514 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5516 /* Create Crypto session*/
5517 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5518 &ut_params->auth_xform);
5520 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5526 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
5528 const struct test_crypto_vector *reference,
5529 enum rte_crypto_auth_operation auth_op,
5530 enum rte_crypto_cipher_operation cipher_op)
5532 uint8_t cipher_key[reference->cipher_key.len + 1];
5533 uint8_t auth_key[reference->auth_key.len + 1];
5535 memcpy(cipher_key, reference->cipher_key.data,
5536 reference->cipher_key.len);
5537 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5539 /* Setup Authentication Parameters */
5540 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5541 ut_params->auth_xform.auth.op = auth_op;
5542 ut_params->auth_xform.next = &ut_params->cipher_xform;
5543 ut_params->auth_xform.auth.algo = reference->auth_algo;
5544 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5545 ut_params->auth_xform.auth.key.data = auth_key;
5546 ut_params->auth_xform.auth.digest_length = reference->digest.len;
5547 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5549 /* Setup Cipher Parameters */
5550 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5551 ut_params->cipher_xform.next = NULL;
5552 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
5553 ut_params->cipher_xform.cipher.op = cipher_op;
5554 ut_params->cipher_xform.cipher.key.data = cipher_key;
5555 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
5557 /* Create Crypto session*/
5558 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5559 &ut_params->auth_xform);
5561 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5567 create_auth_operation(struct crypto_testsuite_params *ts_params,
5568 struct crypto_unittest_params *ut_params,
5569 const struct test_crypto_vector *reference,
5570 unsigned int auth_generate)
5572 /* Generate Crypto op data structure */
5573 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5574 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5575 TEST_ASSERT_NOT_NULL(ut_params->op,
5576 "Failed to allocate pktmbuf offload");
5578 /* Set crypto operation data parameters */
5579 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5581 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5583 /* set crypto operation source mbuf */
5584 sym_op->m_src = ut_params->ibuf;
5587 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5588 ut_params->ibuf, reference->digest.len);
5590 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5591 "no room to append auth tag");
5593 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5594 ut_params->ibuf, reference->plaintext.len);
5595 sym_op->auth.digest.length = reference->digest.len;
5598 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5600 memcpy(sym_op->auth.digest.data,
5601 reference->digest.data,
5602 reference->digest.len);
5604 TEST_HEXDUMP(stdout, "digest:",
5605 sym_op->auth.digest.data,
5606 sym_op->auth.digest.length);
5608 sym_op->auth.data.length = reference->plaintext.len;
5609 sym_op->auth.data.offset = 0;
5615 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
5616 struct crypto_unittest_params *ut_params,
5617 const struct test_crypto_vector *reference,
5618 unsigned int auth_generate)
5620 /* Generate Crypto op data structure */
5621 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5622 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5623 TEST_ASSERT_NOT_NULL(ut_params->op,
5624 "Failed to allocate pktmbuf offload");
5626 /* Set crypto operation data parameters */
5627 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5629 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5631 /* set crypto operation source mbuf */
5632 sym_op->m_src = ut_params->ibuf;
5635 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5636 reference->aad.len);
5637 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
5638 memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
5640 TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
5642 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5643 sym_op->auth.aad.length = reference->aad.len;
5646 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5647 ut_params->ibuf, reference->digest.len);
5649 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5650 "no room to append auth tag");
5652 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5653 ut_params->ibuf, reference->ciphertext.len);
5654 sym_op->auth.digest.length = reference->digest.len;
5657 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5659 memcpy(sym_op->auth.digest.data,
5660 reference->digest.data,
5661 reference->digest.len);
5663 TEST_HEXDUMP(stdout, "digest:",
5664 sym_op->auth.digest.data,
5665 sym_op->auth.digest.length);
5667 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5668 ut_params->ibuf, reference->iv.len);
5669 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5671 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5672 sym_op->cipher.iv.length = reference->iv.len;
5674 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5676 sym_op->cipher.data.length = 0;
5677 sym_op->cipher.data.offset = 0;
5679 sym_op->auth.data.length = 0;
5680 sym_op->auth.data.offset = 0;
5686 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
5687 struct crypto_unittest_params *ut_params,
5688 const struct test_crypto_vector *reference,
5689 unsigned int auth_generate)
5691 /* Generate Crypto op data structure */
5692 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5693 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5694 TEST_ASSERT_NOT_NULL(ut_params->op,
5695 "Failed to allocate pktmbuf offload");
5697 /* Set crypto operation data parameters */
5698 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5700 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5702 /* set crypto operation source mbuf */
5703 sym_op->m_src = ut_params->ibuf;
5706 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5707 ut_params->ibuf, reference->digest.len);
5709 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5710 "no room to append auth tag");
5712 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5713 ut_params->ibuf, reference->ciphertext.len);
5714 sym_op->auth.digest.length = reference->digest.len;
5717 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5719 memcpy(sym_op->auth.digest.data,
5720 reference->digest.data,
5721 reference->digest.len);
5723 TEST_HEXDUMP(stdout, "digest:",
5724 sym_op->auth.digest.data,
5725 sym_op->auth.digest.length);
5727 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5728 ut_params->ibuf, reference->iv.len);
5729 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5731 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5732 sym_op->cipher.iv.length = reference->iv.len;
5734 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5736 sym_op->cipher.data.length = reference->ciphertext.len;
5737 sym_op->cipher.data.offset = reference->iv.len;
5739 sym_op->auth.data.length = reference->ciphertext.len;
5740 sym_op->auth.data.offset = reference->iv.len;
5746 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
5747 struct crypto_unittest_params *ut_params,
5748 const struct test_crypto_vector *reference)
5750 return create_auth_operation(ts_params, ut_params, reference, 0);
5754 create_auth_verify_GMAC_operation(
5755 struct crypto_testsuite_params *ts_params,
5756 struct crypto_unittest_params *ut_params,
5757 const struct test_crypto_vector *reference)
5759 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
5763 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
5764 struct crypto_unittest_params *ut_params,
5765 const struct test_crypto_vector *reference)
5767 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
5771 test_authentication_verify_fail_when_data_corruption(
5772 struct crypto_testsuite_params *ts_params,
5773 struct crypto_unittest_params *ut_params,
5774 const struct test_crypto_vector *reference,
5775 unsigned int data_corrupted)
5781 /* Create session */
5782 retval = create_auth_session(ut_params,
5783 ts_params->valid_devs[0],
5785 RTE_CRYPTO_AUTH_OP_VERIFY);
5789 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5790 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5791 "Failed to allocate input buffer in mempool");
5793 /* clear mbuf payload */
5794 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5795 rte_pktmbuf_tailroom(ut_params->ibuf));
5797 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5798 reference->plaintext.len);
5799 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
5800 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
5802 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
5804 /* Create operation */
5805 retval = create_auth_verify_operation(ts_params, ut_params, reference);
5811 data_corruption(plaintext);
5813 tag_corruption(plaintext, reference->plaintext.len);
5815 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5817 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5818 TEST_ASSERT_EQUAL(ut_params->op->status,
5819 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5820 "authentication not failed");
5822 ut_params->obuf = ut_params->op->sym->m_src;
5823 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5829 test_authentication_verify_GMAC_fail_when_corruption(
5830 struct crypto_testsuite_params *ts_params,
5831 struct crypto_unittest_params *ut_params,
5832 const struct test_crypto_vector *reference,
5833 unsigned int data_corrupted)
5837 /* Create session */
5838 retval = create_auth_cipher_session(ut_params,
5839 ts_params->valid_devs[0],
5841 RTE_CRYPTO_AUTH_OP_VERIFY,
5842 RTE_CRYPTO_CIPHER_OP_DECRYPT);
5846 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5847 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5848 "Failed to allocate input buffer in mempool");
5850 /* clear mbuf payload */
5851 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5852 rte_pktmbuf_tailroom(ut_params->ibuf));
5854 /* Create operation */
5855 retval = create_auth_verify_GMAC_operation(ts_params,
5863 data_corruption(ut_params->op->sym->auth.aad.data);
5865 tag_corruption(ut_params->op->sym->auth.aad.data,
5866 reference->aad.len);
5868 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5870 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5871 TEST_ASSERT_EQUAL(ut_params->op->status,
5872 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5873 "authentication not failed");
5875 ut_params->obuf = ut_params->op->sym->m_src;
5876 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5882 test_authenticated_decryption_fail_when_corruption(
5883 struct crypto_testsuite_params *ts_params,
5884 struct crypto_unittest_params *ut_params,
5885 const struct test_crypto_vector *reference,
5886 unsigned int data_corrupted)
5890 uint8_t *ciphertext;
5892 /* Create session */
5893 retval = create_auth_cipher_session(ut_params,
5894 ts_params->valid_devs[0],
5896 RTE_CRYPTO_AUTH_OP_VERIFY,
5897 RTE_CRYPTO_CIPHER_OP_DECRYPT);
5901 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5902 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5903 "Failed to allocate input buffer in mempool");
5905 /* clear mbuf payload */
5906 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5907 rte_pktmbuf_tailroom(ut_params->ibuf));
5909 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5910 reference->ciphertext.len);
5911 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
5912 memcpy(ciphertext, reference->ciphertext.data,
5913 reference->ciphertext.len);
5915 /* Create operation */
5916 retval = create_cipher_auth_verify_operation(ts_params,
5924 data_corruption(ciphertext);
5926 tag_corruption(ciphertext, reference->ciphertext.len);
5928 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5931 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5932 TEST_ASSERT_EQUAL(ut_params->op->status,
5933 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5934 "authentication not failed");
5936 ut_params->obuf = ut_params->op->sym->m_src;
5937 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5943 test_authentication_verify_fail_when_data_corrupted(
5944 struct crypto_testsuite_params *ts_params,
5945 struct crypto_unittest_params *ut_params,
5946 const struct test_crypto_vector *reference)
5948 return test_authentication_verify_fail_when_data_corruption(
5949 ts_params, ut_params, reference, 1);
5953 test_authentication_verify_fail_when_tag_corrupted(
5954 struct crypto_testsuite_params *ts_params,
5955 struct crypto_unittest_params *ut_params,
5956 const struct test_crypto_vector *reference)
5958 return test_authentication_verify_fail_when_data_corruption(
5959 ts_params, ut_params, reference, 0);
5963 test_authentication_verify_GMAC_fail_when_data_corrupted(
5964 struct crypto_testsuite_params *ts_params,
5965 struct crypto_unittest_params *ut_params,
5966 const struct test_crypto_vector *reference)
5968 return test_authentication_verify_GMAC_fail_when_corruption(
5969 ts_params, ut_params, reference, 1);
5973 test_authentication_verify_GMAC_fail_when_tag_corrupted(
5974 struct crypto_testsuite_params *ts_params,
5975 struct crypto_unittest_params *ut_params,
5976 const struct test_crypto_vector *reference)
5978 return test_authentication_verify_GMAC_fail_when_corruption(
5979 ts_params, ut_params, reference, 0);
5983 test_authenticated_decryption_fail_when_data_corrupted(
5984 struct crypto_testsuite_params *ts_params,
5985 struct crypto_unittest_params *ut_params,
5986 const struct test_crypto_vector *reference)
5988 return test_authenticated_decryption_fail_when_corruption(
5989 ts_params, ut_params, reference, 1);
5993 test_authenticated_decryption_fail_when_tag_corrupted(
5994 struct crypto_testsuite_params *ts_params,
5995 struct crypto_unittest_params *ut_params,
5996 const struct test_crypto_vector *reference)
5998 return test_authenticated_decryption_fail_when_corruption(
5999 ts_params, ut_params, reference, 0);
6003 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
6005 return test_authentication_verify_fail_when_data_corrupted(
6006 &testsuite_params, &unittest_params,
6007 &hmac_sha1_test_crypto_vector);
6011 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
6013 return test_authentication_verify_fail_when_tag_corrupted(
6014 &testsuite_params, &unittest_params,
6015 &hmac_sha1_test_crypto_vector);
6019 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
6021 return test_authentication_verify_GMAC_fail_when_data_corrupted(
6022 &testsuite_params, &unittest_params,
6023 &aes128_gmac_test_vector);
6027 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
6029 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
6030 &testsuite_params, &unittest_params,
6031 &aes128_gmac_test_vector);
6035 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
6037 return test_authenticated_decryption_fail_when_data_corrupted(
6040 &aes128cbc_hmac_sha1_test_vector);
6044 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
6046 return test_authenticated_decryption_fail_when_tag_corrupted(
6049 &aes128cbc_hmac_sha1_test_vector);
6052 static struct unit_test_suite cryptodev_qat_testsuite = {
6053 .suite_name = "Crypto QAT Unit Test Suite",
6054 .setup = testsuite_setup,
6055 .teardown = testsuite_teardown,
6056 .unit_test_cases = {
6057 TEST_CASE_ST(ut_setup, ut_teardown,
6058 test_device_configure_invalid_dev_id),
6059 TEST_CASE_ST(ut_setup, ut_teardown,
6060 test_device_configure_invalid_queue_pair_ids),
6061 TEST_CASE_ST(ut_setup, ut_teardown,
6062 test_queue_pair_descriptor_setup),
6063 TEST_CASE_ST(ut_setup, ut_teardown,
6064 test_multi_session),
6066 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
6067 TEST_CASE_ST(ut_setup, ut_teardown,
6068 test_AES_cipheronly_qat_all),
6069 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
6070 TEST_CASE_ST(ut_setup, ut_teardown,
6071 test_3DES_cipheronly_qat_all),
6072 TEST_CASE_ST(ut_setup, ut_teardown,
6073 test_DES_cipheronly_qat_all),
6074 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
6076 /** AES GCM Authenticated Encryption */
6077 TEST_CASE_ST(ut_setup, ut_teardown,
6078 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6079 TEST_CASE_ST(ut_setup, ut_teardown,
6080 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6081 TEST_CASE_ST(ut_setup, ut_teardown,
6082 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6083 TEST_CASE_ST(ut_setup, ut_teardown,
6084 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6085 TEST_CASE_ST(ut_setup, ut_teardown,
6086 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6087 TEST_CASE_ST(ut_setup, ut_teardown,
6088 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6089 TEST_CASE_ST(ut_setup, ut_teardown,
6090 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6092 /** AES GCM Authenticated Decryption */
6093 TEST_CASE_ST(ut_setup, ut_teardown,
6094 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6095 TEST_CASE_ST(ut_setup, ut_teardown,
6096 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6097 TEST_CASE_ST(ut_setup, ut_teardown,
6098 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6099 TEST_CASE_ST(ut_setup, ut_teardown,
6100 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6101 TEST_CASE_ST(ut_setup, ut_teardown,
6102 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6103 TEST_CASE_ST(ut_setup, ut_teardown,
6104 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6105 TEST_CASE_ST(ut_setup, ut_teardown,
6106 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6108 /** AES GMAC Authentication */
6109 TEST_CASE_ST(ut_setup, ut_teardown,
6110 test_AES_GMAC_authentication_test_case_1),
6111 TEST_CASE_ST(ut_setup, ut_teardown,
6112 test_AES_GMAC_authentication_verify_test_case_1),
6113 TEST_CASE_ST(ut_setup, ut_teardown,
6114 test_AES_GMAC_authentication_test_case_2),
6115 TEST_CASE_ST(ut_setup, ut_teardown,
6116 test_AES_GMAC_authentication_verify_test_case_2),
6117 TEST_CASE_ST(ut_setup, ut_teardown,
6118 test_AES_GMAC_authentication_test_case_3),
6119 TEST_CASE_ST(ut_setup, ut_teardown,
6120 test_AES_GMAC_authentication_verify_test_case_3),
6122 /** SNOW 3G encrypt only (UEA2) */
6123 TEST_CASE_ST(ut_setup, ut_teardown,
6124 test_snow3g_encryption_test_case_1),
6125 TEST_CASE_ST(ut_setup, ut_teardown,
6126 test_snow3g_encryption_test_case_2),
6127 TEST_CASE_ST(ut_setup, ut_teardown,
6128 test_snow3g_encryption_test_case_3),
6129 TEST_CASE_ST(ut_setup, ut_teardown,
6130 test_snow3g_encryption_test_case_4),
6131 TEST_CASE_ST(ut_setup, ut_teardown,
6132 test_snow3g_encryption_test_case_5),
6134 TEST_CASE_ST(ut_setup, ut_teardown,
6135 test_snow3g_encryption_test_case_1_oop),
6136 TEST_CASE_ST(ut_setup, ut_teardown,
6137 test_snow3g_decryption_test_case_1_oop),
6139 /** SNOW 3G decrypt only (UEA2) */
6140 TEST_CASE_ST(ut_setup, ut_teardown,
6141 test_snow3g_decryption_test_case_1),
6142 TEST_CASE_ST(ut_setup, ut_teardown,
6143 test_snow3g_decryption_test_case_2),
6144 TEST_CASE_ST(ut_setup, ut_teardown,
6145 test_snow3g_decryption_test_case_3),
6146 TEST_CASE_ST(ut_setup, ut_teardown,
6147 test_snow3g_decryption_test_case_4),
6148 TEST_CASE_ST(ut_setup, ut_teardown,
6149 test_snow3g_decryption_test_case_5),
6150 TEST_CASE_ST(ut_setup, ut_teardown,
6151 test_snow3g_hash_generate_test_case_1),
6152 TEST_CASE_ST(ut_setup, ut_teardown,
6153 test_snow3g_hash_generate_test_case_2),
6154 TEST_CASE_ST(ut_setup, ut_teardown,
6155 test_snow3g_hash_generate_test_case_3),
6156 TEST_CASE_ST(ut_setup, ut_teardown,
6157 test_snow3g_hash_verify_test_case_1),
6158 TEST_CASE_ST(ut_setup, ut_teardown,
6159 test_snow3g_hash_verify_test_case_2),
6160 TEST_CASE_ST(ut_setup, ut_teardown,
6161 test_snow3g_hash_verify_test_case_3),
6162 TEST_CASE_ST(ut_setup, ut_teardown,
6163 test_snow3g_cipher_auth_test_case_1),
6164 TEST_CASE_ST(ut_setup, ut_teardown,
6165 test_snow3g_auth_cipher_test_case_1),
6167 /** HMAC_MD5 Authentication */
6168 TEST_CASE_ST(ut_setup, ut_teardown,
6169 test_MD5_HMAC_generate_case_1),
6170 TEST_CASE_ST(ut_setup, ut_teardown,
6171 test_MD5_HMAC_verify_case_1),
6172 TEST_CASE_ST(ut_setup, ut_teardown,
6173 test_MD5_HMAC_generate_case_2),
6174 TEST_CASE_ST(ut_setup, ut_teardown,
6175 test_MD5_HMAC_verify_case_2),
6178 TEST_CASE_ST(ut_setup, ut_teardown,
6179 test_null_auth_only_operation),
6180 TEST_CASE_ST(ut_setup, ut_teardown,
6181 test_null_cipher_only_operation),
6182 TEST_CASE_ST(ut_setup, ut_teardown,
6183 test_null_cipher_auth_operation),
6184 TEST_CASE_ST(ut_setup, ut_teardown,
6185 test_null_auth_cipher_operation),
6187 TEST_CASE_ST(ut_setup, ut_teardown,
6188 test_kasumi_hash_generate_test_case_6),
6191 TEST_CASE_ST(ut_setup, ut_teardown,
6192 test_kasumi_encryption_test_case_1),
6193 TEST_CASE_ST(ut_setup, ut_teardown,
6194 test_kasumi_encryption_test_case_3),
6195 TEST_CASE_ST(ut_setup, ut_teardown,
6196 test_kasumi_auth_cipher_test_case_1),
6197 TEST_CASE_ST(ut_setup, ut_teardown,
6198 test_kasumi_cipher_auth_test_case_1),
6200 /** Negative tests */
6201 TEST_CASE_ST(ut_setup, ut_teardown,
6202 authentication_verify_HMAC_SHA1_fail_data_corrupt),
6203 TEST_CASE_ST(ut_setup, ut_teardown,
6204 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6205 TEST_CASE_ST(ut_setup, ut_teardown,
6206 authentication_verify_AES128_GMAC_fail_data_corrupt),
6207 TEST_CASE_ST(ut_setup, ut_teardown,
6208 authentication_verify_AES128_GMAC_fail_tag_corrupt),
6209 TEST_CASE_ST(ut_setup, ut_teardown,
6210 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6211 TEST_CASE_ST(ut_setup, ut_teardown,
6212 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6214 TEST_CASES_END() /**< NULL terminate unit test array */
6218 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
6219 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
6220 .setup = testsuite_setup,
6221 .teardown = testsuite_teardown,
6222 .unit_test_cases = {
6223 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
6225 TEST_CASES_END() /**< NULL terminate unit test array */
6229 static struct unit_test_suite cryptodev_openssl_testsuite = {
6230 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
6231 .setup = testsuite_setup,
6232 .teardown = testsuite_teardown,
6233 .unit_test_cases = {
6234 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
6235 TEST_CASE_ST(ut_setup, ut_teardown,
6236 test_multi_session_random_usage),
6237 TEST_CASE_ST(ut_setup, ut_teardown,
6238 test_AES_chain_openssl_all),
6239 TEST_CASE_ST(ut_setup, ut_teardown,
6240 test_AES_cipheronly_openssl_all),
6241 TEST_CASE_ST(ut_setup, ut_teardown,
6242 test_3DES_chain_openssl_all),
6243 TEST_CASE_ST(ut_setup, ut_teardown,
6244 test_3DES_cipheronly_openssl_all),
6245 TEST_CASE_ST(ut_setup, ut_teardown,
6246 test_authonly_openssl_all),
6248 /** AES GCM Authenticated Encryption */
6249 TEST_CASE_ST(ut_setup, ut_teardown,
6250 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6251 TEST_CASE_ST(ut_setup, ut_teardown,
6252 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6253 TEST_CASE_ST(ut_setup, ut_teardown,
6254 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6255 TEST_CASE_ST(ut_setup, ut_teardown,
6256 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6257 TEST_CASE_ST(ut_setup, ut_teardown,
6258 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6259 TEST_CASE_ST(ut_setup, ut_teardown,
6260 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6261 TEST_CASE_ST(ut_setup, ut_teardown,
6262 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6264 /** AES GCM Authenticated Decryption */
6265 TEST_CASE_ST(ut_setup, ut_teardown,
6266 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6267 TEST_CASE_ST(ut_setup, ut_teardown,
6268 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6269 TEST_CASE_ST(ut_setup, ut_teardown,
6270 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6271 TEST_CASE_ST(ut_setup, ut_teardown,
6272 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6273 TEST_CASE_ST(ut_setup, ut_teardown,
6274 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6275 TEST_CASE_ST(ut_setup, ut_teardown,
6276 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6277 TEST_CASE_ST(ut_setup, ut_teardown,
6278 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6280 /** AES GMAC Authentication */
6281 TEST_CASE_ST(ut_setup, ut_teardown,
6282 test_AES_GMAC_authentication_test_case_1),
6283 TEST_CASE_ST(ut_setup, ut_teardown,
6284 test_AES_GMAC_authentication_verify_test_case_1),
6285 TEST_CASE_ST(ut_setup, ut_teardown,
6286 test_AES_GMAC_authentication_test_case_2),
6287 TEST_CASE_ST(ut_setup, ut_teardown,
6288 test_AES_GMAC_authentication_verify_test_case_2),
6289 TEST_CASE_ST(ut_setup, ut_teardown,
6290 test_AES_GMAC_authentication_test_case_3),
6291 TEST_CASE_ST(ut_setup, ut_teardown,
6292 test_AES_GMAC_authentication_verify_test_case_3),
6293 TEST_CASE_ST(ut_setup, ut_teardown,
6294 test_AES_GMAC_authentication_test_case_4),
6295 TEST_CASE_ST(ut_setup, ut_teardown,
6296 test_AES_GMAC_authentication_verify_test_case_4),
6298 /** Negative tests */
6299 TEST_CASE_ST(ut_setup, ut_teardown,
6300 authentication_verify_HMAC_SHA1_fail_data_corrupt),
6301 TEST_CASE_ST(ut_setup, ut_teardown,
6302 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6303 TEST_CASE_ST(ut_setup, ut_teardown,
6304 authentication_verify_AES128_GMAC_fail_data_corrupt),
6305 TEST_CASE_ST(ut_setup, ut_teardown,
6306 authentication_verify_AES128_GMAC_fail_tag_corrupt),
6307 TEST_CASE_ST(ut_setup, ut_teardown,
6308 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6309 TEST_CASE_ST(ut_setup, ut_teardown,
6310 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6312 TEST_CASES_END() /**< NULL terminate unit test array */
6316 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
6317 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
6318 .setup = testsuite_setup,
6319 .teardown = testsuite_teardown,
6320 .unit_test_cases = {
6321 /** AES GCM Authenticated Encryption */
6322 TEST_CASE_ST(ut_setup, ut_teardown,
6323 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6324 TEST_CASE_ST(ut_setup, ut_teardown,
6325 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6326 TEST_CASE_ST(ut_setup, ut_teardown,
6327 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6328 TEST_CASE_ST(ut_setup, ut_teardown,
6329 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6330 TEST_CASE_ST(ut_setup, ut_teardown,
6331 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6332 TEST_CASE_ST(ut_setup, ut_teardown,
6333 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6334 TEST_CASE_ST(ut_setup, ut_teardown,
6335 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6337 /** AES GCM Authenticated Decryption */
6338 TEST_CASE_ST(ut_setup, ut_teardown,
6339 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6340 TEST_CASE_ST(ut_setup, ut_teardown,
6341 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6342 TEST_CASE_ST(ut_setup, ut_teardown,
6343 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6344 TEST_CASE_ST(ut_setup, ut_teardown,
6345 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6346 TEST_CASE_ST(ut_setup, ut_teardown,
6347 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6348 TEST_CASE_ST(ut_setup, ut_teardown,
6349 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6350 TEST_CASE_ST(ut_setup, ut_teardown,
6351 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6353 TEST_CASES_END() /**< NULL terminate unit test array */
6357 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
6358 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
6359 .setup = testsuite_setup,
6360 .teardown = testsuite_teardown,
6361 .unit_test_cases = {
6362 /** KASUMI encrypt only (UEA1) */
6363 TEST_CASE_ST(ut_setup, ut_teardown,
6364 test_kasumi_encryption_test_case_1),
6365 TEST_CASE_ST(ut_setup, ut_teardown,
6366 test_kasumi_encryption_test_case_2),
6367 TEST_CASE_ST(ut_setup, ut_teardown,
6368 test_kasumi_encryption_test_case_3),
6369 TEST_CASE_ST(ut_setup, ut_teardown,
6370 test_kasumi_encryption_test_case_4),
6371 TEST_CASE_ST(ut_setup, ut_teardown,
6372 test_kasumi_encryption_test_case_5),
6373 /** KASUMI decrypt only (UEA1) */
6374 TEST_CASE_ST(ut_setup, ut_teardown,
6375 test_kasumi_decryption_test_case_1),
6376 TEST_CASE_ST(ut_setup, ut_teardown,
6377 test_kasumi_decryption_test_case_2),
6378 TEST_CASE_ST(ut_setup, ut_teardown,
6379 test_kasumi_decryption_test_case_3),
6380 TEST_CASE_ST(ut_setup, ut_teardown,
6381 test_kasumi_decryption_test_case_4),
6382 TEST_CASE_ST(ut_setup, ut_teardown,
6383 test_kasumi_decryption_test_case_5),
6385 TEST_CASE_ST(ut_setup, ut_teardown,
6386 test_kasumi_encryption_test_case_1_oop),
6387 TEST_CASE_ST(ut_setup, ut_teardown,
6388 test_kasumi_decryption_test_case_1_oop),
6390 /** KASUMI hash only (UIA1) */
6391 TEST_CASE_ST(ut_setup, ut_teardown,
6392 test_kasumi_hash_generate_test_case_1),
6393 TEST_CASE_ST(ut_setup, ut_teardown,
6394 test_kasumi_hash_generate_test_case_2),
6395 TEST_CASE_ST(ut_setup, ut_teardown,
6396 test_kasumi_hash_generate_test_case_3),
6397 TEST_CASE_ST(ut_setup, ut_teardown,
6398 test_kasumi_hash_generate_test_case_4),
6399 TEST_CASE_ST(ut_setup, ut_teardown,
6400 test_kasumi_hash_generate_test_case_5),
6401 TEST_CASE_ST(ut_setup, ut_teardown,
6402 test_kasumi_hash_generate_test_case_6),
6403 TEST_CASE_ST(ut_setup, ut_teardown,
6404 test_kasumi_hash_verify_test_case_1),
6405 TEST_CASE_ST(ut_setup, ut_teardown,
6406 test_kasumi_hash_verify_test_case_2),
6407 TEST_CASE_ST(ut_setup, ut_teardown,
6408 test_kasumi_hash_verify_test_case_3),
6409 TEST_CASE_ST(ut_setup, ut_teardown,
6410 test_kasumi_hash_verify_test_case_4),
6411 TEST_CASE_ST(ut_setup, ut_teardown,
6412 test_kasumi_hash_verify_test_case_5),
6413 TEST_CASE_ST(ut_setup, ut_teardown,
6414 test_kasumi_auth_cipher_test_case_1),
6415 TEST_CASE_ST(ut_setup, ut_teardown,
6416 test_kasumi_cipher_auth_test_case_1),
6417 TEST_CASES_END() /**< NULL terminate unit test array */
6420 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
6421 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
6422 .setup = testsuite_setup,
6423 .teardown = testsuite_teardown,
6424 .unit_test_cases = {
6425 /** SNOW 3G encrypt only (UEA2) */
6426 TEST_CASE_ST(ut_setup, ut_teardown,
6427 test_snow3g_encryption_test_case_1),
6428 TEST_CASE_ST(ut_setup, ut_teardown,
6429 test_snow3g_encryption_test_case_2),
6430 TEST_CASE_ST(ut_setup, ut_teardown,
6431 test_snow3g_encryption_test_case_3),
6432 TEST_CASE_ST(ut_setup, ut_teardown,
6433 test_snow3g_encryption_test_case_4),
6434 TEST_CASE_ST(ut_setup, ut_teardown,
6435 test_snow3g_encryption_test_case_5),
6437 TEST_CASE_ST(ut_setup, ut_teardown,
6438 test_snow3g_encryption_test_case_1_oop),
6439 TEST_CASE_ST(ut_setup, ut_teardown,
6440 test_snow3g_decryption_test_case_1_oop),
6442 TEST_CASE_ST(ut_setup, ut_teardown,
6443 test_snow3g_encryption_test_case_1_offset_oop),
6445 /** SNOW 3G decrypt only (UEA2) */
6446 TEST_CASE_ST(ut_setup, ut_teardown,
6447 test_snow3g_decryption_test_case_1),
6448 TEST_CASE_ST(ut_setup, ut_teardown,
6449 test_snow3g_decryption_test_case_2),
6450 TEST_CASE_ST(ut_setup, ut_teardown,
6451 test_snow3g_decryption_test_case_3),
6452 TEST_CASE_ST(ut_setup, ut_teardown,
6453 test_snow3g_decryption_test_case_4),
6454 TEST_CASE_ST(ut_setup, ut_teardown,
6455 test_snow3g_decryption_test_case_5),
6456 TEST_CASE_ST(ut_setup, ut_teardown,
6457 test_snow3g_hash_generate_test_case_1),
6458 TEST_CASE_ST(ut_setup, ut_teardown,
6459 test_snow3g_hash_generate_test_case_2),
6460 TEST_CASE_ST(ut_setup, ut_teardown,
6461 test_snow3g_hash_generate_test_case_3),
6462 /* Tests with buffers which length is not byte-aligned */
6463 TEST_CASE_ST(ut_setup, ut_teardown,
6464 test_snow3g_hash_generate_test_case_4),
6465 TEST_CASE_ST(ut_setup, ut_teardown,
6466 test_snow3g_hash_generate_test_case_5),
6467 TEST_CASE_ST(ut_setup, ut_teardown,
6468 test_snow3g_hash_generate_test_case_6),
6469 TEST_CASE_ST(ut_setup, ut_teardown,
6470 test_snow3g_hash_verify_test_case_1),
6471 TEST_CASE_ST(ut_setup, ut_teardown,
6472 test_snow3g_hash_verify_test_case_2),
6473 TEST_CASE_ST(ut_setup, ut_teardown,
6474 test_snow3g_hash_verify_test_case_3),
6475 /* Tests with buffers which length is not byte-aligned */
6476 TEST_CASE_ST(ut_setup, ut_teardown,
6477 test_snow3g_hash_verify_test_case_4),
6478 TEST_CASE_ST(ut_setup, ut_teardown,
6479 test_snow3g_hash_verify_test_case_5),
6480 TEST_CASE_ST(ut_setup, ut_teardown,
6481 test_snow3g_hash_verify_test_case_6),
6482 TEST_CASE_ST(ut_setup, ut_teardown,
6483 test_snow3g_cipher_auth_test_case_1),
6484 TEST_CASE_ST(ut_setup, ut_teardown,
6485 test_snow3g_auth_cipher_test_case_1),
6487 TEST_CASES_END() /**< NULL terminate unit test array */
6491 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
6492 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
6493 .setup = testsuite_setup,
6494 .teardown = testsuite_teardown,
6495 .unit_test_cases = {
6496 /** ZUC encrypt only (EEA3) */
6497 TEST_CASE_ST(ut_setup, ut_teardown,
6498 test_zuc_encryption_test_case_1),
6499 TEST_CASE_ST(ut_setup, ut_teardown,
6500 test_zuc_encryption_test_case_2),
6501 TEST_CASE_ST(ut_setup, ut_teardown,
6502 test_zuc_encryption_test_case_3),
6503 TEST_CASE_ST(ut_setup, ut_teardown,
6504 test_zuc_encryption_test_case_4),
6505 TEST_CASE_ST(ut_setup, ut_teardown,
6506 test_zuc_encryption_test_case_5),
6507 TEST_CASE_ST(ut_setup, ut_teardown,
6508 test_zuc_hash_generate_test_case_1),
6509 TEST_CASE_ST(ut_setup, ut_teardown,
6510 test_zuc_hash_generate_test_case_2),
6511 TEST_CASE_ST(ut_setup, ut_teardown,
6512 test_zuc_hash_generate_test_case_3),
6513 TEST_CASE_ST(ut_setup, ut_teardown,
6514 test_zuc_hash_generate_test_case_4),
6515 TEST_CASE_ST(ut_setup, ut_teardown,
6516 test_zuc_hash_generate_test_case_5),
6517 TEST_CASES_END() /**< NULL terminate unit test array */
6521 static struct unit_test_suite cryptodev_null_testsuite = {
6522 .suite_name = "Crypto Device NULL Unit Test Suite",
6523 .setup = testsuite_setup,
6524 .teardown = testsuite_teardown,
6525 .unit_test_cases = {
6526 TEST_CASE_ST(ut_setup, ut_teardown,
6527 test_null_auth_only_operation),
6528 TEST_CASE_ST(ut_setup, ut_teardown,
6529 test_null_cipher_only_operation),
6530 TEST_CASE_ST(ut_setup, ut_teardown,
6531 test_null_cipher_auth_operation),
6532 TEST_CASE_ST(ut_setup, ut_teardown,
6533 test_null_auth_cipher_operation),
6534 TEST_CASE_ST(ut_setup, ut_teardown,
6535 test_null_invalid_operation),
6536 TEST_CASE_ST(ut_setup, ut_teardown,
6537 test_null_burst_operation),
6539 TEST_CASES_END() /**< NULL terminate unit test array */
6544 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
6546 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
6547 return unit_test_suite_runner(&cryptodev_qat_testsuite);
6551 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
6553 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
6555 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
6559 test_cryptodev_openssl(void)
6561 gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
6563 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
6567 test_cryptodev_aesni_gcm(void)
6569 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
6571 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
6575 test_cryptodev_null(void)
6577 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
6579 return unit_test_suite_runner(&cryptodev_null_testsuite);
6583 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
6585 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
6587 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
6591 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
6593 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
6595 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
6599 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
6601 gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
6603 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
6606 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
6607 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
6608 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
6609 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
6610 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
6611 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
6612 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
6613 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);