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_authonly_openssl_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_OPENSSL_PMD,
1541 BLKCIPHER_AUTHONLY_TYPE);
1543 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1545 return TEST_SUCCESS;
1549 test_authonly_qat_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_QAT_SYM_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, plaintext_len, 8);
2965 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
2966 "failed to reserve memory for ciphertext shifted\n");
2968 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
2969 ceil_byte_length(tdata->ciphertext.len));
2970 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
2973 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
2975 expected_ciphertext_shifted,
2976 tdata->validDataLenInBits.len,
2978 "SNOW 3G Ciphertext data not as expected");
2982 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2984 struct crypto_testsuite_params *ts_params = &testsuite_params;
2985 struct crypto_unittest_params *ut_params = &unittest_params;
2989 uint8_t *plaintext, *ciphertext;
2990 unsigned ciphertext_pad_len;
2991 unsigned ciphertext_len;
2993 /* Create SNOW 3G session */
2994 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2995 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2996 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2997 tdata->key.data, tdata->key.len);
3001 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3003 /* Clear mbuf payload */
3004 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3005 rte_pktmbuf_tailroom(ut_params->ibuf));
3007 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3008 /* Append data which is padded to a multiple of */
3009 /* the algorithms block size */
3010 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3011 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3012 ciphertext_pad_len);
3013 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3015 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3017 /* Create SNOW 3G operation */
3018 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3019 tdata->validCipherLenInBits.len,
3020 tdata->validCipherOffsetLenInBits.len,
3021 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3025 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3027 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3028 ut_params->obuf = ut_params->op->sym->m_dst;
3029 if (ut_params->obuf)
3030 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3033 plaintext = ciphertext;
3035 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3038 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3039 tdata->plaintext.data,
3040 tdata->validDataLenInBits.len,
3041 "SNOW 3G Plaintext data not as expected");
3045 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3047 struct crypto_testsuite_params *ts_params = &testsuite_params;
3048 struct crypto_unittest_params *ut_params = &unittest_params;
3052 uint8_t *plaintext, *ciphertext;
3053 unsigned ciphertext_pad_len;
3054 unsigned ciphertext_len;
3056 /* Create SNOW 3G session */
3057 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3058 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3059 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3060 tdata->key.data, tdata->key.len);
3064 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3065 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3067 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3068 "Failed to allocate input buffer");
3069 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3070 "Failed to allocate output buffer");
3072 /* Clear mbuf payload */
3073 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3074 rte_pktmbuf_tailroom(ut_params->ibuf));
3076 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3077 rte_pktmbuf_tailroom(ut_params->obuf));
3079 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3080 /* Append data which is padded to a multiple of */
3081 /* the algorithms block size */
3082 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3083 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3084 ciphertext_pad_len);
3085 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3086 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3088 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3090 /* Create SNOW 3G operation */
3091 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3093 tdata->validCipherLenInBits.len,
3094 tdata->validCipherOffsetLenInBits.len,
3095 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3099 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3101 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3102 ut_params->obuf = ut_params->op->sym->m_dst;
3103 if (ut_params->obuf)
3104 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3107 plaintext = ciphertext;
3109 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3112 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3113 tdata->plaintext.data,
3114 tdata->validDataLenInBits.len,
3115 "SNOW 3G Plaintext data not as expected");
3120 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3122 struct crypto_testsuite_params *ts_params = &testsuite_params;
3123 struct crypto_unittest_params *ut_params = &unittest_params;
3127 uint8_t *plaintext, *ciphertext;
3128 unsigned plaintext_pad_len;
3129 unsigned plaintext_len;
3131 /* Create SNOW 3G session */
3132 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3133 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3134 RTE_CRYPTO_AUTH_OP_GENERATE,
3135 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3136 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3137 tdata->key.data, tdata->key.len,
3138 tdata->aad.len, tdata->digest.len);
3141 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3143 /* clear mbuf payload */
3144 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3145 rte_pktmbuf_tailroom(ut_params->ibuf));
3147 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3148 /* Append data which is padded to a multiple of */
3149 /* the algorithms block size */
3150 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3151 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3153 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3155 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3157 /* Create SNOW 3G operation */
3158 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3159 tdata->digest.len, tdata->aad.data,
3160 tdata->aad.len, /*tdata->plaintext.len,*/
3161 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3162 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3163 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3164 tdata->iv.data, tdata->iv.len,
3165 tdata->validCipherLenInBits.len,
3166 tdata->validCipherOffsetLenInBits.len,
3167 tdata->validAuthLenInBits.len,
3168 tdata->validAuthOffsetLenInBits.len
3173 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3175 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3176 ut_params->obuf = ut_params->op->sym->m_src;
3177 if (ut_params->obuf)
3178 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3179 + tdata->iv.len + tdata->aad.len;
3181 ciphertext = plaintext;
3183 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3185 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3187 tdata->ciphertext.data,
3188 tdata->validDataLenInBits.len,
3189 "SNOW 3G Ciphertext data not as expected");
3191 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3192 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3195 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3198 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3199 "SNOW 3G Generated auth tag not as expected");
3203 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3205 struct crypto_testsuite_params *ts_params = &testsuite_params;
3206 struct crypto_unittest_params *ut_params = &unittest_params;
3210 uint8_t *plaintext, *ciphertext;
3211 unsigned plaintext_pad_len;
3212 unsigned plaintext_len;
3214 /* Create SNOW 3G session */
3215 retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3216 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3217 RTE_CRYPTO_AUTH_OP_GENERATE,
3218 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3219 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3220 tdata->key.data, tdata->key.len,
3221 tdata->aad.len, tdata->digest.len);
3225 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3227 /* clear mbuf payload */
3228 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3229 rte_pktmbuf_tailroom(ut_params->ibuf));
3231 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3232 /* Append data which is padded to a multiple of */
3233 /* the algorithms block size */
3234 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3235 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3237 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3239 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3241 /* Create SNOW 3G operation */
3242 retval = create_wireless_algo_auth_cipher_operation(
3244 tdata->iv.data, tdata->iv.len,
3245 tdata->aad.data, tdata->aad.len,
3247 tdata->validCipherLenInBits.len,
3248 tdata->validCipherOffsetLenInBits.len,
3249 tdata->validAuthLenInBits.len,
3250 tdata->validAuthOffsetLenInBits.len,
3251 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3252 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3258 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3260 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3261 ut_params->obuf = ut_params->op->sym->m_src;
3262 if (ut_params->obuf)
3263 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3264 + tdata->aad.len + tdata->iv.len;
3266 ciphertext = plaintext;
3268 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3269 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3270 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3273 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3275 tdata->ciphertext.data,
3276 tdata->validDataLenInBits.len,
3277 "SNOW 3G Ciphertext data not as expected");
3280 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3283 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3284 "SNOW 3G Generated auth tag not as expected");
3289 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3291 struct crypto_testsuite_params *ts_params = &testsuite_params;
3292 struct crypto_unittest_params *ut_params = &unittest_params;
3296 uint8_t *plaintext, *ciphertext;
3297 unsigned plaintext_pad_len;
3298 unsigned plaintext_len;
3300 /* Create KASUMI session */
3301 retval = create_wireless_algo_auth_cipher_session(
3302 ts_params->valid_devs[0],
3303 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3304 RTE_CRYPTO_AUTH_OP_GENERATE,
3305 RTE_CRYPTO_AUTH_KASUMI_F9,
3306 RTE_CRYPTO_CIPHER_KASUMI_F8,
3307 tdata->key.data, tdata->key.len,
3308 tdata->aad.len, tdata->digest.len);
3311 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3313 /* clear mbuf payload */
3314 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3315 rte_pktmbuf_tailroom(ut_params->ibuf));
3317 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3318 /* Append data which is padded to a multiple of */
3319 /* the algorithms block size */
3320 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3321 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3323 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3325 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3327 /* Create KASUMI operation */
3328 retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
3329 tdata->iv.data, tdata->iv.len,
3330 tdata->aad.data, tdata->aad.len,
3332 tdata->validCipherLenInBits.len,
3333 tdata->validCipherOffsetLenInBits.len,
3334 tdata->validAuthLenInBits.len,
3335 tdata->validAuthOffsetLenInBits.len,
3336 RTE_CRYPTO_AUTH_KASUMI_F9,
3337 RTE_CRYPTO_CIPHER_KASUMI_F8
3343 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3345 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3346 ut_params->obuf = ut_params->op->sym->m_src;
3347 if (ut_params->obuf)
3348 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3349 + tdata->iv.len + tdata->aad.len;
3351 ciphertext = plaintext;
3354 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3356 tdata->ciphertext.data,
3357 tdata->validCipherLenInBits.len,
3358 "KASUMI Ciphertext data not as expected");
3359 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3360 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3363 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3366 DIGEST_BYTE_LENGTH_KASUMI_F9,
3367 "KASUMI Generated auth tag not as expected");
3372 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
3374 struct crypto_testsuite_params *ts_params = &testsuite_params;
3375 struct crypto_unittest_params *ut_params = &unittest_params;
3379 uint8_t *plaintext, *ciphertext;
3380 unsigned plaintext_pad_len;
3381 unsigned plaintext_len;
3383 /* Create KASUMI session */
3384 retval = create_wireless_algo_cipher_auth_session(
3385 ts_params->valid_devs[0],
3386 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3387 RTE_CRYPTO_AUTH_OP_GENERATE,
3388 RTE_CRYPTO_AUTH_KASUMI_F9,
3389 RTE_CRYPTO_CIPHER_KASUMI_F8,
3390 tdata->key.data, tdata->key.len,
3391 tdata->aad.len, tdata->digest.len);
3395 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3397 /* clear mbuf payload */
3398 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3399 rte_pktmbuf_tailroom(ut_params->ibuf));
3401 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3402 /* Append data which is padded to a multiple of */
3403 /* the algorithms block size */
3404 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3405 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3407 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3409 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3411 /* Create KASUMI operation */
3412 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3413 tdata->digest.len, tdata->aad.data,
3415 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3416 RTE_CRYPTO_AUTH_KASUMI_F9,
3417 RTE_CRYPTO_CIPHER_KASUMI_F8,
3418 tdata->iv.data, tdata->iv.len,
3419 tdata->validCipherLenInBits.len,
3420 tdata->validCipherOffsetLenInBits.len,
3421 tdata->validAuthLenInBits.len,
3422 tdata->validAuthOffsetLenInBits.len
3427 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3429 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3430 ut_params->obuf = ut_params->op->sym->m_src;
3431 if (ut_params->obuf)
3432 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3433 + tdata->aad.len + tdata->iv.len;
3435 ciphertext = plaintext;
3437 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3438 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3441 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3443 tdata->ciphertext.data,
3444 tdata->validCipherLenInBits.len,
3445 "KASUMI Ciphertext data not as expected");
3448 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3451 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3452 "KASUMI Generated auth tag not as expected");
3457 test_zuc_encryption(const struct zuc_test_data *tdata)
3459 struct crypto_testsuite_params *ts_params = &testsuite_params;
3460 struct crypto_unittest_params *ut_params = &unittest_params;
3463 uint8_t *plaintext, *ciphertext;
3464 unsigned plaintext_pad_len;
3465 unsigned plaintext_len;
3467 /* Create ZUC session */
3468 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3469 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3470 RTE_CRYPTO_CIPHER_ZUC_EEA3,
3471 tdata->key.data, tdata->key.len);
3475 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3477 /* Clear mbuf payload */
3478 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3479 rte_pktmbuf_tailroom(ut_params->ibuf));
3481 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3482 /* Append data which is padded to a multiple */
3483 /* of the algorithms block size */
3484 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3485 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3487 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3489 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3491 /* Create ZUC operation */
3492 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3493 tdata->plaintext.len,
3494 tdata->validCipherOffsetLenInBits.len,
3495 RTE_CRYPTO_CIPHER_ZUC_EEA3);
3499 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3501 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3503 ut_params->obuf = ut_params->op->sym->m_dst;
3504 if (ut_params->obuf)
3505 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3508 ciphertext = plaintext;
3510 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3513 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3515 tdata->ciphertext.data,
3516 tdata->validCipherLenInBits.len,
3517 "ZUC Ciphertext data not as expected");
3522 test_zuc_authentication(const struct zuc_hash_test_data *tdata)
3524 struct crypto_testsuite_params *ts_params = &testsuite_params;
3525 struct crypto_unittest_params *ut_params = &unittest_params;
3528 unsigned plaintext_pad_len;
3529 unsigned plaintext_len;
3532 /* Create ZUC session */
3533 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3534 tdata->key.data, tdata->key.len,
3535 tdata->aad.len, tdata->digest.len,
3536 RTE_CRYPTO_AUTH_OP_GENERATE,
3537 RTE_CRYPTO_AUTH_ZUC_EIA3);
3541 /* alloc mbuf and set payload */
3542 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3544 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3545 rte_pktmbuf_tailroom(ut_params->ibuf));
3547 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3548 /* Append data which is padded to a multiple of */
3549 /* the algorithms block size */
3550 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3551 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3553 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3555 /* Create ZUC operation */
3556 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3557 tdata->aad.data, tdata->aad.len,
3558 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3559 RTE_CRYPTO_AUTH_ZUC_EIA3,
3560 tdata->validAuthLenInBits.len,
3561 tdata->validAuthOffsetLenInBits.len);
3565 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3567 ut_params->obuf = ut_params->op->sym->m_src;
3568 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3569 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3570 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
3573 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3576 DIGEST_BYTE_LENGTH_KASUMI_F9,
3577 "ZUC Generated auth tag not as expected");
3583 test_kasumi_encryption_test_case_1(void)
3585 return test_kasumi_encryption(&kasumi_test_case_1);
3589 test_kasumi_encryption_test_case_1_oop(void)
3591 return test_kasumi_encryption_oop(&kasumi_test_case_1);
3595 test_kasumi_encryption_test_case_2(void)
3597 return test_kasumi_encryption(&kasumi_test_case_2);
3601 test_kasumi_encryption_test_case_3(void)
3603 return test_kasumi_encryption(&kasumi_test_case_3);
3607 test_kasumi_encryption_test_case_4(void)
3609 return test_kasumi_encryption(&kasumi_test_case_4);
3613 test_kasumi_encryption_test_case_5(void)
3615 return test_kasumi_encryption(&kasumi_test_case_5);
3619 test_kasumi_decryption_test_case_1(void)
3621 return test_kasumi_decryption(&kasumi_test_case_1);
3625 test_kasumi_decryption_test_case_1_oop(void)
3627 return test_kasumi_decryption_oop(&kasumi_test_case_1);
3631 test_kasumi_decryption_test_case_2(void)
3633 return test_kasumi_decryption(&kasumi_test_case_2);
3637 test_kasumi_decryption_test_case_3(void)
3639 return test_kasumi_decryption(&kasumi_test_case_3);
3643 test_kasumi_decryption_test_case_4(void)
3645 return test_kasumi_decryption(&kasumi_test_case_4);
3649 test_kasumi_decryption_test_case_5(void)
3651 return test_kasumi_decryption(&kasumi_test_case_5);
3654 test_snow3g_encryption_test_case_1(void)
3656 return test_snow3g_encryption(&snow3g_test_case_1);
3660 test_snow3g_encryption_test_case_1_oop(void)
3662 return test_snow3g_encryption_oop(&snow3g_test_case_1);
3666 test_snow3g_encryption_test_case_1_offset_oop(void)
3668 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
3672 test_snow3g_encryption_test_case_2(void)
3674 return test_snow3g_encryption(&snow3g_test_case_2);
3678 test_snow3g_encryption_test_case_3(void)
3680 return test_snow3g_encryption(&snow3g_test_case_3);
3684 test_snow3g_encryption_test_case_4(void)
3686 return test_snow3g_encryption(&snow3g_test_case_4);
3690 test_snow3g_encryption_test_case_5(void)
3692 return test_snow3g_encryption(&snow3g_test_case_5);
3696 test_snow3g_decryption_test_case_1(void)
3698 return test_snow3g_decryption(&snow3g_test_case_1);
3702 test_snow3g_decryption_test_case_1_oop(void)
3704 return test_snow3g_decryption_oop(&snow3g_test_case_1);
3708 test_snow3g_decryption_test_case_2(void)
3710 return test_snow3g_decryption(&snow3g_test_case_2);
3714 test_snow3g_decryption_test_case_3(void)
3716 return test_snow3g_decryption(&snow3g_test_case_3);
3720 test_snow3g_decryption_test_case_4(void)
3722 return test_snow3g_decryption(&snow3g_test_case_4);
3726 test_snow3g_decryption_test_case_5(void)
3728 return test_snow3g_decryption(&snow3g_test_case_5);
3731 test_snow3g_cipher_auth_test_case_1(void)
3733 return test_snow3g_cipher_auth(&snow3g_test_case_3);
3737 test_snow3g_auth_cipher_test_case_1(void)
3739 return test_snow3g_auth_cipher(&snow3g_test_case_6);
3743 test_kasumi_auth_cipher_test_case_1(void)
3745 return test_kasumi_auth_cipher(&kasumi_test_case_3);
3749 test_kasumi_cipher_auth_test_case_1(void)
3751 return test_kasumi_cipher_auth(&kasumi_test_case_6);
3755 test_zuc_encryption_test_case_1(void)
3757 return test_zuc_encryption(&zuc_test_case_1);
3761 test_zuc_encryption_test_case_2(void)
3763 return test_zuc_encryption(&zuc_test_case_2);
3767 test_zuc_encryption_test_case_3(void)
3769 return test_zuc_encryption(&zuc_test_case_3);
3773 test_zuc_encryption_test_case_4(void)
3775 return test_zuc_encryption(&zuc_test_case_4);
3779 test_zuc_encryption_test_case_5(void)
3781 return test_zuc_encryption(&zuc_test_case_5);
3785 test_zuc_hash_generate_test_case_1(void)
3787 return test_zuc_authentication(&zuc_hash_test_case_1);
3791 test_zuc_hash_generate_test_case_2(void)
3793 return test_zuc_authentication(&zuc_hash_test_case_2);
3797 test_zuc_hash_generate_test_case_3(void)
3799 return test_zuc_authentication(&zuc_hash_test_case_3);
3803 test_zuc_hash_generate_test_case_4(void)
3805 return test_zuc_authentication(&zuc_hash_test_case_4);
3809 test_zuc_hash_generate_test_case_5(void)
3811 return test_zuc_authentication(&zuc_hash_test_case_5);
3815 test_3DES_chain_qat_all(void)
3817 struct crypto_testsuite_params *ts_params = &testsuite_params;
3820 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3821 ts_params->op_mpool, ts_params->valid_devs[0],
3822 RTE_CRYPTODEV_QAT_SYM_PMD,
3823 BLKCIPHER_3DES_CHAIN_TYPE);
3825 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3827 return TEST_SUCCESS;
3831 test_3DES_cipheronly_qat_all(void)
3833 struct crypto_testsuite_params *ts_params = &testsuite_params;
3836 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3837 ts_params->op_mpool, ts_params->valid_devs[0],
3838 RTE_CRYPTODEV_QAT_SYM_PMD,
3839 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3841 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3843 return TEST_SUCCESS;
3847 test_3DES_chain_openssl_all(void)
3849 struct crypto_testsuite_params *ts_params = &testsuite_params;
3852 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3853 ts_params->op_mpool, ts_params->valid_devs[0],
3854 RTE_CRYPTODEV_OPENSSL_PMD,
3855 BLKCIPHER_3DES_CHAIN_TYPE);
3857 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3859 return TEST_SUCCESS;
3863 test_3DES_cipheronly_openssl_all(void)
3865 struct crypto_testsuite_params *ts_params = &testsuite_params;
3868 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3869 ts_params->op_mpool, ts_params->valid_devs[0],
3870 RTE_CRYPTODEV_OPENSSL_PMD,
3871 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3873 TEST_ASSERT_EQUAL(status, 0, "Test failed");
3875 return TEST_SUCCESS;
3878 /* ***** AES-GCM Tests ***** */
3881 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
3882 const uint8_t *key, const uint8_t key_len,
3883 const uint8_t aad_len, const uint8_t auth_len,
3884 enum rte_crypto_auth_operation auth_op)
3886 uint8_t cipher_key[key_len];
3888 struct crypto_unittest_params *ut_params = &unittest_params;
3890 memcpy(cipher_key, key, key_len);
3892 /* Setup Cipher Parameters */
3893 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3894 ut_params->cipher_xform.next = NULL;
3896 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3897 ut_params->auth_xform.auth.op = auth_op;
3898 ut_params->cipher_xform.cipher.op = op;
3899 ut_params->cipher_xform.cipher.key.data = cipher_key;
3900 ut_params->cipher_xform.cipher.key.length = key_len;
3902 TEST_HEXDUMP(stdout, "key:", key, key_len);
3904 /* Setup Authentication Parameters */
3905 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3906 ut_params->auth_xform.next = NULL;
3908 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3910 ut_params->auth_xform.auth.digest_length = auth_len;
3911 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3912 ut_params->auth_xform.auth.key.length = 0;
3913 ut_params->auth_xform.auth.key.data = NULL;
3915 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3916 ut_params->cipher_xform.next = &ut_params->auth_xform;
3918 /* Create Crypto session*/
3919 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3920 &ut_params->cipher_xform);
3921 } else {/* Create Crypto session*/
3922 ut_params->auth_xform.next = &ut_params->cipher_xform;
3923 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3924 &ut_params->auth_xform);
3927 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3933 create_gcm_operation(enum rte_crypto_cipher_operation op,
3934 const uint8_t *auth_tag, const unsigned auth_tag_len,
3935 const uint8_t *iv, const unsigned iv_len,
3936 const uint8_t *aad, const unsigned aad_len,
3937 const unsigned data_len, unsigned data_pad_len)
3939 struct crypto_testsuite_params *ts_params = &testsuite_params;
3940 struct crypto_unittest_params *ut_params = &unittest_params;
3942 unsigned iv_pad_len = 0, aad_buffer_len;
3944 /* Generate Crypto op data structure */
3945 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3946 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3947 TEST_ASSERT_NOT_NULL(ut_params->op,
3948 "Failed to allocate symmetric crypto operation struct");
3950 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3952 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3953 ut_params->ibuf, auth_tag_len);
3954 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3955 "no room to append digest");
3956 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3957 ut_params->ibuf, data_pad_len);
3958 sym_op->auth.digest.length = auth_tag_len;
3960 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3961 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3962 TEST_HEXDUMP(stdout, "digest:",
3963 sym_op->auth.digest.data,
3964 sym_op->auth.digest.length);
3968 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3970 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3971 ut_params->ibuf, iv_pad_len);
3972 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3974 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3975 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3976 sym_op->cipher.iv.length = iv_len;
3978 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3981 * Always allocate the aad up to the block size.
3982 * The cryptodev API calls out -
3983 * - the array must be big enough to hold the AAD, plus any
3984 * space to round this up to the nearest multiple of the
3985 * block size (16 bytes).
3987 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
3989 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
3990 ut_params->ibuf, aad_buffer_len);
3991 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
3992 "no room to prepend aad");
3993 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
3995 sym_op->auth.aad.length = aad_len;
3997 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
3998 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
4000 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
4001 TEST_HEXDUMP(stdout, "aad:",
4002 sym_op->auth.aad.data, aad_len);
4004 sym_op->cipher.data.length = data_len;
4005 sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
4007 sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
4008 sym_op->auth.data.length = data_len;
4014 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
4016 struct crypto_testsuite_params *ts_params = &testsuite_params;
4017 struct crypto_unittest_params *ut_params = &unittest_params;
4021 uint8_t *plaintext, *ciphertext, *auth_tag;
4022 uint16_t plaintext_pad_len;
4024 /* Create GCM session */
4025 retval = create_gcm_session(ts_params->valid_devs[0],
4026 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4027 tdata->key.data, tdata->key.len,
4028 tdata->aad.len, tdata->auth_tag.len,
4029 RTE_CRYPTO_AUTH_OP_GENERATE);
4034 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4036 /* clear mbuf payload */
4037 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4038 rte_pktmbuf_tailroom(ut_params->ibuf));
4041 * Append data which is padded to a multiple
4042 * of the algorithms block size
4044 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4046 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4048 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4050 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4052 /* Create GCM opertaion */
4053 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4054 tdata->auth_tag.data, tdata->auth_tag.len,
4055 tdata->iv.data, tdata->iv.len,
4056 tdata->aad.data, tdata->aad.len,
4057 tdata->plaintext.len, plaintext_pad_len);
4061 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4063 ut_params->op->sym->m_src = ut_params->ibuf;
4065 /* Process crypto operation */
4066 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4067 ut_params->op), "failed to process sym crypto op");
4069 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4070 "crypto op processing failed");
4072 if (ut_params->op->sym->m_dst) {
4073 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4075 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4076 uint8_t *, plaintext_pad_len);
4078 ciphertext = plaintext;
4079 auth_tag = plaintext + plaintext_pad_len;
4082 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4083 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
4086 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4088 tdata->ciphertext.data,
4089 tdata->ciphertext.len,
4090 "GCM Ciphertext data not as expected");
4092 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4094 tdata->auth_tag.data,
4095 tdata->auth_tag.len,
4096 "GCM Generated auth tag not as expected");
4103 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
4105 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
4109 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
4111 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
4115 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
4117 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
4121 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
4123 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
4127 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
4129 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
4133 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
4135 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
4139 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
4141 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
4145 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
4147 struct crypto_testsuite_params *ts_params = &testsuite_params;
4148 struct crypto_unittest_params *ut_params = &unittest_params;
4152 uint8_t *plaintext, *ciphertext;
4153 uint16_t ciphertext_pad_len;
4155 /* Create GCM session */
4156 retval = create_gcm_session(ts_params->valid_devs[0],
4157 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4158 tdata->key.data, tdata->key.len,
4159 tdata->aad.len, tdata->auth_tag.len,
4160 RTE_CRYPTO_AUTH_OP_VERIFY);
4165 /* alloc mbuf and set payload */
4166 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4168 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4169 rte_pktmbuf_tailroom(ut_params->ibuf));
4171 ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4173 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4174 ciphertext_pad_len);
4175 memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
4177 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4179 /* Create GCM opertaion */
4180 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
4181 tdata->auth_tag.data, tdata->auth_tag.len,
4182 tdata->iv.data, tdata->iv.len,
4183 tdata->aad.data, tdata->aad.len,
4184 tdata->ciphertext.len, ciphertext_pad_len);
4189 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4191 ut_params->op->sym->m_src = ut_params->ibuf;
4193 /* Process crypto operation */
4194 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4195 ut_params->op), "failed to process sym crypto op");
4197 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4198 "crypto op processing failed");
4200 if (ut_params->op->sym->m_dst)
4201 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4204 plaintext = ciphertext;
4206 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
4209 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4211 tdata->plaintext.data,
4212 tdata->plaintext.len,
4213 "GCM plaintext data not as expected");
4215 TEST_ASSERT_EQUAL(ut_params->op->status,
4216 RTE_CRYPTO_OP_STATUS_SUCCESS,
4217 "GCM authentication failed");
4222 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
4224 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
4228 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
4230 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
4234 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
4236 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
4240 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
4242 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
4246 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
4248 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
4252 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
4254 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
4258 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
4260 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
4266 struct crypto_testsuite_params *ts_params = &testsuite_params;
4267 struct rte_cryptodev_stats stats;
4268 struct rte_cryptodev *dev;
4269 cryptodev_stats_get_t temp_pfn;
4271 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4272 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
4273 &stats) == -ENODEV),
4274 "rte_cryptodev_stats_get invalid dev failed");
4275 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
4276 "rte_cryptodev_stats_get invalid Param failed");
4277 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
4278 temp_pfn = dev->dev_ops->stats_get;
4279 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
4280 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
4282 "rte_cryptodev_stats_get invalid Param failed");
4283 dev->dev_ops->stats_get = temp_pfn;
4285 /* Test expected values */
4287 test_AES_CBC_HMAC_SHA1_encrypt_digest();
4289 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4291 "rte_cryptodev_stats_get failed");
4292 TEST_ASSERT((stats.enqueued_count == 1),
4293 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4294 TEST_ASSERT((stats.dequeued_count == 1),
4295 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4296 TEST_ASSERT((stats.enqueue_err_count == 0),
4297 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4298 TEST_ASSERT((stats.dequeue_err_count == 0),
4299 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4301 /* invalid device but should ignore and not reset device stats*/
4302 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
4303 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4305 "rte_cryptodev_stats_get failed");
4306 TEST_ASSERT((stats.enqueued_count == 1),
4307 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4309 /* check that a valid reset clears stats */
4310 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4311 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4313 "rte_cryptodev_stats_get failed");
4314 TEST_ASSERT((stats.enqueued_count == 0),
4315 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4316 TEST_ASSERT((stats.dequeued_count == 0),
4317 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4319 return TEST_SUCCESS;
4322 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
4323 struct crypto_unittest_params *ut_params,
4324 enum rte_crypto_auth_operation op,
4325 const struct HMAC_MD5_vector *test_case)
4329 memcpy(key, test_case->key.data, test_case->key.len);
4331 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4332 ut_params->auth_xform.next = NULL;
4333 ut_params->auth_xform.auth.op = op;
4335 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
4337 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
4338 ut_params->auth_xform.auth.add_auth_data_length = 0;
4339 ut_params->auth_xform.auth.key.length = test_case->key.len;
4340 ut_params->auth_xform.auth.key.data = key;
4342 ut_params->sess = rte_cryptodev_sym_session_create(
4343 ts_params->valid_devs[0], &ut_params->auth_xform);
4345 if (ut_params->sess == NULL)
4348 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4350 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4351 rte_pktmbuf_tailroom(ut_params->ibuf));
4356 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
4357 const struct HMAC_MD5_vector *test_case,
4358 uint8_t **plaintext)
4360 uint16_t plaintext_pad_len;
4362 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4364 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4367 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4369 memcpy(*plaintext, test_case->plaintext.data,
4370 test_case->plaintext.len);
4372 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4373 ut_params->ibuf, MD5_DIGEST_LEN);
4374 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
4375 "no room to append digest");
4376 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4377 ut_params->ibuf, plaintext_pad_len);
4378 sym_op->auth.digest.length = MD5_DIGEST_LEN;
4380 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
4381 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
4382 test_case->auth_tag.len);
4385 sym_op->auth.data.offset = 0;
4386 sym_op->auth.data.length = test_case->plaintext.len;
4388 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4389 ut_params->op->sym->m_src = ut_params->ibuf;
4395 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
4397 uint16_t plaintext_pad_len;
4398 uint8_t *plaintext, *auth_tag;
4400 struct crypto_testsuite_params *ts_params = &testsuite_params;
4401 struct crypto_unittest_params *ut_params = &unittest_params;
4403 if (MD5_HMAC_create_session(ts_params, ut_params,
4404 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
4407 /* Generate Crypto op data structure */
4408 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4409 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4410 TEST_ASSERT_NOT_NULL(ut_params->op,
4411 "Failed to allocate symmetric crypto operation struct");
4413 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4416 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4419 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4420 ut_params->op), "failed to process sym crypto op");
4422 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4423 "crypto op processing failed");
4425 if (ut_params->op->sym->m_dst) {
4426 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4427 uint8_t *, plaintext_pad_len);
4429 auth_tag = plaintext + plaintext_pad_len;
4432 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4434 test_case->auth_tag.data,
4435 test_case->auth_tag.len,
4436 "HMAC_MD5 generated tag not as expected");
4438 return TEST_SUCCESS;
4442 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
4446 struct crypto_testsuite_params *ts_params = &testsuite_params;
4447 struct crypto_unittest_params *ut_params = &unittest_params;
4449 if (MD5_HMAC_create_session(ts_params, ut_params,
4450 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
4454 /* Generate Crypto op data structure */
4455 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4456 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4457 TEST_ASSERT_NOT_NULL(ut_params->op,
4458 "Failed to allocate symmetric crypto operation struct");
4460 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4463 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4464 ut_params->op), "failed to process sym crypto op");
4466 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4467 "HMAC_MD5 crypto op processing failed");
4469 return TEST_SUCCESS;
4473 test_MD5_HMAC_generate_case_1(void)
4475 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
4479 test_MD5_HMAC_verify_case_1(void)
4481 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
4485 test_MD5_HMAC_generate_case_2(void)
4487 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
4491 test_MD5_HMAC_verify_case_2(void)
4493 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
4497 test_multi_session(void)
4499 struct crypto_testsuite_params *ts_params = &testsuite_params;
4500 struct crypto_unittest_params *ut_params = &unittest_params;
4502 struct rte_cryptodev_info dev_info;
4503 struct rte_cryptodev_sym_session **sessions;
4507 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
4508 aes_cbc_key, hmac_sha512_key);
4511 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4513 sessions = rte_malloc(NULL,
4514 (sizeof(struct rte_cryptodev_sym_session *) *
4515 dev_info.sym.max_nb_sessions) + 1, 0);
4517 /* Create multiple crypto sessions*/
4518 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
4519 sessions[i] = rte_cryptodev_sym_session_create(
4520 ts_params->valid_devs[0],
4521 &ut_params->auth_xform);
4522 TEST_ASSERT_NOT_NULL(sessions[i],
4523 "Session creation failed at session number %u",
4526 /* Attempt to send a request on each session */
4527 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
4531 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
4532 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
4534 "Failed to perform decrypt on request number %u.", i);
4535 /* free crypto operation structure */
4537 rte_crypto_op_free(ut_params->op);
4540 * free mbuf - both obuf and ibuf are usually the same,
4541 * so check if they point at the same address is necessary,
4542 * to avoid freeing the mbuf twice.
4544 if (ut_params->obuf) {
4545 rte_pktmbuf_free(ut_params->obuf);
4546 if (ut_params->ibuf == ut_params->obuf)
4547 ut_params->ibuf = 0;
4548 ut_params->obuf = 0;
4550 if (ut_params->ibuf) {
4551 rte_pktmbuf_free(ut_params->ibuf);
4552 ut_params->ibuf = 0;
4556 /* Next session create should fail */
4557 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
4558 &ut_params->auth_xform);
4559 TEST_ASSERT_NULL(sessions[i],
4560 "Session creation succeeded unexpectedly!");
4562 for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
4563 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4568 return TEST_SUCCESS;
4571 struct multi_session_params {
4572 struct crypto_unittest_params ut_params;
4573 uint8_t *cipher_key;
4575 const uint8_t *cipher;
4576 const uint8_t *digest;
4580 #define MB_SESSION_NUMBER 3
4583 test_multi_session_random_usage(void)
4585 struct crypto_testsuite_params *ts_params = &testsuite_params;
4586 struct rte_cryptodev_info dev_info;
4587 struct rte_cryptodev_sym_session **sessions;
4589 struct multi_session_params ut_paramz[] = {
4592 .cipher_key = ms_aes_cbc_key0,
4593 .hmac_key = ms_hmac_key0,
4594 .cipher = ms_aes_cbc_cipher0,
4595 .digest = ms_hmac_digest0,
4596 .iv = ms_aes_cbc_iv0
4599 .cipher_key = ms_aes_cbc_key1,
4600 .hmac_key = ms_hmac_key1,
4601 .cipher = ms_aes_cbc_cipher1,
4602 .digest = ms_hmac_digest1,
4603 .iv = ms_aes_cbc_iv1
4606 .cipher_key = ms_aes_cbc_key2,
4607 .hmac_key = ms_hmac_key2,
4608 .cipher = ms_aes_cbc_cipher2,
4609 .digest = ms_hmac_digest2,
4610 .iv = ms_aes_cbc_iv2
4615 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4617 sessions = rte_malloc(NULL,
4618 (sizeof(struct rte_cryptodev_sym_session *)
4619 * dev_info.sym.max_nb_sessions) + 1, 0);
4621 for (i = 0; i < MB_SESSION_NUMBER; i++) {
4622 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
4623 sizeof(struct crypto_unittest_params));
4625 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
4626 &ut_paramz[i].ut_params,
4627 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
4629 /* Create multiple crypto sessions*/
4630 sessions[i] = rte_cryptodev_sym_session_create(
4631 ts_params->valid_devs[0],
4632 &ut_paramz[i].ut_params.auth_xform);
4634 TEST_ASSERT_NOT_NULL(sessions[i],
4635 "Session creation failed at session number %u",
4641 for (i = 0; i < 40000; i++) {
4643 j = rand() % MB_SESSION_NUMBER;
4645 TEST_ASSERT_SUCCESS(
4646 test_AES_CBC_HMAC_SHA512_decrypt_perform(
4648 &ut_paramz[j].ut_params,
4649 ts_params, ut_paramz[j].cipher,
4650 ut_paramz[j].digest,
4652 "Failed to perform decrypt on request number %u.", i);
4654 if (ut_paramz[j].ut_params.op)
4655 rte_crypto_op_free(ut_paramz[j].ut_params.op);
4658 * free mbuf - both obuf and ibuf are usually the same,
4659 * so check if they point at the same address is necessary,
4660 * to avoid freeing the mbuf twice.
4662 if (ut_paramz[j].ut_params.obuf) {
4663 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
4664 if (ut_paramz[j].ut_params.ibuf
4665 == ut_paramz[j].ut_params.obuf)
4666 ut_paramz[j].ut_params.ibuf = 0;
4667 ut_paramz[j].ut_params.obuf = 0;
4669 if (ut_paramz[j].ut_params.ibuf) {
4670 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
4671 ut_paramz[j].ut_params.ibuf = 0;
4675 for (i = 0; i < MB_SESSION_NUMBER; i++)
4676 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4681 return TEST_SUCCESS;
4685 test_null_cipher_only_operation(void)
4687 struct crypto_testsuite_params *ts_params = &testsuite_params;
4688 struct crypto_unittest_params *ut_params = &unittest_params;
4690 /* Generate test mbuf data and space for digest */
4691 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4692 catch_22_quote, QUOTE_512_BYTES, 0);
4694 /* Setup Cipher Parameters */
4695 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4696 ut_params->cipher_xform.next = NULL;
4698 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4699 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4701 /* Create Crypto session*/
4702 ut_params->sess = rte_cryptodev_sym_session_create(
4703 ts_params->valid_devs[0], &ut_params->cipher_xform);
4704 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4706 /* Generate Crypto op data structure */
4707 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4708 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4709 TEST_ASSERT_NOT_NULL(ut_params->op,
4710 "Failed to allocate symmetric crypto operation struct");
4712 /* Set crypto operation data parameters */
4713 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4715 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4717 /* set crypto operation source mbuf */
4718 sym_op->m_src = ut_params->ibuf;
4720 sym_op->cipher.data.offset = 0;
4721 sym_op->cipher.data.length = QUOTE_512_BYTES;
4723 /* Process crypto operation */
4724 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4726 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4728 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4729 "crypto operation processing failed");
4732 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4733 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4736 "Ciphertext data not as expected");
4738 return TEST_SUCCESS;
4742 test_null_auth_only_operation(void)
4744 struct crypto_testsuite_params *ts_params = &testsuite_params;
4745 struct crypto_unittest_params *ut_params = &unittest_params;
4747 /* Generate test mbuf data and space for digest */
4748 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4749 catch_22_quote, QUOTE_512_BYTES, 0);
4751 /* Setup HMAC Parameters */
4752 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4753 ut_params->auth_xform.next = NULL;
4755 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4756 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4758 /* Create Crypto session*/
4759 ut_params->sess = rte_cryptodev_sym_session_create(
4760 ts_params->valid_devs[0], &ut_params->auth_xform);
4761 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4763 /* Generate Crypto op data structure */
4764 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4765 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4766 TEST_ASSERT_NOT_NULL(ut_params->op,
4767 "Failed to allocate symmetric crypto operation struct");
4769 /* Set crypto operation data parameters */
4770 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4772 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4774 sym_op->m_src = ut_params->ibuf;
4776 sym_op->auth.data.offset = 0;
4777 sym_op->auth.data.length = QUOTE_512_BYTES;
4779 /* Process crypto operation */
4780 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4782 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4784 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4785 "crypto operation processing failed");
4787 return TEST_SUCCESS;
4791 test_null_cipher_auth_operation(void)
4793 struct crypto_testsuite_params *ts_params = &testsuite_params;
4794 struct crypto_unittest_params *ut_params = &unittest_params;
4796 /* Generate test mbuf data and space for digest */
4797 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4798 catch_22_quote, QUOTE_512_BYTES, 0);
4800 /* Setup Cipher Parameters */
4801 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4802 ut_params->cipher_xform.next = &ut_params->auth_xform;
4804 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4805 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4807 /* Setup HMAC Parameters */
4808 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4809 ut_params->auth_xform.next = NULL;
4811 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4812 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4814 /* Create Crypto session*/
4815 ut_params->sess = rte_cryptodev_sym_session_create(
4816 ts_params->valid_devs[0], &ut_params->cipher_xform);
4817 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4819 /* Generate Crypto op data structure */
4820 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4821 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4822 TEST_ASSERT_NOT_NULL(ut_params->op,
4823 "Failed to allocate symmetric crypto operation struct");
4825 /* Set crypto operation data parameters */
4826 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4828 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4830 sym_op->m_src = ut_params->ibuf;
4832 sym_op->cipher.data.offset = 0;
4833 sym_op->cipher.data.length = QUOTE_512_BYTES;
4835 sym_op->auth.data.offset = 0;
4836 sym_op->auth.data.length = QUOTE_512_BYTES;
4838 /* Process crypto operation */
4839 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4841 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4843 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4844 "crypto operation processing failed");
4847 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4848 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4851 "Ciphertext data not as expected");
4853 return TEST_SUCCESS;
4857 test_null_auth_cipher_operation(void)
4859 struct crypto_testsuite_params *ts_params = &testsuite_params;
4860 struct crypto_unittest_params *ut_params = &unittest_params;
4862 /* Generate test mbuf data and space for digest */
4863 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4864 catch_22_quote, QUOTE_512_BYTES, 0);
4866 /* Setup Cipher Parameters */
4867 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4868 ut_params->cipher_xform.next = NULL;
4870 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4871 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4873 /* Setup HMAC Parameters */
4874 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4875 ut_params->auth_xform.next = &ut_params->cipher_xform;
4877 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4878 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4880 /* Create Crypto session*/
4881 ut_params->sess = rte_cryptodev_sym_session_create(
4882 ts_params->valid_devs[0], &ut_params->cipher_xform);
4883 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4885 /* Generate Crypto op data structure */
4886 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4887 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4888 TEST_ASSERT_NOT_NULL(ut_params->op,
4889 "Failed to allocate symmetric crypto operation struct");
4891 /* Set crypto operation data parameters */
4892 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4894 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4896 sym_op->m_src = ut_params->ibuf;
4898 sym_op->cipher.data.offset = 0;
4899 sym_op->cipher.data.length = QUOTE_512_BYTES;
4901 sym_op->auth.data.offset = 0;
4902 sym_op->auth.data.length = QUOTE_512_BYTES;
4904 /* Process crypto operation */
4905 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4907 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4909 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4910 "crypto operation processing failed");
4913 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4914 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4917 "Ciphertext data not as expected");
4919 return TEST_SUCCESS;
4924 test_null_invalid_operation(void)
4926 struct crypto_testsuite_params *ts_params = &testsuite_params;
4927 struct crypto_unittest_params *ut_params = &unittest_params;
4929 /* Setup Cipher Parameters */
4930 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4931 ut_params->cipher_xform.next = NULL;
4933 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
4934 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4936 /* Create Crypto session*/
4937 ut_params->sess = rte_cryptodev_sym_session_create(
4938 ts_params->valid_devs[0], &ut_params->cipher_xform);
4939 TEST_ASSERT_NULL(ut_params->sess,
4940 "Session creation succeeded unexpectedly");
4943 /* Setup HMAC Parameters */
4944 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4945 ut_params->auth_xform.next = NULL;
4947 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
4948 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4950 /* Create Crypto session*/
4951 ut_params->sess = rte_cryptodev_sym_session_create(
4952 ts_params->valid_devs[0], &ut_params->auth_xform);
4953 TEST_ASSERT_NULL(ut_params->sess,
4954 "Session creation succeeded unexpectedly");
4956 return TEST_SUCCESS;
4960 #define NULL_BURST_LENGTH (32)
4963 test_null_burst_operation(void)
4965 struct crypto_testsuite_params *ts_params = &testsuite_params;
4966 struct crypto_unittest_params *ut_params = &unittest_params;
4968 unsigned i, burst_len = NULL_BURST_LENGTH;
4970 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
4971 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
4973 /* Setup Cipher Parameters */
4974 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4975 ut_params->cipher_xform.next = &ut_params->auth_xform;
4977 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4978 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4980 /* Setup HMAC Parameters */
4981 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4982 ut_params->auth_xform.next = NULL;
4984 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4985 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4987 /* Create Crypto session*/
4988 ut_params->sess = rte_cryptodev_sym_session_create(
4989 ts_params->valid_devs[0], &ut_params->cipher_xform);
4990 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4992 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4993 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
4994 burst_len, "failed to generate burst of crypto ops");
4996 /* Generate an operation for each mbuf in burst */
4997 for (i = 0; i < burst_len; i++) {
4998 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5000 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
5002 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
5006 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
5008 burst[i]->sym->m_src = m;
5011 /* Process crypto operation */
5012 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
5013 0, burst, burst_len),
5015 "Error enqueuing burst");
5017 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
5018 0, burst_dequeued, burst_len),
5020 "Error dequeuing burst");
5023 for (i = 0; i < burst_len; i++) {
5025 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
5026 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
5028 "data not as expected");
5030 rte_pktmbuf_free(burst[i]->sym->m_src);
5031 rte_crypto_op_free(burst[i]);
5034 return TEST_SUCCESS;
5038 generate_gmac_large_plaintext(uint8_t *data)
5042 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
5043 memcpy(&data[i], &data[0], 32);
5047 create_gmac_operation(enum rte_crypto_auth_operation op,
5048 const struct gmac_test_data *tdata)
5050 struct crypto_testsuite_params *ts_params = &testsuite_params;
5051 struct crypto_unittest_params *ut_params = &unittest_params;
5052 struct rte_crypto_sym_op *sym_op;
5054 unsigned iv_pad_len;
5055 unsigned aad_pad_len;
5057 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
5058 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5061 * Runtime generate the large plain text instead of use hard code
5062 * plain text vector. It is done to avoid create huge source file
5063 * with the test vector.
5065 if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
5066 generate_gmac_large_plaintext(tdata->aad.data);
5068 /* Generate Crypto op data structure */
5069 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5070 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5071 TEST_ASSERT_NOT_NULL(ut_params->op,
5072 "Failed to allocate symmetric crypto operation struct");
5074 sym_op = ut_params->op->sym;
5075 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5077 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
5078 "no room to append aad");
5080 sym_op->auth.aad.length = tdata->aad.len;
5081 sym_op->auth.aad.phys_addr =
5082 rte_pktmbuf_mtophys(ut_params->ibuf);
5083 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
5085 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5086 ut_params->ibuf, tdata->gmac_tag.len);
5087 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5088 "no room to append digest");
5090 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5091 ut_params->ibuf, aad_pad_len);
5092 sym_op->auth.digest.length = tdata->gmac_tag.len;
5094 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5095 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
5096 tdata->gmac_tag.len);
5097 TEST_HEXDUMP(stdout, "digest:",
5098 sym_op->auth.digest.data,
5099 sym_op->auth.digest.length);
5102 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5103 ut_params->ibuf, iv_pad_len);
5104 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5106 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
5107 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5108 sym_op->cipher.iv.length = tdata->iv.len;
5110 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
5112 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
5114 sym_op->cipher.data.length = 0;
5115 sym_op->cipher.data.offset = 0;
5117 sym_op->auth.data.offset = 0;
5118 sym_op->auth.data.length = 0;
5123 static int create_gmac_session(uint8_t dev_id,
5124 enum rte_crypto_cipher_operation op,
5125 const struct gmac_test_data *tdata,
5126 enum rte_crypto_auth_operation auth_op)
5128 uint8_t cipher_key[tdata->key.len];
5130 struct crypto_unittest_params *ut_params = &unittest_params;
5132 memcpy(cipher_key, tdata->key.data, tdata->key.len);
5134 /* For GMAC we setup cipher parameters */
5135 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5136 ut_params->cipher_xform.next = NULL;
5137 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
5138 ut_params->cipher_xform.cipher.op = op;
5139 ut_params->cipher_xform.cipher.key.data = cipher_key;
5140 ut_params->cipher_xform.cipher.key.length = tdata->key.len;
5142 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5143 ut_params->auth_xform.next = NULL;
5145 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
5146 ut_params->auth_xform.auth.op = auth_op;
5147 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
5148 ut_params->auth_xform.auth.add_auth_data_length = 0;
5149 ut_params->auth_xform.auth.key.length = 0;
5150 ut_params->auth_xform.auth.key.data = NULL;
5152 ut_params->cipher_xform.next = &ut_params->auth_xform;
5154 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5155 &ut_params->cipher_xform);
5157 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5163 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
5165 struct crypto_testsuite_params *ts_params = &testsuite_params;
5166 struct crypto_unittest_params *ut_params = &unittest_params;
5170 uint8_t *auth_tag, *p;
5171 uint16_t aad_pad_len;
5173 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5174 "No GMAC length in the source data");
5176 retval = create_gmac_session(ts_params->valid_devs[0],
5177 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5178 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
5183 if (tdata->aad.len > MBUF_SIZE)
5184 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5186 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5187 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5188 "Failed to allocate input buffer in mempool");
5190 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5191 rte_pktmbuf_tailroom(ut_params->ibuf));
5193 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5195 p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
5197 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
5203 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5205 ut_params->op->sym->m_src = ut_params->ibuf;
5207 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5208 ut_params->op), "failed to process sym crypto op");
5210 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5211 "crypto op processing failed");
5213 if (ut_params->op->sym->m_dst) {
5214 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5215 uint8_t *, aad_pad_len);
5217 auth_tag = p + aad_pad_len;
5220 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
5222 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5224 tdata->gmac_tag.data,
5225 tdata->gmac_tag.len,
5226 "GMAC Generated auth tag not as expected");
5232 test_AES_GMAC_authentication_test_case_1(void)
5234 return test_AES_GMAC_authentication(&gmac_test_case_1);
5238 test_AES_GMAC_authentication_test_case_2(void)
5240 return test_AES_GMAC_authentication(&gmac_test_case_2);
5244 test_AES_GMAC_authentication_test_case_3(void)
5246 return test_AES_GMAC_authentication(&gmac_test_case_3);
5250 test_AES_GMAC_authentication_test_case_4(void)
5252 return test_AES_GMAC_authentication(&gmac_test_case_4);
5256 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
5258 struct crypto_testsuite_params *ts_params = &testsuite_params;
5259 struct crypto_unittest_params *ut_params = &unittest_params;
5262 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5263 "No GMAC length in the source data");
5265 retval = create_gmac_session(ts_params->valid_devs[0],
5266 RTE_CRYPTO_CIPHER_OP_DECRYPT,
5267 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
5272 if (tdata->aad.len > MBUF_SIZE)
5273 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5275 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5276 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5277 "Failed to allocate input buffer in mempool");
5279 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5280 rte_pktmbuf_tailroom(ut_params->ibuf));
5282 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
5288 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5290 ut_params->op->sym->m_src = ut_params->ibuf;
5292 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5293 ut_params->op), "failed to process sym crypto op");
5295 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5296 "crypto op processing failed");
5303 test_AES_GMAC_authentication_verify_test_case_1(void)
5305 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
5309 test_AES_GMAC_authentication_verify_test_case_2(void)
5311 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
5315 test_AES_GMAC_authentication_verify_test_case_3(void)
5317 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
5321 test_AES_GMAC_authentication_verify_test_case_4(void)
5323 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
5326 struct test_crypto_vector {
5327 enum rte_crypto_cipher_algorithm crypto_algo;
5340 const uint8_t *data;
5345 const uint8_t *data;
5349 enum rte_crypto_auth_algorithm auth_algo;
5357 const uint8_t *data;
5367 static const struct test_crypto_vector
5368 hmac_sha1_test_crypto_vector = {
5369 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5371 .data = plaintext_hash,
5376 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5377 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5378 0xDE, 0xF4, 0xDE, 0xAD
5384 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
5385 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
5386 0x3F, 0x91, 0x64, 0x59
5392 static const struct test_crypto_vector
5393 aes128_gmac_test_vector = {
5394 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
5395 .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
5397 .data = plaintext_hash,
5402 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5403 0x08, 0x09, 0x0A, 0x0B
5409 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5410 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
5416 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
5417 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
5423 static const struct test_crypto_vector
5424 aes128cbc_hmac_sha1_test_vector = {
5425 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
5428 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
5429 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
5435 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5436 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
5441 .data = plaintext_hash,
5445 .data = ciphertext512_aes128cbc,
5448 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5451 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5452 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5453 0xDE, 0xF4, 0xDE, 0xAD
5459 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
5460 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5461 0x18, 0x8C, 0x1D, 0x32
5468 data_corruption(uint8_t *data)
5474 tag_corruption(uint8_t *data, unsigned int tag_offset)
5476 data[tag_offset] += 1;
5480 create_auth_session(struct crypto_unittest_params *ut_params,
5482 const struct test_crypto_vector *reference,
5483 enum rte_crypto_auth_operation auth_op)
5485 uint8_t auth_key[reference->auth_key.len + 1];
5487 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5489 /* Setup Authentication Parameters */
5490 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5491 ut_params->auth_xform.auth.op = auth_op;
5492 ut_params->auth_xform.next = NULL;
5493 ut_params->auth_xform.auth.algo = reference->auth_algo;
5494 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5495 ut_params->auth_xform.auth.key.data = auth_key;
5496 ut_params->auth_xform.auth.digest_length = reference->digest.len;
5497 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5499 /* Create Crypto session*/
5500 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5501 &ut_params->auth_xform);
5503 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5509 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
5511 const struct test_crypto_vector *reference,
5512 enum rte_crypto_auth_operation auth_op,
5513 enum rte_crypto_cipher_operation cipher_op)
5515 uint8_t cipher_key[reference->cipher_key.len + 1];
5516 uint8_t auth_key[reference->auth_key.len + 1];
5518 memcpy(cipher_key, reference->cipher_key.data,
5519 reference->cipher_key.len);
5520 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5522 /* Setup Authentication Parameters */
5523 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5524 ut_params->auth_xform.auth.op = auth_op;
5525 ut_params->auth_xform.next = &ut_params->cipher_xform;
5526 ut_params->auth_xform.auth.algo = reference->auth_algo;
5527 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5528 ut_params->auth_xform.auth.key.data = auth_key;
5529 ut_params->auth_xform.auth.digest_length = reference->digest.len;
5530 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5532 /* Setup Cipher Parameters */
5533 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5534 ut_params->cipher_xform.next = NULL;
5535 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
5536 ut_params->cipher_xform.cipher.op = cipher_op;
5537 ut_params->cipher_xform.cipher.key.data = cipher_key;
5538 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
5540 /* Create Crypto session*/
5541 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5542 &ut_params->auth_xform);
5544 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5550 create_auth_operation(struct crypto_testsuite_params *ts_params,
5551 struct crypto_unittest_params *ut_params,
5552 const struct test_crypto_vector *reference,
5553 unsigned int auth_generate)
5555 /* Generate Crypto op data structure */
5556 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5557 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5558 TEST_ASSERT_NOT_NULL(ut_params->op,
5559 "Failed to allocate pktmbuf offload");
5561 /* Set crypto operation data parameters */
5562 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5564 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5566 /* set crypto operation source mbuf */
5567 sym_op->m_src = ut_params->ibuf;
5570 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5571 ut_params->ibuf, reference->digest.len);
5573 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5574 "no room to append auth tag");
5576 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5577 ut_params->ibuf, reference->plaintext.len);
5578 sym_op->auth.digest.length = reference->digest.len;
5581 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5583 memcpy(sym_op->auth.digest.data,
5584 reference->digest.data,
5585 reference->digest.len);
5587 TEST_HEXDUMP(stdout, "digest:",
5588 sym_op->auth.digest.data,
5589 sym_op->auth.digest.length);
5591 sym_op->auth.data.length = reference->plaintext.len;
5592 sym_op->auth.data.offset = 0;
5598 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
5599 struct crypto_unittest_params *ut_params,
5600 const struct test_crypto_vector *reference,
5601 unsigned int auth_generate)
5603 /* Generate Crypto op data structure */
5604 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5605 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5606 TEST_ASSERT_NOT_NULL(ut_params->op,
5607 "Failed to allocate pktmbuf offload");
5609 /* Set crypto operation data parameters */
5610 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5612 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5614 /* set crypto operation source mbuf */
5615 sym_op->m_src = ut_params->ibuf;
5618 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5619 reference->aad.len);
5620 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
5621 memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
5623 TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
5625 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5626 sym_op->auth.aad.length = reference->aad.len;
5629 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5630 ut_params->ibuf, reference->digest.len);
5632 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5633 "no room to append auth tag");
5635 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5636 ut_params->ibuf, reference->ciphertext.len);
5637 sym_op->auth.digest.length = reference->digest.len;
5640 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5642 memcpy(sym_op->auth.digest.data,
5643 reference->digest.data,
5644 reference->digest.len);
5646 TEST_HEXDUMP(stdout, "digest:",
5647 sym_op->auth.digest.data,
5648 sym_op->auth.digest.length);
5650 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5651 ut_params->ibuf, reference->iv.len);
5652 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5654 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5655 sym_op->cipher.iv.length = reference->iv.len;
5657 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5659 sym_op->cipher.data.length = 0;
5660 sym_op->cipher.data.offset = 0;
5662 sym_op->auth.data.length = 0;
5663 sym_op->auth.data.offset = 0;
5669 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
5670 struct crypto_unittest_params *ut_params,
5671 const struct test_crypto_vector *reference,
5672 unsigned int auth_generate)
5674 /* Generate Crypto op data structure */
5675 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5676 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5677 TEST_ASSERT_NOT_NULL(ut_params->op,
5678 "Failed to allocate pktmbuf offload");
5680 /* Set crypto operation data parameters */
5681 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5683 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5685 /* set crypto operation source mbuf */
5686 sym_op->m_src = ut_params->ibuf;
5689 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5690 ut_params->ibuf, reference->digest.len);
5692 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5693 "no room to append auth tag");
5695 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5696 ut_params->ibuf, reference->ciphertext.len);
5697 sym_op->auth.digest.length = reference->digest.len;
5700 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5702 memcpy(sym_op->auth.digest.data,
5703 reference->digest.data,
5704 reference->digest.len);
5706 TEST_HEXDUMP(stdout, "digest:",
5707 sym_op->auth.digest.data,
5708 sym_op->auth.digest.length);
5710 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5711 ut_params->ibuf, reference->iv.len);
5712 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5714 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5715 sym_op->cipher.iv.length = reference->iv.len;
5717 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5719 sym_op->cipher.data.length = reference->ciphertext.len;
5720 sym_op->cipher.data.offset = reference->iv.len;
5722 sym_op->auth.data.length = reference->ciphertext.len;
5723 sym_op->auth.data.offset = reference->iv.len;
5729 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
5730 struct crypto_unittest_params *ut_params,
5731 const struct test_crypto_vector *reference)
5733 return create_auth_operation(ts_params, ut_params, reference, 0);
5737 create_auth_verify_GMAC_operation(
5738 struct crypto_testsuite_params *ts_params,
5739 struct crypto_unittest_params *ut_params,
5740 const struct test_crypto_vector *reference)
5742 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
5746 create_cipher_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_cipher_auth_operation(ts_params, ut_params, reference, 0);
5754 test_authentication_verify_fail_when_data_corruption(
5755 struct crypto_testsuite_params *ts_params,
5756 struct crypto_unittest_params *ut_params,
5757 const struct test_crypto_vector *reference,
5758 unsigned int data_corrupted)
5764 /* Create session */
5765 retval = create_auth_session(ut_params,
5766 ts_params->valid_devs[0],
5768 RTE_CRYPTO_AUTH_OP_VERIFY);
5772 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5773 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5774 "Failed to allocate input buffer in mempool");
5776 /* clear mbuf payload */
5777 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5778 rte_pktmbuf_tailroom(ut_params->ibuf));
5780 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5781 reference->plaintext.len);
5782 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
5783 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
5785 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
5787 /* Create operation */
5788 retval = create_auth_verify_operation(ts_params, ut_params, reference);
5794 data_corruption(plaintext);
5796 tag_corruption(plaintext, reference->plaintext.len);
5798 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5800 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5801 TEST_ASSERT_EQUAL(ut_params->op->status,
5802 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5803 "authentication not failed");
5805 ut_params->obuf = ut_params->op->sym->m_src;
5806 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5812 test_authentication_verify_GMAC_fail_when_corruption(
5813 struct crypto_testsuite_params *ts_params,
5814 struct crypto_unittest_params *ut_params,
5815 const struct test_crypto_vector *reference,
5816 unsigned int data_corrupted)
5820 /* Create session */
5821 retval = create_auth_cipher_session(ut_params,
5822 ts_params->valid_devs[0],
5824 RTE_CRYPTO_AUTH_OP_VERIFY,
5825 RTE_CRYPTO_CIPHER_OP_DECRYPT);
5829 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5830 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5831 "Failed to allocate input buffer in mempool");
5833 /* clear mbuf payload */
5834 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5835 rte_pktmbuf_tailroom(ut_params->ibuf));
5837 /* Create operation */
5838 retval = create_auth_verify_GMAC_operation(ts_params,
5846 data_corruption(ut_params->op->sym->auth.aad.data);
5848 tag_corruption(ut_params->op->sym->auth.aad.data,
5849 reference->aad.len);
5851 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5853 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5854 TEST_ASSERT_EQUAL(ut_params->op->status,
5855 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5856 "authentication not failed");
5858 ut_params->obuf = ut_params->op->sym->m_src;
5859 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5865 test_authenticated_decryption_fail_when_corruption(
5866 struct crypto_testsuite_params *ts_params,
5867 struct crypto_unittest_params *ut_params,
5868 const struct test_crypto_vector *reference,
5869 unsigned int data_corrupted)
5873 uint8_t *ciphertext;
5875 /* Create session */
5876 retval = create_auth_cipher_session(ut_params,
5877 ts_params->valid_devs[0],
5879 RTE_CRYPTO_AUTH_OP_VERIFY,
5880 RTE_CRYPTO_CIPHER_OP_DECRYPT);
5884 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5885 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5886 "Failed to allocate input buffer in mempool");
5888 /* clear mbuf payload */
5889 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5890 rte_pktmbuf_tailroom(ut_params->ibuf));
5892 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5893 reference->ciphertext.len);
5894 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
5895 memcpy(ciphertext, reference->ciphertext.data,
5896 reference->ciphertext.len);
5898 /* Create operation */
5899 retval = create_cipher_auth_verify_operation(ts_params,
5907 data_corruption(ciphertext);
5909 tag_corruption(ciphertext, reference->ciphertext.len);
5911 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5914 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5915 TEST_ASSERT_EQUAL(ut_params->op->status,
5916 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5917 "authentication not failed");
5919 ut_params->obuf = ut_params->op->sym->m_src;
5920 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5926 test_authentication_verify_fail_when_data_corrupted(
5927 struct crypto_testsuite_params *ts_params,
5928 struct crypto_unittest_params *ut_params,
5929 const struct test_crypto_vector *reference)
5931 return test_authentication_verify_fail_when_data_corruption(
5932 ts_params, ut_params, reference, 1);
5936 test_authentication_verify_fail_when_tag_corrupted(
5937 struct crypto_testsuite_params *ts_params,
5938 struct crypto_unittest_params *ut_params,
5939 const struct test_crypto_vector *reference)
5941 return test_authentication_verify_fail_when_data_corruption(
5942 ts_params, ut_params, reference, 0);
5946 test_authentication_verify_GMAC_fail_when_data_corrupted(
5947 struct crypto_testsuite_params *ts_params,
5948 struct crypto_unittest_params *ut_params,
5949 const struct test_crypto_vector *reference)
5951 return test_authentication_verify_GMAC_fail_when_corruption(
5952 ts_params, ut_params, reference, 1);
5956 test_authentication_verify_GMAC_fail_when_tag_corrupted(
5957 struct crypto_testsuite_params *ts_params,
5958 struct crypto_unittest_params *ut_params,
5959 const struct test_crypto_vector *reference)
5961 return test_authentication_verify_GMAC_fail_when_corruption(
5962 ts_params, ut_params, reference, 0);
5966 test_authenticated_decryption_fail_when_data_corrupted(
5967 struct crypto_testsuite_params *ts_params,
5968 struct crypto_unittest_params *ut_params,
5969 const struct test_crypto_vector *reference)
5971 return test_authenticated_decryption_fail_when_corruption(
5972 ts_params, ut_params, reference, 1);
5976 test_authenticated_decryption_fail_when_tag_corrupted(
5977 struct crypto_testsuite_params *ts_params,
5978 struct crypto_unittest_params *ut_params,
5979 const struct test_crypto_vector *reference)
5981 return test_authenticated_decryption_fail_when_corruption(
5982 ts_params, ut_params, reference, 0);
5986 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
5988 return test_authentication_verify_fail_when_data_corrupted(
5989 &testsuite_params, &unittest_params,
5990 &hmac_sha1_test_crypto_vector);
5994 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
5996 return test_authentication_verify_fail_when_tag_corrupted(
5997 &testsuite_params, &unittest_params,
5998 &hmac_sha1_test_crypto_vector);
6002 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
6004 return test_authentication_verify_GMAC_fail_when_data_corrupted(
6005 &testsuite_params, &unittest_params,
6006 &aes128_gmac_test_vector);
6010 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
6012 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
6013 &testsuite_params, &unittest_params,
6014 &aes128_gmac_test_vector);
6018 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
6020 return test_authenticated_decryption_fail_when_data_corrupted(
6023 &aes128cbc_hmac_sha1_test_vector);
6027 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
6029 return test_authenticated_decryption_fail_when_tag_corrupted(
6032 &aes128cbc_hmac_sha1_test_vector);
6035 static struct unit_test_suite cryptodev_qat_testsuite = {
6036 .suite_name = "Crypto QAT Unit Test Suite",
6037 .setup = testsuite_setup,
6038 .teardown = testsuite_teardown,
6039 .unit_test_cases = {
6040 TEST_CASE_ST(ut_setup, ut_teardown,
6041 test_device_configure_invalid_dev_id),
6042 TEST_CASE_ST(ut_setup, ut_teardown,
6043 test_device_configure_invalid_queue_pair_ids),
6044 TEST_CASE_ST(ut_setup, ut_teardown,
6045 test_queue_pair_descriptor_setup),
6046 TEST_CASE_ST(ut_setup, ut_teardown,
6047 test_multi_session),
6049 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
6050 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
6051 TEST_CASE_ST(ut_setup, ut_teardown,
6052 test_3DES_cipheronly_qat_all),
6053 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
6054 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
6056 /** AES GCM Authenticated Encryption */
6057 TEST_CASE_ST(ut_setup, ut_teardown,
6058 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6059 TEST_CASE_ST(ut_setup, ut_teardown,
6060 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6061 TEST_CASE_ST(ut_setup, ut_teardown,
6062 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6063 TEST_CASE_ST(ut_setup, ut_teardown,
6064 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6065 TEST_CASE_ST(ut_setup, ut_teardown,
6066 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6067 TEST_CASE_ST(ut_setup, ut_teardown,
6068 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6069 TEST_CASE_ST(ut_setup, ut_teardown,
6070 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6072 /** AES GCM Authenticated Decryption */
6073 TEST_CASE_ST(ut_setup, ut_teardown,
6074 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6075 TEST_CASE_ST(ut_setup, ut_teardown,
6076 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6077 TEST_CASE_ST(ut_setup, ut_teardown,
6078 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6079 TEST_CASE_ST(ut_setup, ut_teardown,
6080 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6081 TEST_CASE_ST(ut_setup, ut_teardown,
6082 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6083 TEST_CASE_ST(ut_setup, ut_teardown,
6084 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6085 TEST_CASE_ST(ut_setup, ut_teardown,
6086 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6088 /** AES GMAC Authentication */
6089 TEST_CASE_ST(ut_setup, ut_teardown,
6090 test_AES_GMAC_authentication_test_case_1),
6091 TEST_CASE_ST(ut_setup, ut_teardown,
6092 test_AES_GMAC_authentication_verify_test_case_1),
6093 TEST_CASE_ST(ut_setup, ut_teardown,
6094 test_AES_GMAC_authentication_test_case_2),
6095 TEST_CASE_ST(ut_setup, ut_teardown,
6096 test_AES_GMAC_authentication_verify_test_case_2),
6097 TEST_CASE_ST(ut_setup, ut_teardown,
6098 test_AES_GMAC_authentication_test_case_3),
6099 TEST_CASE_ST(ut_setup, ut_teardown,
6100 test_AES_GMAC_authentication_verify_test_case_3),
6102 /** SNOW 3G encrypt only (UEA2) */
6103 TEST_CASE_ST(ut_setup, ut_teardown,
6104 test_snow3g_encryption_test_case_1),
6105 TEST_CASE_ST(ut_setup, ut_teardown,
6106 test_snow3g_encryption_test_case_2),
6107 TEST_CASE_ST(ut_setup, ut_teardown,
6108 test_snow3g_encryption_test_case_3),
6109 TEST_CASE_ST(ut_setup, ut_teardown,
6110 test_snow3g_encryption_test_case_4),
6111 TEST_CASE_ST(ut_setup, ut_teardown,
6112 test_snow3g_encryption_test_case_5),
6114 TEST_CASE_ST(ut_setup, ut_teardown,
6115 test_snow3g_encryption_test_case_1_oop),
6116 TEST_CASE_ST(ut_setup, ut_teardown,
6117 test_snow3g_decryption_test_case_1_oop),
6119 /** SNOW 3G decrypt only (UEA2) */
6120 TEST_CASE_ST(ut_setup, ut_teardown,
6121 test_snow3g_decryption_test_case_1),
6122 TEST_CASE_ST(ut_setup, ut_teardown,
6123 test_snow3g_decryption_test_case_2),
6124 TEST_CASE_ST(ut_setup, ut_teardown,
6125 test_snow3g_decryption_test_case_3),
6126 TEST_CASE_ST(ut_setup, ut_teardown,
6127 test_snow3g_decryption_test_case_4),
6128 TEST_CASE_ST(ut_setup, ut_teardown,
6129 test_snow3g_decryption_test_case_5),
6130 TEST_CASE_ST(ut_setup, ut_teardown,
6131 test_snow3g_hash_generate_test_case_1),
6132 TEST_CASE_ST(ut_setup, ut_teardown,
6133 test_snow3g_hash_generate_test_case_2),
6134 TEST_CASE_ST(ut_setup, ut_teardown,
6135 test_snow3g_hash_generate_test_case_3),
6136 TEST_CASE_ST(ut_setup, ut_teardown,
6137 test_snow3g_hash_verify_test_case_1),
6138 TEST_CASE_ST(ut_setup, ut_teardown,
6139 test_snow3g_hash_verify_test_case_2),
6140 TEST_CASE_ST(ut_setup, ut_teardown,
6141 test_snow3g_hash_verify_test_case_3),
6142 TEST_CASE_ST(ut_setup, ut_teardown,
6143 test_snow3g_cipher_auth_test_case_1),
6144 TEST_CASE_ST(ut_setup, ut_teardown,
6145 test_snow3g_auth_cipher_test_case_1),
6147 /** HMAC_MD5 Authentication */
6148 TEST_CASE_ST(ut_setup, ut_teardown,
6149 test_MD5_HMAC_generate_case_1),
6150 TEST_CASE_ST(ut_setup, ut_teardown,
6151 test_MD5_HMAC_verify_case_1),
6152 TEST_CASE_ST(ut_setup, ut_teardown,
6153 test_MD5_HMAC_generate_case_2),
6154 TEST_CASE_ST(ut_setup, ut_teardown,
6155 test_MD5_HMAC_verify_case_2),
6158 TEST_CASE_ST(ut_setup, ut_teardown,
6159 test_null_auth_only_operation),
6160 TEST_CASE_ST(ut_setup, ut_teardown,
6161 test_null_cipher_only_operation),
6162 TEST_CASE_ST(ut_setup, ut_teardown,
6163 test_null_cipher_auth_operation),
6164 TEST_CASE_ST(ut_setup, ut_teardown,
6165 test_null_auth_cipher_operation),
6167 TEST_CASE_ST(ut_setup, ut_teardown,
6168 test_kasumi_hash_generate_test_case_6),
6171 TEST_CASE_ST(ut_setup, ut_teardown,
6172 test_kasumi_encryption_test_case_1),
6173 TEST_CASE_ST(ut_setup, ut_teardown,
6174 test_kasumi_encryption_test_case_3),
6175 TEST_CASE_ST(ut_setup, ut_teardown,
6176 test_kasumi_auth_cipher_test_case_1),
6177 TEST_CASE_ST(ut_setup, ut_teardown,
6178 test_kasumi_cipher_auth_test_case_1),
6180 /** Negative tests */
6181 TEST_CASE_ST(ut_setup, ut_teardown,
6182 authentication_verify_HMAC_SHA1_fail_data_corrupt),
6183 TEST_CASE_ST(ut_setup, ut_teardown,
6184 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6185 TEST_CASE_ST(ut_setup, ut_teardown,
6186 authentication_verify_AES128_GMAC_fail_data_corrupt),
6187 TEST_CASE_ST(ut_setup, ut_teardown,
6188 authentication_verify_AES128_GMAC_fail_tag_corrupt),
6189 TEST_CASE_ST(ut_setup, ut_teardown,
6190 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6191 TEST_CASE_ST(ut_setup, ut_teardown,
6192 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6194 TEST_CASES_END() /**< NULL terminate unit test array */
6198 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
6199 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
6200 .setup = testsuite_setup,
6201 .teardown = testsuite_teardown,
6202 .unit_test_cases = {
6203 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
6205 TEST_CASES_END() /**< NULL terminate unit test array */
6209 static struct unit_test_suite cryptodev_openssl_testsuite = {
6210 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
6211 .setup = testsuite_setup,
6212 .teardown = testsuite_teardown,
6213 .unit_test_cases = {
6214 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
6215 TEST_CASE_ST(ut_setup, ut_teardown,
6216 test_multi_session_random_usage),
6217 TEST_CASE_ST(ut_setup, ut_teardown,
6218 test_AES_chain_openssl_all),
6219 TEST_CASE_ST(ut_setup, ut_teardown,
6220 test_AES_cipheronly_openssl_all),
6221 TEST_CASE_ST(ut_setup, ut_teardown,
6222 test_3DES_chain_openssl_all),
6223 TEST_CASE_ST(ut_setup, ut_teardown,
6224 test_3DES_cipheronly_openssl_all),
6225 TEST_CASE_ST(ut_setup, ut_teardown,
6226 test_authonly_openssl_all),
6228 /** AES GCM Authenticated Encryption */
6229 TEST_CASE_ST(ut_setup, ut_teardown,
6230 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6231 TEST_CASE_ST(ut_setup, ut_teardown,
6232 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6233 TEST_CASE_ST(ut_setup, ut_teardown,
6234 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6235 TEST_CASE_ST(ut_setup, ut_teardown,
6236 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6237 TEST_CASE_ST(ut_setup, ut_teardown,
6238 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6239 TEST_CASE_ST(ut_setup, ut_teardown,
6240 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6241 TEST_CASE_ST(ut_setup, ut_teardown,
6242 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6244 /** AES GCM Authenticated Decryption */
6245 TEST_CASE_ST(ut_setup, ut_teardown,
6246 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6247 TEST_CASE_ST(ut_setup, ut_teardown,
6248 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6249 TEST_CASE_ST(ut_setup, ut_teardown,
6250 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6251 TEST_CASE_ST(ut_setup, ut_teardown,
6252 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6253 TEST_CASE_ST(ut_setup, ut_teardown,
6254 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6255 TEST_CASE_ST(ut_setup, ut_teardown,
6256 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6257 TEST_CASE_ST(ut_setup, ut_teardown,
6258 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6260 /** AES GMAC Authentication */
6261 TEST_CASE_ST(ut_setup, ut_teardown,
6262 test_AES_GMAC_authentication_test_case_1),
6263 TEST_CASE_ST(ut_setup, ut_teardown,
6264 test_AES_GMAC_authentication_verify_test_case_1),
6265 TEST_CASE_ST(ut_setup, ut_teardown,
6266 test_AES_GMAC_authentication_test_case_2),
6267 TEST_CASE_ST(ut_setup, ut_teardown,
6268 test_AES_GMAC_authentication_verify_test_case_2),
6269 TEST_CASE_ST(ut_setup, ut_teardown,
6270 test_AES_GMAC_authentication_test_case_3),
6271 TEST_CASE_ST(ut_setup, ut_teardown,
6272 test_AES_GMAC_authentication_verify_test_case_3),
6273 TEST_CASE_ST(ut_setup, ut_teardown,
6274 test_AES_GMAC_authentication_test_case_4),
6275 TEST_CASE_ST(ut_setup, ut_teardown,
6276 test_AES_GMAC_authentication_verify_test_case_4),
6278 /** Negative tests */
6279 TEST_CASE_ST(ut_setup, ut_teardown,
6280 authentication_verify_HMAC_SHA1_fail_data_corrupt),
6281 TEST_CASE_ST(ut_setup, ut_teardown,
6282 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6283 TEST_CASE_ST(ut_setup, ut_teardown,
6284 authentication_verify_AES128_GMAC_fail_data_corrupt),
6285 TEST_CASE_ST(ut_setup, ut_teardown,
6286 authentication_verify_AES128_GMAC_fail_tag_corrupt),
6287 TEST_CASE_ST(ut_setup, ut_teardown,
6288 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6289 TEST_CASE_ST(ut_setup, ut_teardown,
6290 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6292 TEST_CASES_END() /**< NULL terminate unit test array */
6296 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
6297 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
6298 .setup = testsuite_setup,
6299 .teardown = testsuite_teardown,
6300 .unit_test_cases = {
6301 /** AES GCM Authenticated Encryption */
6302 TEST_CASE_ST(ut_setup, ut_teardown,
6303 test_mb_AES_GCM_authenticated_encryption_test_case_1),
6304 TEST_CASE_ST(ut_setup, ut_teardown,
6305 test_mb_AES_GCM_authenticated_encryption_test_case_2),
6306 TEST_CASE_ST(ut_setup, ut_teardown,
6307 test_mb_AES_GCM_authenticated_encryption_test_case_3),
6308 TEST_CASE_ST(ut_setup, ut_teardown,
6309 test_mb_AES_GCM_authenticated_encryption_test_case_4),
6310 TEST_CASE_ST(ut_setup, ut_teardown,
6311 test_mb_AES_GCM_authenticated_encryption_test_case_5),
6312 TEST_CASE_ST(ut_setup, ut_teardown,
6313 test_mb_AES_GCM_authenticated_encryption_test_case_6),
6314 TEST_CASE_ST(ut_setup, ut_teardown,
6315 test_mb_AES_GCM_authenticated_encryption_test_case_7),
6317 /** AES GCM Authenticated Decryption */
6318 TEST_CASE_ST(ut_setup, ut_teardown,
6319 test_mb_AES_GCM_authenticated_decryption_test_case_1),
6320 TEST_CASE_ST(ut_setup, ut_teardown,
6321 test_mb_AES_GCM_authenticated_decryption_test_case_2),
6322 TEST_CASE_ST(ut_setup, ut_teardown,
6323 test_mb_AES_GCM_authenticated_decryption_test_case_3),
6324 TEST_CASE_ST(ut_setup, ut_teardown,
6325 test_mb_AES_GCM_authenticated_decryption_test_case_4),
6326 TEST_CASE_ST(ut_setup, ut_teardown,
6327 test_mb_AES_GCM_authenticated_decryption_test_case_5),
6328 TEST_CASE_ST(ut_setup, ut_teardown,
6329 test_mb_AES_GCM_authenticated_decryption_test_case_6),
6330 TEST_CASE_ST(ut_setup, ut_teardown,
6331 test_mb_AES_GCM_authenticated_decryption_test_case_7),
6333 TEST_CASES_END() /**< NULL terminate unit test array */
6337 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
6338 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
6339 .setup = testsuite_setup,
6340 .teardown = testsuite_teardown,
6341 .unit_test_cases = {
6342 /** KASUMI encrypt only (UEA1) */
6343 TEST_CASE_ST(ut_setup, ut_teardown,
6344 test_kasumi_encryption_test_case_1),
6345 TEST_CASE_ST(ut_setup, ut_teardown,
6346 test_kasumi_encryption_test_case_2),
6347 TEST_CASE_ST(ut_setup, ut_teardown,
6348 test_kasumi_encryption_test_case_3),
6349 TEST_CASE_ST(ut_setup, ut_teardown,
6350 test_kasumi_encryption_test_case_4),
6351 TEST_CASE_ST(ut_setup, ut_teardown,
6352 test_kasumi_encryption_test_case_5),
6353 /** KASUMI decrypt only (UEA1) */
6354 TEST_CASE_ST(ut_setup, ut_teardown,
6355 test_kasumi_decryption_test_case_1),
6356 TEST_CASE_ST(ut_setup, ut_teardown,
6357 test_kasumi_decryption_test_case_2),
6358 TEST_CASE_ST(ut_setup, ut_teardown,
6359 test_kasumi_decryption_test_case_3),
6360 TEST_CASE_ST(ut_setup, ut_teardown,
6361 test_kasumi_decryption_test_case_4),
6362 TEST_CASE_ST(ut_setup, ut_teardown,
6363 test_kasumi_decryption_test_case_5),
6365 TEST_CASE_ST(ut_setup, ut_teardown,
6366 test_kasumi_encryption_test_case_1_oop),
6367 TEST_CASE_ST(ut_setup, ut_teardown,
6368 test_kasumi_decryption_test_case_1_oop),
6370 /** KASUMI hash only (UIA1) */
6371 TEST_CASE_ST(ut_setup, ut_teardown,
6372 test_kasumi_hash_generate_test_case_1),
6373 TEST_CASE_ST(ut_setup, ut_teardown,
6374 test_kasumi_hash_generate_test_case_2),
6375 TEST_CASE_ST(ut_setup, ut_teardown,
6376 test_kasumi_hash_generate_test_case_3),
6377 TEST_CASE_ST(ut_setup, ut_teardown,
6378 test_kasumi_hash_generate_test_case_4),
6379 TEST_CASE_ST(ut_setup, ut_teardown,
6380 test_kasumi_hash_generate_test_case_5),
6381 TEST_CASE_ST(ut_setup, ut_teardown,
6382 test_kasumi_hash_generate_test_case_6),
6383 TEST_CASE_ST(ut_setup, ut_teardown,
6384 test_kasumi_hash_verify_test_case_1),
6385 TEST_CASE_ST(ut_setup, ut_teardown,
6386 test_kasumi_hash_verify_test_case_2),
6387 TEST_CASE_ST(ut_setup, ut_teardown,
6388 test_kasumi_hash_verify_test_case_3),
6389 TEST_CASE_ST(ut_setup, ut_teardown,
6390 test_kasumi_hash_verify_test_case_4),
6391 TEST_CASE_ST(ut_setup, ut_teardown,
6392 test_kasumi_hash_verify_test_case_5),
6393 TEST_CASE_ST(ut_setup, ut_teardown,
6394 test_kasumi_auth_cipher_test_case_1),
6395 TEST_CASE_ST(ut_setup, ut_teardown,
6396 test_kasumi_cipher_auth_test_case_1),
6397 TEST_CASES_END() /**< NULL terminate unit test array */
6400 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
6401 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
6402 .setup = testsuite_setup,
6403 .teardown = testsuite_teardown,
6404 .unit_test_cases = {
6405 /** SNOW 3G encrypt only (UEA2) */
6406 TEST_CASE_ST(ut_setup, ut_teardown,
6407 test_snow3g_encryption_test_case_1),
6408 TEST_CASE_ST(ut_setup, ut_teardown,
6409 test_snow3g_encryption_test_case_2),
6410 TEST_CASE_ST(ut_setup, ut_teardown,
6411 test_snow3g_encryption_test_case_3),
6412 TEST_CASE_ST(ut_setup, ut_teardown,
6413 test_snow3g_encryption_test_case_4),
6414 TEST_CASE_ST(ut_setup, ut_teardown,
6415 test_snow3g_encryption_test_case_5),
6417 TEST_CASE_ST(ut_setup, ut_teardown,
6418 test_snow3g_encryption_test_case_1_oop),
6419 TEST_CASE_ST(ut_setup, ut_teardown,
6420 test_snow3g_decryption_test_case_1_oop),
6422 TEST_CASE_ST(ut_setup, ut_teardown,
6423 test_snow3g_encryption_test_case_1_offset_oop),
6425 /** SNOW 3G decrypt only (UEA2) */
6426 TEST_CASE_ST(ut_setup, ut_teardown,
6427 test_snow3g_decryption_test_case_1),
6428 TEST_CASE_ST(ut_setup, ut_teardown,
6429 test_snow3g_decryption_test_case_2),
6430 TEST_CASE_ST(ut_setup, ut_teardown,
6431 test_snow3g_decryption_test_case_3),
6432 TEST_CASE_ST(ut_setup, ut_teardown,
6433 test_snow3g_decryption_test_case_4),
6434 TEST_CASE_ST(ut_setup, ut_teardown,
6435 test_snow3g_decryption_test_case_5),
6436 TEST_CASE_ST(ut_setup, ut_teardown,
6437 test_snow3g_hash_generate_test_case_1),
6438 TEST_CASE_ST(ut_setup, ut_teardown,
6439 test_snow3g_hash_generate_test_case_2),
6440 TEST_CASE_ST(ut_setup, ut_teardown,
6441 test_snow3g_hash_generate_test_case_3),
6442 /* Tests with buffers which length is not byte-aligned */
6443 TEST_CASE_ST(ut_setup, ut_teardown,
6444 test_snow3g_hash_generate_test_case_4),
6445 TEST_CASE_ST(ut_setup, ut_teardown,
6446 test_snow3g_hash_generate_test_case_5),
6447 TEST_CASE_ST(ut_setup, ut_teardown,
6448 test_snow3g_hash_generate_test_case_6),
6449 TEST_CASE_ST(ut_setup, ut_teardown,
6450 test_snow3g_hash_verify_test_case_1),
6451 TEST_CASE_ST(ut_setup, ut_teardown,
6452 test_snow3g_hash_verify_test_case_2),
6453 TEST_CASE_ST(ut_setup, ut_teardown,
6454 test_snow3g_hash_verify_test_case_3),
6455 /* Tests with buffers which length is not byte-aligned */
6456 TEST_CASE_ST(ut_setup, ut_teardown,
6457 test_snow3g_hash_verify_test_case_4),
6458 TEST_CASE_ST(ut_setup, ut_teardown,
6459 test_snow3g_hash_verify_test_case_5),
6460 TEST_CASE_ST(ut_setup, ut_teardown,
6461 test_snow3g_hash_verify_test_case_6),
6462 TEST_CASE_ST(ut_setup, ut_teardown,
6463 test_snow3g_cipher_auth_test_case_1),
6464 TEST_CASE_ST(ut_setup, ut_teardown,
6465 test_snow3g_auth_cipher_test_case_1),
6467 TEST_CASES_END() /**< NULL terminate unit test array */
6471 static struct unit_test_suite cryptodev_sw_zuc_testsuite = {
6472 .suite_name = "Crypto Device SW ZUC Unit Test Suite",
6473 .setup = testsuite_setup,
6474 .teardown = testsuite_teardown,
6475 .unit_test_cases = {
6476 /** ZUC encrypt only (EEA3) */
6477 TEST_CASE_ST(ut_setup, ut_teardown,
6478 test_zuc_encryption_test_case_1),
6479 TEST_CASE_ST(ut_setup, ut_teardown,
6480 test_zuc_encryption_test_case_2),
6481 TEST_CASE_ST(ut_setup, ut_teardown,
6482 test_zuc_encryption_test_case_3),
6483 TEST_CASE_ST(ut_setup, ut_teardown,
6484 test_zuc_encryption_test_case_4),
6485 TEST_CASE_ST(ut_setup, ut_teardown,
6486 test_zuc_encryption_test_case_5),
6487 TEST_CASE_ST(ut_setup, ut_teardown,
6488 test_zuc_hash_generate_test_case_1),
6489 TEST_CASE_ST(ut_setup, ut_teardown,
6490 test_zuc_hash_generate_test_case_2),
6491 TEST_CASE_ST(ut_setup, ut_teardown,
6492 test_zuc_hash_generate_test_case_3),
6493 TEST_CASE_ST(ut_setup, ut_teardown,
6494 test_zuc_hash_generate_test_case_4),
6495 TEST_CASE_ST(ut_setup, ut_teardown,
6496 test_zuc_hash_generate_test_case_5),
6497 TEST_CASES_END() /**< NULL terminate unit test array */
6501 static struct unit_test_suite cryptodev_null_testsuite = {
6502 .suite_name = "Crypto Device NULL Unit Test Suite",
6503 .setup = testsuite_setup,
6504 .teardown = testsuite_teardown,
6505 .unit_test_cases = {
6506 TEST_CASE_ST(ut_setup, ut_teardown,
6507 test_null_auth_only_operation),
6508 TEST_CASE_ST(ut_setup, ut_teardown,
6509 test_null_cipher_only_operation),
6510 TEST_CASE_ST(ut_setup, ut_teardown,
6511 test_null_cipher_auth_operation),
6512 TEST_CASE_ST(ut_setup, ut_teardown,
6513 test_null_auth_cipher_operation),
6514 TEST_CASE_ST(ut_setup, ut_teardown,
6515 test_null_invalid_operation),
6516 TEST_CASE_ST(ut_setup, ut_teardown,
6517 test_null_burst_operation),
6519 TEST_CASES_END() /**< NULL terminate unit test array */
6524 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
6526 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
6527 return unit_test_suite_runner(&cryptodev_qat_testsuite);
6531 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
6533 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
6535 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
6539 test_cryptodev_openssl(void)
6541 gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
6543 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
6547 test_cryptodev_aesni_gcm(void)
6549 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
6551 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
6555 test_cryptodev_null(void)
6557 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
6559 return unit_test_suite_runner(&cryptodev_null_testsuite);
6563 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
6565 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
6567 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
6571 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
6573 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
6575 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
6579 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
6581 gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
6583 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
6586 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
6587 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
6588 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
6589 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
6590 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
6591 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
6592 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
6593 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);