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_aes.h"
47 #include "test_cryptodev_kasumi_test_vectors.h"
48 #include "test_cryptodev_kasumi_hash_test_vectors.h"
49 #include "test_cryptodev_snow3g_test_vectors.h"
50 #include "test_cryptodev_snow3g_hash_test_vectors.h"
51 #include "test_cryptodev_gcm_test_vectors.h"
52 #include "test_cryptodev_hmac_test_vectors.h"
54 static enum rte_cryptodev_type gbl_cryptodev_type;
56 struct crypto_testsuite_params {
57 struct rte_mempool *mbuf_pool;
58 struct rte_mempool *op_mpool;
59 struct rte_cryptodev_config conf;
60 struct rte_cryptodev_qp_conf qp_conf;
62 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
63 uint8_t valid_dev_count;
66 struct crypto_unittest_params {
67 struct rte_crypto_sym_xform cipher_xform;
68 struct rte_crypto_sym_xform auth_xform;
70 struct rte_cryptodev_sym_session *sess;
72 struct rte_crypto_op *op;
74 struct rte_mbuf *obuf, *ibuf;
79 #define ALIGN_POW2_ROUNDUP(num, align) \
80 (((num) + (align) - 1) & ~((align) - 1))
83 * Forward declarations.
86 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
87 struct crypto_unittest_params *ut_params);
90 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
91 struct crypto_unittest_params *ut_params,
92 struct crypto_testsuite_params *ts_param);
94 static struct rte_mbuf *
95 setup_test_string(struct rte_mempool *mpool,
96 const char *string, size_t len, uint8_t blocksize)
98 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
99 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
101 memset(m->buf_addr, 0, m->buf_len);
103 char *dst = rte_pktmbuf_append(m, t_len);
110 rte_memcpy(dst, string, t_len);
112 memset(dst, 0, t_len);
118 /* Get number of bytes in X bits (rounding up) */
120 ceil_byte_length(uint32_t num_bits)
123 return ((num_bits >> 3) + 1);
125 return (num_bits >> 3);
128 static struct rte_crypto_op *
129 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
131 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
132 printf("Error sending packet for encryption");
138 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
144 static struct crypto_testsuite_params testsuite_params = { NULL };
145 static struct crypto_unittest_params unittest_params;
148 testsuite_setup(void)
150 struct crypto_testsuite_params *ts_params = &testsuite_params;
151 struct rte_cryptodev_info info;
152 unsigned i, nb_devs, dev_id;
156 memset(ts_params, 0, sizeof(*ts_params));
158 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
159 if (ts_params->mbuf_pool == NULL) {
160 /* Not already created so create */
161 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
163 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
165 if (ts_params->mbuf_pool == NULL) {
166 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
171 ts_params->op_mpool = rte_crypto_op_pool_create(
172 "MBUF_CRYPTO_SYM_OP_POOL",
173 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
174 NUM_MBUFS, MBUF_CACHE_SIZE,
176 sizeof(struct rte_crypto_sym_xform),
178 if (ts_params->op_mpool == NULL) {
179 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
183 /* Create 2 AESNI MB devices if required */
184 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
185 nb_devs = rte_cryptodev_count_devtype(
186 RTE_CRYPTODEV_AESNI_MB_PMD);
188 for (i = nb_devs; i < 2; i++) {
189 ret = rte_eal_vdev_init(
190 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
192 TEST_ASSERT(ret == 0,
193 "Failed to create instance %u of"
195 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
200 /* Create 2 AESNI GCM devices if required */
201 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
202 nb_devs = rte_cryptodev_count_devtype(
203 RTE_CRYPTODEV_AESNI_GCM_PMD);
205 for (i = nb_devs; i < 2; i++) {
206 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
207 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
208 "Failed to create instance %u of"
210 i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
215 /* Create 2 Snow3G devices if required */
216 if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
217 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
219 for (i = nb_devs; i < 2; i++) {
220 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
221 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
222 "Failed to create instance %u of"
224 i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
229 /* Create 2 KASUMI devices if required */
230 if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
231 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
233 for (i = nb_devs; i < 2; i++) {
234 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
235 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
236 "Failed to create instance %u of"
238 i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
243 /* Create 2 NULL devices if required */
244 if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
245 nb_devs = rte_cryptodev_count_devtype(
246 RTE_CRYPTODEV_NULL_PMD);
248 for (i = nb_devs; i < 2; i++) {
249 int dev_id = rte_eal_vdev_init(
250 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
252 TEST_ASSERT(dev_id >= 0,
253 "Failed to create instance %u of"
255 i, RTE_STR(CRYPTODEV_NAME_NULL_PMD));
260 nb_devs = rte_cryptodev_count();
262 RTE_LOG(ERR, USER1, "No crypto devices found?");
266 /* Create list of valid crypto devs */
267 for (i = 0; i < nb_devs; i++) {
268 rte_cryptodev_info_get(i, &info);
269 if (info.dev_type == gbl_cryptodev_type)
270 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
273 if (ts_params->valid_dev_count < 1)
276 /* Set up all the qps on the first of the valid devices found */
277 for (i = 0; i < 1; i++) {
278 dev_id = ts_params->valid_devs[i];
280 rte_cryptodev_info_get(dev_id, &info);
283 * Since we can't free and re-allocate queue memory always set
284 * the queues on this device up to max size first so enough
285 * memory is allocated for any later re-configures needed by
289 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
290 ts_params->conf.socket_id = SOCKET_ID_ANY;
291 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
293 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
295 "Failed to configure cryptodev %u with %u qps",
296 dev_id, ts_params->conf.nb_queue_pairs);
298 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
300 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
301 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
302 dev_id, qp_id, &ts_params->qp_conf,
303 rte_cryptodev_socket_id(dev_id)),
304 "Failed to setup queue pair %u on "
314 testsuite_teardown(void)
316 struct crypto_testsuite_params *ts_params = &testsuite_params;
318 if (ts_params->mbuf_pool != NULL) {
319 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
320 rte_mempool_avail_count(ts_params->mbuf_pool));
323 if (ts_params->op_mpool != NULL) {
324 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
325 rte_mempool_avail_count(ts_params->op_mpool));
333 struct crypto_testsuite_params *ts_params = &testsuite_params;
334 struct crypto_unittest_params *ut_params = &unittest_params;
338 /* Clear unit test parameters before running test */
339 memset(ut_params, 0, sizeof(*ut_params));
341 /* Reconfigure device to default parameters */
342 ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE;
343 ts_params->conf.socket_id = SOCKET_ID_ANY;
344 ts_params->conf.session_mp.nb_objs =
345 (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) ?
346 DEFAULT_NUM_OPS_INFLIGHT :
347 DEFAULT_NUM_OPS_INFLIGHT;
349 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
351 "Failed to configure cryptodev %u",
352 ts_params->valid_devs[0]);
355 * Now reconfigure queues to size we actually want to use in this
358 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
360 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
361 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
362 ts_params->valid_devs[0], qp_id,
364 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
365 "Failed to setup queue pair %u on cryptodev %u",
366 qp_id, ts_params->valid_devs[0]);
370 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
372 /* Start the device */
373 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
374 "Failed to start cryptodev %u",
375 ts_params->valid_devs[0]);
383 struct crypto_testsuite_params *ts_params = &testsuite_params;
384 struct crypto_unittest_params *ut_params = &unittest_params;
385 struct rte_cryptodev_stats stats;
387 /* free crypto session structure */
388 if (ut_params->sess) {
389 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
391 ut_params->sess = NULL;
394 /* free crypto operation structure */
396 rte_crypto_op_free(ut_params->op);
399 * free mbuf - both obuf and ibuf are usually the same,
400 * so check if they point at the same address is necessary,
401 * to avoid freeing the mbuf twice.
403 if (ut_params->obuf) {
404 rte_pktmbuf_free(ut_params->obuf);
405 if (ut_params->ibuf == ut_params->obuf)
409 if (ut_params->ibuf) {
410 rte_pktmbuf_free(ut_params->ibuf);
414 if (ts_params->mbuf_pool != NULL)
415 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
416 rte_mempool_avail_count(ts_params->mbuf_pool));
418 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
420 /* Stop the device */
421 rte_cryptodev_stop(ts_params->valid_devs[0]);
425 test_device_configure_invalid_dev_id(void)
427 struct crypto_testsuite_params *ts_params = &testsuite_params;
428 uint16_t dev_id, num_devs = 0;
430 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
431 "Need at least %d devices for test", 1);
433 /* valid dev_id values */
434 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
436 /* Stop the device in case it's started so it can be configured */
437 rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
439 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
440 "Failed test for rte_cryptodev_configure: "
441 "invalid dev_num %u", dev_id);
443 /* invalid dev_id values */
446 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
447 "Failed test for rte_cryptodev_configure: "
448 "invalid dev_num %u", dev_id);
452 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
453 "Failed test for rte_cryptodev_configure:"
454 "invalid dev_num %u", dev_id);
460 test_device_configure_invalid_queue_pair_ids(void)
462 struct crypto_testsuite_params *ts_params = &testsuite_params;
464 /* Stop the device in case it's started so it can be configured */
465 rte_cryptodev_stop(ts_params->valid_devs[0]);
467 /* valid - one queue pairs */
468 ts_params->conf.nb_queue_pairs = 1;
470 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
472 "Failed to configure cryptodev: dev_id %u, qp_id %u",
473 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
476 /* valid - max value queue pairs */
477 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
479 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
481 "Failed to configure cryptodev: dev_id %u, qp_id %u",
482 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
485 /* invalid - zero queue pairs */
486 ts_params->conf.nb_queue_pairs = 0;
488 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
490 "Failed test for rte_cryptodev_configure, dev_id %u,"
492 ts_params->valid_devs[0],
493 ts_params->conf.nb_queue_pairs);
496 /* invalid - max value supported by field queue pairs */
497 ts_params->conf.nb_queue_pairs = UINT16_MAX;
499 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
501 "Failed test for rte_cryptodev_configure, dev_id %u,"
503 ts_params->valid_devs[0],
504 ts_params->conf.nb_queue_pairs);
507 /* invalid - max value + 1 queue pairs */
508 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
510 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
512 "Failed test for rte_cryptodev_configure, dev_id %u,"
514 ts_params->valid_devs[0],
515 ts_params->conf.nb_queue_pairs);
521 test_queue_pair_descriptor_setup(void)
523 struct crypto_testsuite_params *ts_params = &testsuite_params;
524 struct rte_cryptodev_info dev_info;
525 struct rte_cryptodev_qp_conf qp_conf = {
526 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
531 /* Stop the device in case it's started so it can be configured */
532 rte_cryptodev_stop(ts_params->valid_devs[0]);
535 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
537 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
539 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
540 &ts_params->conf), "Failed to configure cryptodev %u",
541 ts_params->valid_devs[0]);
545 * Test various ring sizes on this device. memzones can't be
546 * freed so are re-used if ring is released and re-created.
548 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
550 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
551 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
552 ts_params->valid_devs[0], qp_id, &qp_conf,
553 rte_cryptodev_socket_id(
554 ts_params->valid_devs[0])),
556 "rte_cryptodev_queue_pair_setup: num_inflights "
557 "%u on qp %u on cryptodev %u",
558 qp_conf.nb_descriptors, qp_id,
559 ts_params->valid_devs[0]);
562 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
564 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
565 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
566 ts_params->valid_devs[0], qp_id, &qp_conf,
567 rte_cryptodev_socket_id(
568 ts_params->valid_devs[0])),
570 " rte_cryptodev_queue_pair_setup: num_inflights"
571 " %u on qp %u on cryptodev %u",
572 qp_conf.nb_descriptors, qp_id,
573 ts_params->valid_devs[0]);
576 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
578 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
579 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
580 ts_params->valid_devs[0], qp_id, &qp_conf,
581 rte_cryptodev_socket_id(
582 ts_params->valid_devs[0])),
584 "rte_cryptodev_queue_pair_setup: num_inflights"
585 " %u on qp %u on cryptodev %u",
586 qp_conf.nb_descriptors, qp_id,
587 ts_params->valid_devs[0]);
590 /* invalid number of descriptors - max supported + 2 */
591 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
593 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
594 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
595 ts_params->valid_devs[0], qp_id, &qp_conf,
596 rte_cryptodev_socket_id(
597 ts_params->valid_devs[0])),
598 "Unexpectedly passed test for "
599 "rte_cryptodev_queue_pair_setup:"
600 "num_inflights %u on qp %u on cryptodev %u",
601 qp_conf.nb_descriptors, qp_id,
602 ts_params->valid_devs[0]);
605 /* invalid number of descriptors - max value of parameter */
606 qp_conf.nb_descriptors = UINT32_MAX-1;
608 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
609 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
610 ts_params->valid_devs[0], qp_id, &qp_conf,
611 rte_cryptodev_socket_id(
612 ts_params->valid_devs[0])),
613 "Unexpectedly passed test for "
614 "rte_cryptodev_queue_pair_setup:"
615 "num_inflights %u on qp %u on cryptodev %u",
616 qp_conf.nb_descriptors, qp_id,
617 ts_params->valid_devs[0]);
620 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
622 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
623 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
624 ts_params->valid_devs[0], qp_id, &qp_conf,
625 rte_cryptodev_socket_id(
626 ts_params->valid_devs[0])),
628 " rte_cryptodev_queue_pair_setup:"
629 "num_inflights %u on qp %u on cryptodev %u",
630 qp_conf.nb_descriptors, qp_id,
631 ts_params->valid_devs[0]);
634 /* invalid number of descriptors - max supported + 1 */
635 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
637 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
638 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
639 ts_params->valid_devs[0], qp_id, &qp_conf,
640 rte_cryptodev_socket_id(
641 ts_params->valid_devs[0])),
642 "Unexpectedly passed test for "
643 "rte_cryptodev_queue_pair_setup:"
644 "num_inflights %u on qp %u on cryptodev %u",
645 qp_conf.nb_descriptors, qp_id,
646 ts_params->valid_devs[0]);
649 /* test invalid queue pair id */
650 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
652 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */
654 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
655 ts_params->valid_devs[0],
657 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
658 "Failed test for rte_cryptodev_queue_pair_setup:"
659 "invalid qp %u on cryptodev %u",
660 qp_id, ts_params->valid_devs[0]);
662 qp_id = 0xffff; /*invalid*/
664 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
665 ts_params->valid_devs[0],
667 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
668 "Failed test for rte_cryptodev_queue_pair_setup:"
669 "invalid qp %u on cryptodev %u",
670 qp_id, ts_params->valid_devs[0]);
675 /* ***** Plaintext data for tests ***** */
677 const char catch_22_quote_1[] =
678 "There was only one catch and that was Catch-22, which "
679 "specified that a concern for one's safety in the face of "
680 "dangers that were real and immediate was the process of a "
681 "rational mind. Orr was crazy and could be grounded. All he "
682 "had to do was ask; and as soon as he did, he would no longer "
683 "be crazy and would have to fly more missions. Orr would be "
684 "crazy to fly more missions and sane if he didn't, but if he "
685 "was sane he had to fly them. If he flew them he was crazy "
686 "and didn't have to; but if he didn't want to he was sane and "
687 "had to. Yossarian was moved very deeply by the absolute "
688 "simplicity of this clause of Catch-22 and let out a "
689 "respectful whistle. \"That's some catch, that Catch-22\", he "
690 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
692 const char catch_22_quote[] =
693 "What a lousy earth! He wondered how many people were "
694 "destitute that same night even in his own prosperous country, "
695 "how many homes were shanties, how many husbands were drunk "
696 "and wives socked, and how many children were bullied, abused, "
697 "or abandoned. How many families hungered for food they could "
698 "not afford to buy? How many hearts were broken? How many "
699 "suicides would take place that same night, how many people "
700 "would go insane? How many cockroaches and landlords would "
701 "triumph? How many winners were losers, successes failures, "
702 "and rich men poor men? How many wise guys were stupid? How "
703 "many happy endings were unhappy endings? How many honest men "
704 "were liars, brave men cowards, loyal men traitors, how many "
705 "sainted men were corrupt, how many people in positions of "
706 "trust had sold their souls to bodyguards, how many had never "
707 "had souls? How many straight-and-narrow paths were crooked "
708 "paths? How many best families were worst families and how "
709 "many good people were bad people? When you added them all up "
710 "and then subtracted, you might be left with only the children, "
711 "and perhaps with Albert Einstein and an old violinist or "
712 "sculptor somewhere.";
714 #define QUOTE_480_BYTES (480)
715 #define QUOTE_512_BYTES (512)
716 #define QUOTE_768_BYTES (768)
717 #define QUOTE_1024_BYTES (1024)
721 /* ***** SHA1 Hash Tests ***** */
723 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
725 static uint8_t hmac_sha1_key[] = {
726 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
727 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
728 0xDE, 0xF4, 0xDE, 0xAD };
730 /* ***** SHA224 Hash Tests ***** */
732 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
735 /* ***** AES-CBC Cipher Tests ***** */
737 #define CIPHER_KEY_LENGTH_AES_CBC (16)
738 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
740 static uint8_t aes_cbc_key[] = {
741 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
742 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
744 static uint8_t aes_cbc_iv[] = {
745 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
746 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
749 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
751 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
752 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
753 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
754 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
755 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
756 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
757 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
758 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
759 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
760 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
761 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
762 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
763 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
764 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
765 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
766 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
767 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
768 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
769 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
770 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
771 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
772 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
773 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
774 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
775 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
776 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
777 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
778 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
779 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
780 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
781 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
782 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
783 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
784 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
785 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
786 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
787 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
788 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
789 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
790 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
791 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
792 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
793 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
794 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
795 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
796 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
797 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
798 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
799 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
800 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
801 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
802 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
803 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
804 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
805 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
806 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
807 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
808 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
809 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
810 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
811 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
812 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
813 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
814 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
815 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
818 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
819 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
820 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
821 0x18, 0x8c, 0x1d, 0x32
826 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
828 struct crypto_testsuite_params *ts_params = &testsuite_params;
829 struct crypto_unittest_params *ut_params = &unittest_params;
831 /* Generate test mbuf data and space for digest */
832 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
833 catch_22_quote, QUOTE_512_BYTES, 0);
835 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
836 DIGEST_BYTE_LENGTH_SHA1);
837 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
839 /* Setup Cipher Parameters */
840 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
841 ut_params->cipher_xform.next = &ut_params->auth_xform;
843 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
844 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
845 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
846 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
848 /* Setup HMAC Parameters */
849 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
851 ut_params->auth_xform.next = NULL;
853 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
854 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
855 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
856 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
857 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
859 /* Create crypto session*/
860 ut_params->sess = rte_cryptodev_sym_session_create(
861 ts_params->valid_devs[0],
862 &ut_params->cipher_xform);
863 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
865 /* Generate crypto op data structure */
866 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
867 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
868 TEST_ASSERT_NOT_NULL(ut_params->op,
869 "Failed to allocate symmetric crypto operation struct");
871 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
873 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
875 /* set crypto operation source mbuf */
876 sym_op->m_src = ut_params->ibuf;
878 /* Set crypto operation authentication parameters */
879 sym_op->auth.digest.data = ut_params->digest;
880 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
881 ut_params->ibuf, QUOTE_512_BYTES);
882 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
884 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
885 sym_op->auth.data.length = QUOTE_512_BYTES;
887 /* Set crypto operation cipher parameters */
888 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
889 CIPHER_IV_LENGTH_AES_CBC);
890 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
891 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
893 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
894 CIPHER_IV_LENGTH_AES_CBC);
896 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
897 sym_op->cipher.data.length = QUOTE_512_BYTES;
899 /* Process crypto operation */
900 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
901 ut_params->op), "failed to process sym crypto op");
903 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
904 "crypto op processing failed");
907 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
908 uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
910 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
911 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
913 "ciphertext data not as expected");
915 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
917 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
918 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
919 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
920 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
921 DIGEST_BYTE_LENGTH_SHA1,
922 "Generated digest data not as expected");
927 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
929 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
931 static uint8_t hmac_sha512_key[] = {
932 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
933 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
934 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
935 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
936 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
937 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
938 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
939 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
941 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
942 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
943 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
944 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
945 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
946 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
947 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
948 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
949 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
954 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
955 struct crypto_unittest_params *ut_params);
958 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
959 struct crypto_unittest_params *ut_params,
960 struct crypto_testsuite_params *ts_params);
964 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
965 struct crypto_unittest_params *ut_params)
968 /* Setup Cipher Parameters */
969 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
970 ut_params->cipher_xform.next = NULL;
972 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
973 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
974 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
975 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
977 /* Setup HMAC Parameters */
978 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
979 ut_params->auth_xform.next = &ut_params->cipher_xform;
981 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
982 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
983 ut_params->auth_xform.auth.key.data = hmac_sha512_key;
984 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
985 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
992 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
993 struct crypto_unittest_params *ut_params,
994 struct crypto_testsuite_params *ts_params)
996 /* Generate test mbuf data and digest */
997 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
999 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1000 QUOTE_512_BYTES, 0);
1002 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1003 DIGEST_BYTE_LENGTH_SHA512);
1004 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1006 rte_memcpy(ut_params->digest,
1007 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1008 DIGEST_BYTE_LENGTH_SHA512);
1010 /* Generate Crypto op data structure */
1011 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1012 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1013 TEST_ASSERT_NOT_NULL(ut_params->op,
1014 "Failed to allocate symmetric crypto operation struct");
1016 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1018 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1020 /* set crypto operation source mbuf */
1021 sym_op->m_src = ut_params->ibuf;
1023 sym_op->auth.digest.data = ut_params->digest;
1024 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1025 ut_params->ibuf, QUOTE_512_BYTES);
1026 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1028 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1029 sym_op->auth.data.length = QUOTE_512_BYTES;
1031 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1032 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1033 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1034 ut_params->ibuf, 0);
1035 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1037 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1038 CIPHER_IV_LENGTH_AES_CBC);
1040 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1041 sym_op->cipher.data.length = QUOTE_512_BYTES;
1043 /* Process crypto operation */
1044 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1045 ut_params->op), "failed to process sym crypto op");
1047 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1048 "crypto op processing failed");
1050 ut_params->obuf = ut_params->op->sym->m_src;
1053 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1054 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1055 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1057 "Plaintext data not as expected");
1060 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1061 "Digest verification failed");
1063 return TEST_SUCCESS;
1067 test_AES_mb_all(void)
1069 struct crypto_testsuite_params *ts_params = &testsuite_params;
1072 status = test_AES_all_tests(ts_params->mbuf_pool,
1073 ts_params->op_mpool, ts_params->valid_devs[0],
1074 RTE_CRYPTODEV_AESNI_MB_PMD);
1076 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1078 return TEST_SUCCESS;
1082 test_AES_qat_all(void)
1084 struct crypto_testsuite_params *ts_params = &testsuite_params;
1087 status = test_AES_all_tests(ts_params->mbuf_pool,
1088 ts_params->op_mpool, ts_params->valid_devs[0],
1089 RTE_CRYPTODEV_QAT_SYM_PMD);
1091 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1093 return TEST_SUCCESS;
1096 /* ***** Snow3G Tests ***** */
1098 create_snow3g_kasumi_hash_session(uint8_t dev_id,
1099 const uint8_t *key, const uint8_t key_len,
1100 const uint8_t aad_len, const uint8_t auth_len,
1101 enum rte_crypto_auth_operation op,
1102 enum rte_crypto_auth_algorithm algo)
1104 uint8_t hash_key[key_len];
1106 struct crypto_unittest_params *ut_params = &unittest_params;
1108 memcpy(hash_key, key, key_len);
1110 TEST_HEXDUMP(stdout, "key:", key, key_len);
1112 /* Setup Authentication Parameters */
1113 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1114 ut_params->auth_xform.next = NULL;
1116 ut_params->auth_xform.auth.op = op;
1117 ut_params->auth_xform.auth.algo = algo;
1118 ut_params->auth_xform.auth.key.length = key_len;
1119 ut_params->auth_xform.auth.key.data = hash_key;
1120 ut_params->auth_xform.auth.digest_length = auth_len;
1121 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1122 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1123 &ut_params->auth_xform);
1124 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1129 create_snow3g_kasumi_cipher_session(uint8_t dev_id,
1130 enum rte_crypto_cipher_operation op,
1131 enum rte_crypto_cipher_algorithm algo,
1132 const uint8_t *key, const uint8_t key_len)
1134 uint8_t cipher_key[key_len];
1136 struct crypto_unittest_params *ut_params = &unittest_params;
1138 memcpy(cipher_key, key, key_len);
1140 /* Setup Cipher Parameters */
1141 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1142 ut_params->cipher_xform.next = NULL;
1144 ut_params->cipher_xform.cipher.algo = algo;
1145 ut_params->cipher_xform.cipher.op = op;
1146 ut_params->cipher_xform.cipher.key.data = cipher_key;
1147 ut_params->cipher_xform.cipher.key.length = key_len;
1149 TEST_HEXDUMP(stdout, "key:", key, key_len);
1151 /* Create Crypto session */
1152 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1155 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1160 create_snow3g_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1161 const unsigned cipher_len,
1162 const unsigned cipher_offset,
1163 enum rte_crypto_cipher_algorithm algo)
1165 struct crypto_testsuite_params *ts_params = &testsuite_params;
1166 struct crypto_unittest_params *ut_params = &unittest_params;
1167 unsigned iv_pad_len = 0;
1169 /* Generate Crypto op data structure */
1170 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1171 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1172 TEST_ASSERT_NOT_NULL(ut_params->op,
1173 "Failed to allocate pktmbuf offload");
1175 /* Set crypto operation data parameters */
1176 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1178 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1180 /* set crypto operation source mbuf */
1181 sym_op->m_src = ut_params->ibuf;
1184 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1185 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1187 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1189 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1192 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1194 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1195 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1196 sym_op->cipher.iv.length = iv_pad_len;
1198 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1199 sym_op->cipher.data.length = cipher_len;
1200 sym_op->cipher.data.offset = cipher_offset;
1205 create_snow3g_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1206 const unsigned cipher_len,
1207 const unsigned cipher_offset,
1208 enum rte_crypto_cipher_algorithm algo)
1210 struct crypto_testsuite_params *ts_params = &testsuite_params;
1211 struct crypto_unittest_params *ut_params = &unittest_params;
1212 unsigned iv_pad_len = 0;
1214 /* Generate Crypto op data structure */
1215 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1216 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1217 TEST_ASSERT_NOT_NULL(ut_params->op,
1218 "Failed to allocate pktmbuf offload");
1220 /* Set crypto operation data parameters */
1221 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1223 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1225 /* set crypto operation source mbuf */
1226 sym_op->m_src = ut_params->ibuf;
1227 sym_op->m_dst = ut_params->obuf;
1230 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1231 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1233 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1234 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1237 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1239 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1240 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1241 sym_op->cipher.iv.length = iv_pad_len;
1243 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1244 sym_op->cipher.data.length = cipher_len;
1245 sym_op->cipher.data.offset = cipher_offset;
1250 create_snow3g_kasumi_cipher_auth_session(uint8_t dev_id,
1251 enum rte_crypto_cipher_operation cipher_op,
1252 enum rte_crypto_auth_operation auth_op,
1253 enum rte_crypto_auth_algorithm auth_algo,
1254 enum rte_crypto_cipher_algorithm cipher_algo,
1255 const uint8_t *key, const uint8_t key_len,
1256 const uint8_t aad_len, const uint8_t auth_len)
1259 uint8_t cipher_auth_key[key_len];
1261 struct crypto_unittest_params *ut_params = &unittest_params;
1263 memcpy(cipher_auth_key, key, key_len);
1265 /* Setup Authentication Parameters */
1266 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1267 ut_params->auth_xform.next = NULL;
1269 ut_params->auth_xform.auth.op = auth_op;
1270 ut_params->auth_xform.auth.algo = auth_algo;
1271 ut_params->auth_xform.auth.key.length = key_len;
1272 /* Hash key = cipher key */
1273 ut_params->auth_xform.auth.key.data = cipher_auth_key;
1274 ut_params->auth_xform.auth.digest_length = auth_len;
1275 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1277 /* Setup Cipher Parameters */
1278 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1279 ut_params->cipher_xform.next = &ut_params->auth_xform;
1281 ut_params->cipher_xform.cipher.algo = cipher_algo;
1282 ut_params->cipher_xform.cipher.op = cipher_op;
1283 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1284 ut_params->cipher_xform.cipher.key.length = key_len;
1286 TEST_HEXDUMP(stdout, "key:", key, key_len);
1288 /* Create Crypto session*/
1289 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1290 &ut_params->cipher_xform);
1292 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1297 create_snow3g_kasumi_auth_cipher_session(uint8_t dev_id,
1298 enum rte_crypto_cipher_operation cipher_op,
1299 enum rte_crypto_auth_operation auth_op,
1300 enum rte_crypto_auth_algorithm auth_algo,
1301 enum rte_crypto_cipher_algorithm cipher_algo,
1302 const uint8_t *key, const uint8_t key_len,
1303 const uint8_t aad_len, const uint8_t auth_len)
1305 uint8_t auth_cipher_key[key_len];
1307 struct crypto_unittest_params *ut_params = &unittest_params;
1309 memcpy(auth_cipher_key, key, key_len);
1311 /* Setup Authentication Parameters */
1312 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1313 ut_params->auth_xform.auth.op = auth_op;
1314 ut_params->auth_xform.next = &ut_params->cipher_xform;
1315 ut_params->auth_xform.auth.algo = auth_algo;
1316 ut_params->auth_xform.auth.key.length = key_len;
1317 ut_params->auth_xform.auth.key.data = auth_cipher_key;
1318 ut_params->auth_xform.auth.digest_length = auth_len;
1319 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1321 /* Setup Cipher Parameters */
1322 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1323 ut_params->cipher_xform.next = NULL;
1324 ut_params->cipher_xform.cipher.algo = cipher_algo;
1325 ut_params->cipher_xform.cipher.op = cipher_op;
1326 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
1327 ut_params->cipher_xform.cipher.key.length = key_len;
1329 TEST_HEXDUMP(stdout, "key:", key, key_len);
1331 /* Create Crypto session*/
1332 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1333 &ut_params->auth_xform);
1335 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1341 create_snow3g_kasumi_hash_operation(const uint8_t *auth_tag,
1342 const unsigned auth_tag_len,
1343 const uint8_t *aad, const unsigned aad_len,
1344 unsigned data_pad_len,
1345 enum rte_crypto_auth_operation op,
1346 enum rte_crypto_auth_algorithm algo,
1347 const unsigned auth_len, const unsigned auth_offset)
1349 struct crypto_testsuite_params *ts_params = &testsuite_params;
1351 struct crypto_unittest_params *ut_params = &unittest_params;
1353 unsigned aad_buffer_len;
1355 /* Generate Crypto op data structure */
1356 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1357 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1358 TEST_ASSERT_NOT_NULL(ut_params->op,
1359 "Failed to allocate pktmbuf offload");
1361 /* Set crypto operation data parameters */
1362 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1364 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1366 /* set crypto operation source mbuf */
1367 sym_op->m_src = ut_params->ibuf;
1371 * Always allocate the aad up to the block size.
1372 * The cryptodev API calls out -
1373 * - the array must be big enough to hold the AAD, plus any
1374 * space to round this up to the nearest multiple of the
1375 * block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
1377 if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1378 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1380 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1381 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1382 ut_params->ibuf, aad_buffer_len);
1383 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1384 "no room to prepend aad");
1385 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1387 sym_op->auth.aad.length = aad_len;
1389 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1390 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1392 TEST_HEXDUMP(stdout, "aad:",
1393 sym_op->auth.aad.data, aad_len);
1396 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1397 ut_params->ibuf, auth_tag_len);
1399 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1400 "no room to append auth tag");
1401 ut_params->digest = sym_op->auth.digest.data;
1402 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1403 ut_params->ibuf, data_pad_len + aad_len);
1404 sym_op->auth.digest.length = auth_tag_len;
1405 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1406 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1408 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1410 TEST_HEXDUMP(stdout, "digest:",
1411 sym_op->auth.digest.data,
1412 sym_op->auth.digest.length);
1414 sym_op->auth.data.length = auth_len;
1415 sym_op->auth.data.offset = auth_offset;
1421 create_snow3g_kasumi_cipher_hash_operation(const uint8_t *auth_tag,
1422 const unsigned auth_tag_len,
1423 const uint8_t *aad, const uint8_t aad_len,
1424 unsigned data_pad_len,
1425 enum rte_crypto_auth_operation op,
1426 enum rte_crypto_auth_algorithm auth_algo,
1427 enum rte_crypto_cipher_algorithm cipher_algo,
1428 const uint8_t *iv, const uint8_t iv_len,
1429 const unsigned cipher_len, const unsigned cipher_offset,
1430 const unsigned auth_len, const unsigned auth_offset)
1432 struct crypto_testsuite_params *ts_params = &testsuite_params;
1433 struct crypto_unittest_params *ut_params = &unittest_params;
1435 unsigned iv_pad_len = 0;
1436 unsigned aad_buffer_len;
1438 /* Generate Crypto op data structure */
1439 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1440 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1441 TEST_ASSERT_NOT_NULL(ut_params->op,
1442 "Failed to allocate pktmbuf offload");
1443 /* Set crypto operation data parameters */
1444 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1446 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1448 /* set crypto operation source mbuf */
1449 sym_op->m_src = ut_params->ibuf;
1452 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1453 ut_params->ibuf, auth_tag_len);
1455 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1456 "no room to append auth tag");
1457 ut_params->digest = sym_op->auth.digest.data;
1458 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1459 ut_params->ibuf, data_pad_len);
1460 sym_op->auth.digest.length = auth_tag_len;
1461 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1462 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1464 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1466 TEST_HEXDUMP(stdout, "digest:",
1467 sym_op->auth.digest.data,
1468 sym_op->auth.digest.length);
1472 * Always allocate the aad up to the block size.
1473 * The cryptodev API calls out -
1474 * - the array must be big enough to hold the AAD, plus any
1475 * space to round this up to the nearest multiple of the
1476 * block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
1478 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1479 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1481 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1482 sym_op->auth.aad.data =
1483 (uint8_t *)rte_pktmbuf_prepend(
1484 ut_params->ibuf, aad_buffer_len);
1485 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1486 "no room to prepend aad");
1487 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1489 sym_op->auth.aad.length = aad_len;
1490 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1491 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1492 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
1495 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1496 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1498 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1499 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1500 ut_params->ibuf, iv_pad_len);
1502 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1503 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1504 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1505 sym_op->cipher.iv.length = iv_pad_len;
1506 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1507 sym_op->cipher.data.length = cipher_len;
1508 sym_op->cipher.data.offset = cipher_offset + auth_offset;
1509 sym_op->auth.data.length = auth_len;
1510 sym_op->auth.data.offset = auth_offset + cipher_offset;
1516 create_snow3g_kasumi_auth_cipher_operation(const unsigned auth_tag_len,
1517 const uint8_t *iv, const uint8_t iv_len,
1518 const uint8_t *aad, const uint8_t aad_len,
1519 unsigned data_pad_len,
1520 const unsigned cipher_len, const unsigned cipher_offset,
1521 const unsigned auth_len, const unsigned auth_offset,
1522 enum rte_crypto_auth_algorithm auth_algo,
1523 enum rte_crypto_cipher_algorithm cipher_algo)
1525 struct crypto_testsuite_params *ts_params = &testsuite_params;
1526 struct crypto_unittest_params *ut_params = &unittest_params;
1528 unsigned iv_pad_len = 0;
1529 unsigned aad_buffer_len = 0;
1531 /* Generate Crypto op data structure */
1532 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1533 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1534 TEST_ASSERT_NOT_NULL(ut_params->op,
1535 "Failed to allocate pktmbuf offload");
1537 /* Set crypto operation data parameters */
1538 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1540 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1542 /* set crypto operation source mbuf */
1543 sym_op->m_src = ut_params->ibuf;
1546 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1547 ut_params->ibuf, auth_tag_len);
1549 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1550 "no room to append auth tag");
1552 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1553 ut_params->ibuf, data_pad_len);
1554 sym_op->auth.digest.length = auth_tag_len;
1556 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1558 TEST_HEXDUMP(stdout, "digest:",
1559 sym_op->auth.digest.data,
1560 sym_op->auth.digest.length);
1564 * Always allocate the aad up to the block size.
1565 * The cryptodev API calls out -
1566 * - the array must be big enough to hold the AAD, plus any
1567 * space to round this up to the nearest multiple of the
1568 * block size (8 bytes for KASUMI 16 bytes).
1570 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1571 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1573 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1574 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1575 ut_params->ibuf, aad_buffer_len);
1576 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1577 "no room to prepend aad");
1578 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1580 sym_op->auth.aad.length = aad_len;
1581 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1582 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1583 TEST_HEXDUMP(stdout, "aad:",
1584 sym_op->auth.aad.data, aad_len);
1587 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1588 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1590 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1592 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1593 ut_params->ibuf, iv_pad_len);
1594 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1596 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1597 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1598 sym_op->cipher.iv.length = iv_pad_len;
1600 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1602 sym_op->cipher.data.length = cipher_len;
1603 sym_op->cipher.data.offset = auth_offset + cipher_offset;
1605 sym_op->auth.data.length = auth_len;
1606 sym_op->auth.data.offset = auth_offset + cipher_offset;
1612 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
1614 struct crypto_testsuite_params *ts_params = &testsuite_params;
1615 struct crypto_unittest_params *ut_params = &unittest_params;
1618 unsigned plaintext_pad_len;
1619 unsigned plaintext_len;
1622 /* Create SNOW3G session */
1623 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1624 tdata->key.data, tdata->key.len,
1625 tdata->aad.len, tdata->digest.len,
1626 RTE_CRYPTO_AUTH_OP_GENERATE,
1627 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
1631 /* alloc mbuf and set payload */
1632 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1634 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1635 rte_pktmbuf_tailroom(ut_params->ibuf));
1637 plaintext_len = ceil_byte_length(tdata->plaintext.len);
1638 /* Append data which is padded to a multiple of */
1639 /* the algorithms block size */
1640 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
1641 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1643 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1645 /* Create SNOW3G operation */
1646 retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
1647 tdata->aad.data, tdata->aad.len,
1648 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
1649 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1650 tdata->validAuthLenInBits.len,
1651 tdata->validAuthOffsetLenInBits.len);
1655 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1657 ut_params->obuf = ut_params->op->sym->m_src;
1658 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1659 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1660 + plaintext_pad_len + tdata->aad.len;
1663 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1666 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
1667 "Snow3G Generated auth tag not as expected");
1673 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
1675 struct crypto_testsuite_params *ts_params = &testsuite_params;
1676 struct crypto_unittest_params *ut_params = &unittest_params;
1679 unsigned plaintext_pad_len;
1680 unsigned plaintext_len;
1683 /* Create SNOW3G session */
1684 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1685 tdata->key.data, tdata->key.len,
1686 tdata->aad.len, tdata->digest.len,
1687 RTE_CRYPTO_AUTH_OP_VERIFY,
1688 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
1691 /* alloc mbuf and set payload */
1692 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1694 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1695 rte_pktmbuf_tailroom(ut_params->ibuf));
1697 plaintext_len = ceil_byte_length(tdata->plaintext.len);
1698 /* Append data which is padded to a multiple of */
1699 /* the algorithms block size */
1700 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
1701 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1703 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1705 /* Create SNOW3G operation */
1706 retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
1708 tdata->aad.data, tdata->aad.len,
1710 RTE_CRYPTO_AUTH_OP_VERIFY,
1711 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1712 tdata->validAuthLenInBits.len,
1713 tdata->validAuthOffsetLenInBits.len);
1717 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1719 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1720 ut_params->obuf = ut_params->op->sym->m_src;
1721 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1722 + plaintext_pad_len + tdata->aad.len;
1725 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
1734 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
1736 struct crypto_testsuite_params *ts_params = &testsuite_params;
1737 struct crypto_unittest_params *ut_params = &unittest_params;
1740 unsigned plaintext_pad_len;
1741 unsigned plaintext_len;
1744 /* Create KASUMI session */
1745 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1746 tdata->key.data, tdata->key.len,
1747 tdata->aad.len, tdata->digest.len,
1748 RTE_CRYPTO_AUTH_OP_GENERATE,
1749 RTE_CRYPTO_AUTH_KASUMI_F9);
1753 /* alloc mbuf and set payload */
1754 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1756 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1757 rte_pktmbuf_tailroom(ut_params->ibuf));
1759 plaintext_len = ceil_byte_length(tdata->plaintext.len);
1760 /* Append data which is padded to a multiple of */
1761 /* the algorithms block size */
1762 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
1763 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1765 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1767 /* Create KASUMI operation */
1768 retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
1769 tdata->aad.data, tdata->aad.len,
1770 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
1771 RTE_CRYPTO_AUTH_KASUMI_F9,
1772 tdata->validAuthLenInBits.len,
1773 tdata->validAuthOffsetLenInBits.len);
1777 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1779 ut_params->obuf = ut_params->op->sym->m_src;
1780 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1781 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1782 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
1785 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1788 DIGEST_BYTE_LENGTH_KASUMI_F9,
1789 "KASUMI Generated auth tag not as expected");
1795 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
1797 struct crypto_testsuite_params *ts_params = &testsuite_params;
1798 struct crypto_unittest_params *ut_params = &unittest_params;
1801 unsigned plaintext_pad_len;
1802 unsigned plaintext_len;
1805 /* Create KASUMI session */
1806 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1807 tdata->key.data, tdata->key.len,
1808 tdata->aad.len, tdata->digest.len,
1809 RTE_CRYPTO_AUTH_OP_VERIFY,
1810 RTE_CRYPTO_AUTH_KASUMI_F9);
1813 /* alloc mbuf and set payload */
1814 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1816 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1817 rte_pktmbuf_tailroom(ut_params->ibuf));
1819 plaintext_len = ceil_byte_length(tdata->plaintext.len);
1820 /* Append data which is padded to a multiple */
1821 /* of the algorithms block size */
1822 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
1823 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1825 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1827 /* Create KASUMI operation */
1828 retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
1830 tdata->aad.data, tdata->aad.len,
1832 RTE_CRYPTO_AUTH_OP_VERIFY,
1833 RTE_CRYPTO_AUTH_KASUMI_F9,
1834 tdata->validAuthLenInBits.len,
1835 tdata->validAuthOffsetLenInBits.len);
1839 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1841 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1842 ut_params->obuf = ut_params->op->sym->m_src;
1843 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1844 + plaintext_pad_len + tdata->aad.len;
1847 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
1856 test_snow3g_hash_generate_test_case_1(void)
1858 return test_snow3g_authentication(&snow3g_hash_test_case_1);
1862 test_snow3g_hash_generate_test_case_2(void)
1864 return test_snow3g_authentication(&snow3g_hash_test_case_2);
1868 test_snow3g_hash_generate_test_case_3(void)
1870 return test_snow3g_authentication(&snow3g_hash_test_case_3);
1874 test_snow3g_hash_generate_test_case_4(void)
1876 return test_snow3g_authentication(&snow3g_hash_test_case_4);
1880 test_snow3g_hash_generate_test_case_5(void)
1882 return test_snow3g_authentication(&snow3g_hash_test_case_5);
1886 test_snow3g_hash_generate_test_case_6(void)
1888 return test_snow3g_authentication(&snow3g_hash_test_case_6);
1892 test_snow3g_hash_verify_test_case_1(void)
1894 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
1899 test_snow3g_hash_verify_test_case_2(void)
1901 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
1905 test_snow3g_hash_verify_test_case_3(void)
1907 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
1911 test_snow3g_hash_verify_test_case_4(void)
1913 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
1917 test_snow3g_hash_verify_test_case_5(void)
1919 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
1923 test_snow3g_hash_verify_test_case_6(void)
1925 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
1929 test_kasumi_hash_generate_test_case_1(void)
1931 return test_kasumi_authentication(&kasumi_hash_test_case_1);
1935 test_kasumi_hash_generate_test_case_2(void)
1937 return test_kasumi_authentication(&kasumi_hash_test_case_2);
1941 test_kasumi_hash_generate_test_case_3(void)
1943 return test_kasumi_authentication(&kasumi_hash_test_case_3);
1947 test_kasumi_hash_generate_test_case_4(void)
1949 return test_kasumi_authentication(&kasumi_hash_test_case_4);
1953 test_kasumi_hash_generate_test_case_5(void)
1955 return test_kasumi_authentication(&kasumi_hash_test_case_5);
1959 test_kasumi_hash_generate_test_case_6(void)
1961 return test_kasumi_authentication(&kasumi_hash_test_case_6);
1965 test_kasumi_hash_verify_test_case_1(void)
1967 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
1971 test_kasumi_hash_verify_test_case_2(void)
1973 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
1977 test_kasumi_hash_verify_test_case_3(void)
1979 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
1983 test_kasumi_hash_verify_test_case_4(void)
1985 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
1989 test_kasumi_hash_verify_test_case_5(void)
1991 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
1995 test_kasumi_encryption(const struct kasumi_test_data *tdata)
1997 struct crypto_testsuite_params *ts_params = &testsuite_params;
1998 struct crypto_unittest_params *ut_params = &unittest_params;
2001 uint8_t *plaintext, *ciphertext;
2002 unsigned plaintext_pad_len;
2003 unsigned plaintext_len;
2005 /* Create KASUMI session */
2006 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2007 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2008 RTE_CRYPTO_CIPHER_KASUMI_F8,
2009 tdata->key.data, tdata->key.len);
2013 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2015 /* Clear mbuf payload */
2016 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2017 rte_pktmbuf_tailroom(ut_params->ibuf));
2019 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2020 /* Append data which is padded to a multiple */
2021 /* of the algorithms block size */
2022 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2023 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2025 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2027 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2029 /* Create KASUMI operation */
2030 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2031 tdata->plaintext.len,
2032 tdata->validCipherOffsetLenInBits.len,
2033 RTE_CRYPTO_CIPHER_KASUMI_F8);
2037 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2039 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2041 ut_params->obuf = ut_params->op->sym->m_dst;
2042 if (ut_params->obuf)
2043 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2046 ciphertext = plaintext;
2048 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2051 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2053 tdata->ciphertext.data,
2054 tdata->validCipherLenInBits.len,
2055 "KASUMI Ciphertext data not as expected");
2060 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2062 struct crypto_testsuite_params *ts_params = &testsuite_params;
2063 struct crypto_unittest_params *ut_params = &unittest_params;
2066 uint8_t *plaintext, *ciphertext;
2067 unsigned plaintext_pad_len;
2068 unsigned plaintext_len;
2070 /* Create KASUMI session */
2071 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2072 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2073 RTE_CRYPTO_CIPHER_KASUMI_F8,
2074 tdata->key.data, tdata->key.len);
2078 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2079 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2081 /* Clear mbuf payload */
2082 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2083 rte_pktmbuf_tailroom(ut_params->ibuf));
2085 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2086 /* Append data which is padded to a multiple */
2087 /* of the algorithms block size */
2088 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2089 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2091 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2092 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2094 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2096 /* Create KASUMI operation */
2097 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2099 tdata->plaintext.len,
2100 tdata->validCipherOffsetLenInBits.len,
2101 RTE_CRYPTO_CIPHER_KASUMI_F8);
2105 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2107 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2109 ut_params->obuf = ut_params->op->sym->m_dst;
2110 if (ut_params->obuf)
2111 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2114 ciphertext = plaintext;
2116 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2119 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2121 tdata->ciphertext.data,
2122 tdata->validCipherLenInBits.len,
2123 "KASUMI Ciphertext data not as expected");
2128 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
2130 struct crypto_testsuite_params *ts_params = &testsuite_params;
2131 struct crypto_unittest_params *ut_params = &unittest_params;
2134 uint8_t *ciphertext, *plaintext;
2135 unsigned ciphertext_pad_len;
2136 unsigned ciphertext_len;
2138 /* Create KASUMI session */
2139 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2140 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2141 RTE_CRYPTO_CIPHER_KASUMI_F8,
2142 tdata->key.data, tdata->key.len);
2146 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2147 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2149 /* Clear mbuf payload */
2150 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2151 rte_pktmbuf_tailroom(ut_params->ibuf));
2153 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2154 /* Append data which is padded to a multiple */
2155 /* of the algorithms block size */
2156 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2157 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2158 ciphertext_pad_len);
2159 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2160 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2162 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2164 /* Create KASUMI operation */
2165 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2167 tdata->ciphertext.len,
2168 tdata->validCipherOffsetLenInBits.len,
2169 RTE_CRYPTO_CIPHER_KASUMI_F8);
2173 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2175 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2177 ut_params->obuf = ut_params->op->sym->m_dst;
2178 if (ut_params->obuf)
2179 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2182 plaintext = ciphertext;
2184 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2187 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2189 tdata->plaintext.data,
2190 tdata->validCipherLenInBits.len,
2191 "KASUMI Plaintext data not as expected");
2196 test_kasumi_decryption(const struct kasumi_test_data *tdata)
2198 struct crypto_testsuite_params *ts_params = &testsuite_params;
2199 struct crypto_unittest_params *ut_params = &unittest_params;
2202 uint8_t *ciphertext, *plaintext;
2203 unsigned ciphertext_pad_len;
2204 unsigned ciphertext_len;
2206 /* Create KASUMI session */
2207 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2208 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2209 RTE_CRYPTO_CIPHER_KASUMI_F8,
2210 tdata->key.data, tdata->key.len);
2214 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2216 /* Clear mbuf payload */
2217 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2218 rte_pktmbuf_tailroom(ut_params->ibuf));
2220 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2221 /* Append data which is padded to a multiple */
2222 /* of the algorithms block size */
2223 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2224 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2225 ciphertext_pad_len);
2226 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2228 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2230 /* Create KASUMI operation */
2231 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data,
2233 tdata->ciphertext.len,
2234 tdata->validCipherOffsetLenInBits.len,
2235 RTE_CRYPTO_CIPHER_KASUMI_F8);
2239 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2241 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2243 ut_params->obuf = ut_params->op->sym->m_dst;
2244 if (ut_params->obuf)
2245 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2248 plaintext = ciphertext;
2250 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2253 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2255 tdata->plaintext.data,
2256 tdata->validCipherLenInBits.len,
2257 "KASUMI Plaintext data not as expected");
2262 test_snow3g_encryption(const struct snow3g_test_data *tdata)
2264 struct crypto_testsuite_params *ts_params = &testsuite_params;
2265 struct crypto_unittest_params *ut_params = &unittest_params;
2268 uint8_t *plaintext, *ciphertext;
2269 unsigned plaintext_pad_len;
2270 unsigned plaintext_len;
2272 /* Create SNOW3G session */
2273 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2274 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2275 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2276 tdata->key.data, tdata->key.len);
2280 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2282 /* Clear mbuf payload */
2283 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2284 rte_pktmbuf_tailroom(ut_params->ibuf));
2286 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2287 /* Append data which is padded to a multiple of */
2288 /* the algorithms block size */
2289 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2290 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2292 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2294 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2296 /* Create SNOW3G operation */
2297 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2298 tdata->validCipherLenInBits.len,
2299 tdata->validCipherOffsetLenInBits.len,
2300 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2304 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2306 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2308 ut_params->obuf = ut_params->op->sym->m_dst;
2309 if (ut_params->obuf)
2310 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2313 ciphertext = plaintext;
2315 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2318 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2320 tdata->ciphertext.data,
2321 tdata->validDataLenInBits.len,
2322 "Snow3G Ciphertext data not as expected");
2328 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
2330 struct crypto_testsuite_params *ts_params = &testsuite_params;
2331 struct crypto_unittest_params *ut_params = &unittest_params;
2332 uint8_t *plaintext, *ciphertext;
2335 unsigned plaintext_pad_len;
2336 unsigned plaintext_len;
2338 /* Create SNOW3G session */
2339 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2340 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2341 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2342 tdata->key.data, tdata->key.len);
2346 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2347 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2349 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2350 "Failed to allocate input buffer in mempool");
2351 TEST_ASSERT_NOT_NULL(ut_params->obuf,
2352 "Failed to allocate output buffer in mempool");
2354 /* Clear mbuf payload */
2355 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2356 rte_pktmbuf_tailroom(ut_params->ibuf));
2358 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2359 /* Append data which is padded to a multiple of */
2360 /* the algorithms block size */
2361 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2362 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2364 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2365 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2367 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2369 /* Create SNOW3G operation */
2370 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2372 tdata->validCipherLenInBits.len,
2373 tdata->validCipherOffsetLenInBits.len,
2374 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2378 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2380 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2382 ut_params->obuf = ut_params->op->sym->m_dst;
2383 if (ut_params->obuf)
2384 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2387 ciphertext = plaintext;
2389 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2392 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2394 tdata->ciphertext.data,
2395 tdata->validDataLenInBits.len,
2396 "Snow3G Ciphertext data not as expected");
2400 /* Shift right a buffer by "offset" bits, "offset" < 8 */
2402 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
2404 uint8_t curr_byte, prev_byte;
2405 uint32_t length_in_bytes = ceil_byte_length(length + offset);
2406 uint8_t lower_byte_mask = (1 << offset) - 1;
2409 prev_byte = buffer[0];
2410 buffer[0] >>= offset;
2412 for (i = 1; i < length_in_bytes; i++) {
2413 curr_byte = buffer[i];
2414 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
2415 (curr_byte >> offset);
2416 prev_byte = curr_byte;
2421 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
2423 struct crypto_testsuite_params *ts_params = &testsuite_params;
2424 struct crypto_unittest_params *ut_params = &unittest_params;
2425 uint8_t *plaintext, *ciphertext;
2427 uint32_t plaintext_len;
2428 uint32_t plaintext_pad_len;
2429 uint8_t extra_offset = 4;
2430 uint8_t *expected_ciphertext_shifted;
2432 /* Create SNOW3G session */
2433 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2434 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2435 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2436 tdata->key.data, tdata->key.len);
2440 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2441 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2443 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2444 "Failed to allocate input buffer in mempool");
2445 TEST_ASSERT_NOT_NULL(ut_params->obuf,
2446 "Failed to allocate output buffer in mempool");
2448 /* Clear mbuf payload */
2449 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2450 rte_pktmbuf_tailroom(ut_params->ibuf));
2452 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
2454 * Append data which is padded to a
2455 * multiple of the algorithms block size
2457 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2459 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2462 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2464 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2465 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
2467 #ifdef RTE_APP_TEST_DEBUG
2468 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2470 /* Create SNOW3G operation */
2471 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2473 tdata->validCipherLenInBits.len,
2474 tdata->validCipherOffsetLenInBits.len +
2476 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2480 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2482 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2484 ut_params->obuf = ut_params->op->sym->m_dst;
2485 if (ut_params->obuf)
2486 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2489 ciphertext = plaintext;
2491 #ifdef RTE_APP_TEST_DEBUG
2492 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2495 expected_ciphertext_shifted = rte_malloc(NULL,
2496 ceil_byte_length(plaintext_len + extra_offset), 0);
2498 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
2499 "failed to reserve memory for ciphertext shifted\n");
2501 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
2502 ceil_byte_length(tdata->ciphertext.len));
2503 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
2506 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
2508 expected_ciphertext_shifted,
2509 tdata->validDataLenInBits.len,
2511 "Snow3G Ciphertext data not as expected");
2515 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2517 struct crypto_testsuite_params *ts_params = &testsuite_params;
2518 struct crypto_unittest_params *ut_params = &unittest_params;
2522 uint8_t *plaintext, *ciphertext;
2523 unsigned ciphertext_pad_len;
2524 unsigned ciphertext_len;
2526 /* Create SNOW3G session */
2527 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2528 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2529 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2530 tdata->key.data, tdata->key.len);
2534 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2536 /* Clear mbuf payload */
2537 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2538 rte_pktmbuf_tailroom(ut_params->ibuf));
2540 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2541 /* Append data which is padded to a multiple of */
2542 /* the algorithms block size */
2543 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
2544 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2545 ciphertext_pad_len);
2546 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2548 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2550 /* Create SNOW3G operation */
2551 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2552 tdata->validCipherLenInBits.len,
2553 tdata->validCipherOffsetLenInBits.len,
2554 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2558 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2560 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2561 ut_params->obuf = ut_params->op->sym->m_dst;
2562 if (ut_params->obuf)
2563 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2566 plaintext = ciphertext;
2568 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2571 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
2572 tdata->plaintext.data,
2573 tdata->validDataLenInBits.len,
2574 "Snow3G Plaintext data not as expected");
2578 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
2580 struct crypto_testsuite_params *ts_params = &testsuite_params;
2581 struct crypto_unittest_params *ut_params = &unittest_params;
2585 uint8_t *plaintext, *ciphertext;
2586 unsigned ciphertext_pad_len;
2587 unsigned ciphertext_len;
2589 /* Create SNOW3G session */
2590 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2591 RTE_CRYPTO_CIPHER_OP_DECRYPT,
2592 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2593 tdata->key.data, tdata->key.len);
2597 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2598 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2600 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2601 "Failed to allocate input buffer");
2602 TEST_ASSERT_NOT_NULL(ut_params->obuf,
2603 "Failed to allocate output buffer");
2605 /* Clear mbuf payload */
2606 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2607 rte_pktmbuf_tailroom(ut_params->ibuf));
2609 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
2610 rte_pktmbuf_tailroom(ut_params->obuf));
2612 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2613 /* Append data which is padded to a multiple of */
2614 /* the algorithms block size */
2615 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
2616 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2617 ciphertext_pad_len);
2618 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2619 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2621 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2623 /* Create SNOW3G operation */
2624 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2626 tdata->validCipherLenInBits.len,
2627 tdata->validCipherOffsetLenInBits.len,
2628 RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2632 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2634 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2635 ut_params->obuf = ut_params->op->sym->m_dst;
2636 if (ut_params->obuf)
2637 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2640 plaintext = ciphertext;
2642 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2645 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
2646 tdata->plaintext.data,
2647 tdata->validDataLenInBits.len,
2648 "Snow3G Plaintext data not as expected");
2653 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
2655 struct crypto_testsuite_params *ts_params = &testsuite_params;
2656 struct crypto_unittest_params *ut_params = &unittest_params;
2660 uint8_t *plaintext, *ciphertext;
2661 unsigned plaintext_pad_len;
2662 unsigned plaintext_len;
2664 /* Create SNOW3G session */
2665 retval = create_snow3g_kasumi_cipher_auth_session(ts_params->valid_devs[0],
2666 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2667 RTE_CRYPTO_AUTH_OP_GENERATE,
2668 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2669 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2670 tdata->key.data, tdata->key.len,
2671 tdata->aad.len, tdata->digest.len);
2674 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2676 /* clear mbuf payload */
2677 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2678 rte_pktmbuf_tailroom(ut_params->ibuf));
2680 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2681 /* Append data which is padded to a multiple of */
2682 /* the algorithms block size */
2683 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2684 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2686 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2688 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2690 /* Create SNOW3G operation */
2691 retval = create_snow3g_kasumi_cipher_hash_operation(tdata->digest.data,
2692 tdata->digest.len, tdata->aad.data,
2693 tdata->aad.len, /*tdata->plaintext.len,*/
2694 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2695 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2696 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2697 tdata->iv.data, tdata->iv.len,
2698 tdata->validCipherLenInBits.len,
2699 tdata->validCipherOffsetLenInBits.len,
2700 tdata->validAuthLenInBits.len,
2701 tdata->validAuthOffsetLenInBits.len
2706 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2708 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2709 ut_params->obuf = ut_params->op->sym->m_src;
2710 if (ut_params->obuf)
2711 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2712 + tdata->iv.len + tdata->aad.len;
2714 ciphertext = plaintext;
2716 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2718 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2720 tdata->ciphertext.data,
2721 tdata->validDataLenInBits.len,
2722 "Snow3G Ciphertext data not as expected");
2724 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2725 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
2728 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2731 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2732 "Snow3G Generated auth tag not as expected");
2736 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
2738 struct crypto_testsuite_params *ts_params = &testsuite_params;
2739 struct crypto_unittest_params *ut_params = &unittest_params;
2743 uint8_t *plaintext, *ciphertext;
2744 unsigned plaintext_pad_len;
2745 unsigned plaintext_len;
2747 /* Create SNOW3G session */
2748 retval = create_snow3g_kasumi_auth_cipher_session(ts_params->valid_devs[0],
2749 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2750 RTE_CRYPTO_AUTH_OP_GENERATE,
2751 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2752 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2753 tdata->key.data, tdata->key.len,
2754 tdata->aad.len, tdata->digest.len);
2758 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2760 /* clear mbuf payload */
2761 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2762 rte_pktmbuf_tailroom(ut_params->ibuf));
2764 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2765 /* Append data which is padded to a multiple of */
2766 /* the algorithms block size */
2767 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2768 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2770 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2772 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2774 /* Create SNOW3G operation */
2775 retval = create_snow3g_kasumi_auth_cipher_operation(
2777 tdata->iv.data, tdata->iv.len,
2778 tdata->aad.data, tdata->aad.len,
2780 tdata->validCipherLenInBits.len,
2781 tdata->validCipherOffsetLenInBits.len,
2782 tdata->validAuthLenInBits.len,
2783 tdata->validAuthOffsetLenInBits.len,
2784 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2785 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
2791 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2793 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2794 ut_params->obuf = ut_params->op->sym->m_src;
2795 if (ut_params->obuf)
2796 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2797 + tdata->aad.len + tdata->iv.len;
2799 ciphertext = plaintext;
2801 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2802 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
2803 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2806 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2808 tdata->ciphertext.data,
2809 tdata->validDataLenInBits.len,
2810 "Snow3G Ciphertext data not as expected");
2813 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2816 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2817 "Snow3G Generated auth tag not as expected");
2822 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
2824 struct crypto_testsuite_params *ts_params = &testsuite_params;
2825 struct crypto_unittest_params *ut_params = &unittest_params;
2829 uint8_t *plaintext, *ciphertext;
2830 unsigned plaintext_pad_len;
2831 unsigned plaintext_len;
2833 /* Create KASUMI session */
2834 retval = create_snow3g_kasumi_auth_cipher_session(
2835 ts_params->valid_devs[0],
2836 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2837 RTE_CRYPTO_AUTH_OP_GENERATE,
2838 RTE_CRYPTO_AUTH_KASUMI_F9,
2839 RTE_CRYPTO_CIPHER_KASUMI_F8,
2840 tdata->key.data, tdata->key.len,
2841 tdata->aad.len, tdata->digest.len);
2844 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2846 /* clear mbuf payload */
2847 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2848 rte_pktmbuf_tailroom(ut_params->ibuf));
2850 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2851 /* Append data which is padded to a multiple of */
2852 /* the algorithms block size */
2853 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2854 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2856 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2858 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2860 /* Create KASUMI operation */
2861 retval = create_snow3g_kasumi_auth_cipher_operation(tdata->digest.len,
2862 tdata->iv.data, tdata->iv.len,
2863 tdata->aad.data, tdata->aad.len,
2865 tdata->validCipherLenInBits.len,
2866 tdata->validCipherOffsetLenInBits.len,
2867 tdata->validAuthLenInBits.len,
2868 tdata->validAuthOffsetLenInBits.len,
2869 RTE_CRYPTO_AUTH_KASUMI_F9,
2870 RTE_CRYPTO_CIPHER_KASUMI_F8
2876 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2878 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2879 ut_params->obuf = ut_params->op->sym->m_src;
2880 if (ut_params->obuf)
2881 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2882 + tdata->iv.len + tdata->aad.len;
2884 ciphertext = plaintext;
2887 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2889 tdata->ciphertext.data,
2890 tdata->validCipherLenInBits.len,
2891 "KASUMI Ciphertext data not as expected");
2892 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2893 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
2896 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2899 DIGEST_BYTE_LENGTH_KASUMI_F9,
2900 "KASUMI Generated auth tag not as expected");
2905 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
2907 struct crypto_testsuite_params *ts_params = &testsuite_params;
2908 struct crypto_unittest_params *ut_params = &unittest_params;
2912 uint8_t *plaintext, *ciphertext;
2913 unsigned plaintext_pad_len;
2914 unsigned plaintext_len;
2916 /* Create KASUMI session */
2917 retval = create_snow3g_kasumi_cipher_auth_session(
2918 ts_params->valid_devs[0],
2919 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2920 RTE_CRYPTO_AUTH_OP_GENERATE,
2921 RTE_CRYPTO_AUTH_KASUMI_F9,
2922 RTE_CRYPTO_CIPHER_KASUMI_F8,
2923 tdata->key.data, tdata->key.len,
2924 tdata->aad.len, tdata->digest.len);
2928 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2930 /* clear mbuf payload */
2931 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2932 rte_pktmbuf_tailroom(ut_params->ibuf));
2934 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2935 /* Append data which is padded to a multiple of */
2936 /* the algorithms block size */
2937 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2938 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2940 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2942 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2944 /* Create KASUMI operation */
2945 retval = create_snow3g_kasumi_cipher_hash_operation(tdata->digest.data,
2946 tdata->digest.len, tdata->aad.data,
2948 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2949 RTE_CRYPTO_AUTH_KASUMI_F9,
2950 RTE_CRYPTO_CIPHER_KASUMI_F8,
2951 tdata->iv.data, tdata->iv.len,
2952 tdata->validCipherLenInBits.len,
2953 tdata->validCipherOffsetLenInBits.len,
2954 tdata->validAuthLenInBits.len,
2955 tdata->validAuthOffsetLenInBits.len
2960 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2962 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2963 ut_params->obuf = ut_params->op->sym->m_src;
2964 if (ut_params->obuf)
2965 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2966 + tdata->aad.len + tdata->iv.len;
2968 ciphertext = plaintext;
2970 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2971 + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
2974 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2976 tdata->ciphertext.data,
2977 tdata->validCipherLenInBits.len,
2978 "KASUMI Ciphertext data not as expected");
2981 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2984 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2985 "KASUMI Generated auth tag not as expected");
2990 test_kasumi_encryption_test_case_1(void)
2992 return test_kasumi_encryption(&kasumi_test_case_1);
2996 test_kasumi_encryption_test_case_1_oop(void)
2998 return test_kasumi_encryption_oop(&kasumi_test_case_1);
3002 test_kasumi_encryption_test_case_2(void)
3004 return test_kasumi_encryption(&kasumi_test_case_2);
3008 test_kasumi_encryption_test_case_3(void)
3010 return test_kasumi_encryption(&kasumi_test_case_3);
3014 test_kasumi_encryption_test_case_4(void)
3016 return test_kasumi_encryption(&kasumi_test_case_4);
3020 test_kasumi_encryption_test_case_5(void)
3022 return test_kasumi_encryption(&kasumi_test_case_5);
3026 test_kasumi_decryption_test_case_1(void)
3028 return test_kasumi_decryption(&kasumi_test_case_1);
3032 test_kasumi_decryption_test_case_1_oop(void)
3034 return test_kasumi_decryption_oop(&kasumi_test_case_1);
3038 test_kasumi_decryption_test_case_2(void)
3040 return test_kasumi_decryption(&kasumi_test_case_2);
3044 test_kasumi_decryption_test_case_3(void)
3046 return test_kasumi_decryption(&kasumi_test_case_3);
3050 test_kasumi_decryption_test_case_4(void)
3052 return test_kasumi_decryption(&kasumi_test_case_4);
3056 test_kasumi_decryption_test_case_5(void)
3058 return test_kasumi_decryption(&kasumi_test_case_5);
3061 test_snow3g_encryption_test_case_1(void)
3063 return test_snow3g_encryption(&snow3g_test_case_1);
3067 test_snow3g_encryption_test_case_1_oop(void)
3069 return test_snow3g_encryption_oop(&snow3g_test_case_1);
3073 test_snow3g_encryption_test_case_1_offset_oop(void)
3075 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
3079 test_snow3g_encryption_test_case_2(void)
3081 return test_snow3g_encryption(&snow3g_test_case_2);
3085 test_snow3g_encryption_test_case_3(void)
3087 return test_snow3g_encryption(&snow3g_test_case_3);
3091 test_snow3g_encryption_test_case_4(void)
3093 return test_snow3g_encryption(&snow3g_test_case_4);
3097 test_snow3g_encryption_test_case_5(void)
3099 return test_snow3g_encryption(&snow3g_test_case_5);
3103 test_snow3g_decryption_test_case_1(void)
3105 return test_snow3g_decryption(&snow3g_test_case_1);
3109 test_snow3g_decryption_test_case_1_oop(void)
3111 return test_snow3g_decryption_oop(&snow3g_test_case_1);
3115 test_snow3g_decryption_test_case_2(void)
3117 return test_snow3g_decryption(&snow3g_test_case_2);
3121 test_snow3g_decryption_test_case_3(void)
3123 return test_snow3g_decryption(&snow3g_test_case_3);
3127 test_snow3g_decryption_test_case_4(void)
3129 return test_snow3g_decryption(&snow3g_test_case_4);
3133 test_snow3g_decryption_test_case_5(void)
3135 return test_snow3g_decryption(&snow3g_test_case_5);
3138 test_snow3g_cipher_auth_test_case_1(void)
3140 return test_snow3g_cipher_auth(&snow3g_test_case_3);
3144 test_snow3g_auth_cipher_test_case_1(void)
3146 return test_snow3g_auth_cipher(&snow3g_test_case_6);
3150 test_kasumi_auth_cipher_test_case_1(void)
3152 return test_kasumi_auth_cipher(&kasumi_test_case_3);
3156 test_kasumi_cipher_auth_test_case_1(void)
3158 return test_kasumi_cipher_auth(&kasumi_test_case_6);
3162 /* ***** AES-GCM Tests ***** */
3165 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
3166 const uint8_t *key, const uint8_t key_len,
3167 const uint8_t aad_len, const uint8_t auth_len)
3169 uint8_t cipher_key[key_len];
3171 struct crypto_unittest_params *ut_params = &unittest_params;
3174 memcpy(cipher_key, key, key_len);
3176 /* Setup Cipher Parameters */
3177 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3178 ut_params->cipher_xform.next = NULL;
3180 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3181 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3182 ut_params->cipher_xform.cipher.op = op;
3183 ut_params->cipher_xform.cipher.key.data = cipher_key;
3184 ut_params->cipher_xform.cipher.key.length = key_len;
3186 TEST_HEXDUMP(stdout, "key:", key, key_len);
3188 /* Setup Authentication Parameters */
3189 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3190 ut_params->auth_xform.next = NULL;
3192 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3194 ut_params->auth_xform.auth.digest_length = auth_len;
3195 ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3196 ut_params->auth_xform.auth.key.length = 0;
3197 ut_params->auth_xform.auth.key.data = NULL;
3199 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3200 ut_params->cipher_xform.next = &ut_params->auth_xform;
3202 /* Create Crypto session*/
3203 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3204 &ut_params->cipher_xform);
3205 } else {/* Create Crypto session*/
3206 ut_params->auth_xform.next = &ut_params->cipher_xform;
3207 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3208 &ut_params->auth_xform);
3211 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3217 create_gcm_operation(enum rte_crypto_cipher_operation op,
3218 const uint8_t *auth_tag, const unsigned auth_tag_len,
3219 const uint8_t *iv, const unsigned iv_len,
3220 const uint8_t *aad, const unsigned aad_len,
3221 const unsigned data_len, unsigned data_pad_len)
3223 struct crypto_testsuite_params *ts_params = &testsuite_params;
3224 struct crypto_unittest_params *ut_params = &unittest_params;
3226 unsigned iv_pad_len = 0, aad_buffer_len;
3228 /* Generate Crypto op data structure */
3229 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3230 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3231 TEST_ASSERT_NOT_NULL(ut_params->op,
3232 "Failed to allocate symmetric crypto operation struct");
3234 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3238 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3239 ut_params->ibuf, auth_tag_len);
3240 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3241 "no room to append digest");
3242 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3243 ut_params->ibuf, data_pad_len);
3244 sym_op->auth.digest.length = auth_tag_len;
3246 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3247 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3248 TEST_HEXDUMP(stdout, "digest:",
3249 sym_op->auth.digest.data,
3250 sym_op->auth.digest.length);
3254 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3256 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3257 ut_params->ibuf, iv_pad_len);
3258 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3260 memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3261 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3262 sym_op->cipher.iv.length = iv_pad_len;
3264 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3268 sym_op->cipher.iv.data[15] = 1;
3271 * Always allocate the aad up to the block size.
3272 * The cryptodev API calls out -
3273 * - the array must be big enough to hold the AAD, plus any
3274 * space to round this up to the nearest multiple of the
3275 * block size (16 bytes).
3277 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
3279 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
3280 ut_params->ibuf, aad_buffer_len);
3281 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
3282 "no room to prepend aad");
3283 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
3285 sym_op->auth.aad.length = aad_len;
3287 memset(sym_op->auth.aad.data, 0, aad_buffer_len);
3288 rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
3290 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
3291 TEST_HEXDUMP(stdout, "aad:",
3292 sym_op->auth.aad.data, aad_len);
3294 sym_op->cipher.data.length = data_len;
3295 sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
3297 sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
3298 sym_op->auth.data.length = data_len;
3304 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
3306 struct crypto_testsuite_params *ts_params = &testsuite_params;
3307 struct crypto_unittest_params *ut_params = &unittest_params;
3311 uint8_t *plaintext, *ciphertext, *auth_tag;
3312 uint16_t plaintext_pad_len;
3314 /* Create GCM session */
3315 retval = create_gcm_session(ts_params->valid_devs[0],
3316 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3317 tdata->key.data, tdata->key.len,
3318 tdata->aad.len, tdata->auth_tag.len);
3323 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3325 /* clear mbuf payload */
3326 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3327 rte_pktmbuf_tailroom(ut_params->ibuf));
3330 * Append data which is padded to a multiple
3331 * of the algorithms block size
3333 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
3335 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3337 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
3339 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3341 /* Create GCM opertaion */
3342 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3343 tdata->auth_tag.data, tdata->auth_tag.len,
3344 tdata->iv.data, tdata->iv.len,
3345 tdata->aad.data, tdata->aad.len,
3346 tdata->plaintext.len, plaintext_pad_len);
3350 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3352 ut_params->op->sym->m_src = ut_params->ibuf;
3354 /* Process crypto operation */
3355 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3356 ut_params->op), "failed to process sym crypto op");
3358 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3359 "crypto op processing failed");
3361 if (ut_params->op->sym->m_dst) {
3362 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3364 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
3365 uint8_t *, plaintext_pad_len);
3367 ciphertext = plaintext;
3368 auth_tag = plaintext + plaintext_pad_len;
3371 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3372 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
3375 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3377 tdata->ciphertext.data,
3378 tdata->ciphertext.len,
3379 "GCM Ciphertext data not as expected");
3381 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3383 tdata->auth_tag.data,
3384 tdata->auth_tag.len,
3385 "GCM Generated auth tag not as expected");
3392 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
3394 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
3398 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
3400 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
3404 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
3406 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
3410 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
3412 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
3416 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
3418 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
3422 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
3424 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
3428 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
3430 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
3434 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
3436 struct crypto_testsuite_params *ts_params = &testsuite_params;
3437 struct crypto_unittest_params *ut_params = &unittest_params;
3441 uint8_t *plaintext, *ciphertext;
3442 uint16_t ciphertext_pad_len;
3444 /* Create GCM session */
3445 retval = create_gcm_session(ts_params->valid_devs[0],
3446 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3447 tdata->key.data, tdata->key.len,
3448 tdata->aad.len, tdata->auth_tag.len);
3453 /* alloc mbuf and set payload */
3454 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3456 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3457 rte_pktmbuf_tailroom(ut_params->ibuf));
3459 ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
3461 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3462 ciphertext_pad_len);
3463 memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
3465 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3467 /* Create GCM opertaion */
3468 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
3469 tdata->auth_tag.data, tdata->auth_tag.len,
3470 tdata->iv.data, tdata->iv.len,
3471 tdata->aad.data, tdata->aad.len,
3472 tdata->ciphertext.len, ciphertext_pad_len);
3477 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3479 ut_params->op->sym->m_src = ut_params->ibuf;
3481 /* Process crypto operation */
3482 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3483 ut_params->op), "failed to process sym crypto op");
3485 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3486 "crypto op processing failed");
3488 if (ut_params->op->sym->m_dst)
3489 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3492 plaintext = ciphertext;
3494 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
3497 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3499 tdata->plaintext.data,
3500 tdata->plaintext.len,
3501 "GCM plaintext data not as expected");
3503 TEST_ASSERT_EQUAL(ut_params->op->status,
3504 RTE_CRYPTO_OP_STATUS_SUCCESS,
3505 "GCM authentication failed");
3510 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
3512 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
3516 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
3518 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
3522 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
3524 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
3528 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
3530 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
3534 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
3536 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
3540 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
3542 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
3546 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
3548 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
3554 struct crypto_testsuite_params *ts_params = &testsuite_params;
3555 struct rte_cryptodev_stats stats;
3556 struct rte_cryptodev *dev;
3557 cryptodev_stats_get_t temp_pfn;
3559 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
3560 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
3561 &stats) == -ENODEV),
3562 "rte_cryptodev_stats_get invalid dev failed");
3563 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
3564 "rte_cryptodev_stats_get invalid Param failed");
3565 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
3566 temp_pfn = dev->dev_ops->stats_get;
3567 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
3568 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
3570 "rte_cryptodev_stats_get invalid Param failed");
3571 dev->dev_ops->stats_get = temp_pfn;
3573 /* Test expected values */
3575 test_AES_CBC_HMAC_SHA1_encrypt_digest();
3577 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3579 "rte_cryptodev_stats_get failed");
3580 TEST_ASSERT((stats.enqueued_count == 1),
3581 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3582 TEST_ASSERT((stats.dequeued_count == 1),
3583 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3584 TEST_ASSERT((stats.enqueue_err_count == 0),
3585 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3586 TEST_ASSERT((stats.dequeue_err_count == 0),
3587 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3589 /* invalid device but should ignore and not reset device stats*/
3590 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
3591 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3593 "rte_cryptodev_stats_get failed");
3594 TEST_ASSERT((stats.enqueued_count == 1),
3595 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3597 /* check that a valid reset clears stats */
3598 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
3599 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3601 "rte_cryptodev_stats_get failed");
3602 TEST_ASSERT((stats.enqueued_count == 0),
3603 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3604 TEST_ASSERT((stats.dequeued_count == 0),
3605 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3607 return TEST_SUCCESS;
3610 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
3611 struct crypto_unittest_params *ut_params,
3612 enum rte_crypto_auth_operation op,
3613 const struct HMAC_MD5_vector *test_case)
3617 memcpy(key, test_case->key.data, test_case->key.len);
3619 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3620 ut_params->auth_xform.next = NULL;
3621 ut_params->auth_xform.auth.op = op;
3623 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
3625 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
3626 ut_params->auth_xform.auth.add_auth_data_length = 0;
3627 ut_params->auth_xform.auth.key.length = test_case->key.len;
3628 ut_params->auth_xform.auth.key.data = key;
3630 ut_params->sess = rte_cryptodev_sym_session_create(
3631 ts_params->valid_devs[0], &ut_params->auth_xform);
3633 if (ut_params->sess == NULL)
3636 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3638 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3639 rte_pktmbuf_tailroom(ut_params->ibuf));
3644 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
3645 const struct HMAC_MD5_vector *test_case,
3646 uint8_t **plaintext)
3648 uint16_t plaintext_pad_len;
3650 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3652 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
3655 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3657 memcpy(*plaintext, test_case->plaintext.data,
3658 test_case->plaintext.len);
3660 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3661 ut_params->ibuf, MD5_DIGEST_LEN);
3662 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3663 "no room to append digest");
3664 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3665 ut_params->ibuf, plaintext_pad_len);
3666 sym_op->auth.digest.length = MD5_DIGEST_LEN;
3668 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
3669 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
3670 test_case->auth_tag.len);
3673 sym_op->auth.data.offset = 0;
3674 sym_op->auth.data.length = test_case->plaintext.len;
3676 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3677 ut_params->op->sym->m_src = ut_params->ibuf;
3683 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
3685 uint16_t plaintext_pad_len;
3686 uint8_t *plaintext, *auth_tag;
3688 struct crypto_testsuite_params *ts_params = &testsuite_params;
3689 struct crypto_unittest_params *ut_params = &unittest_params;
3691 if (MD5_HMAC_create_session(ts_params, ut_params,
3692 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
3695 /* Generate Crypto op data structure */
3696 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3697 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3698 TEST_ASSERT_NOT_NULL(ut_params->op,
3699 "Failed to allocate symmetric crypto operation struct");
3701 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
3704 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
3707 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3708 ut_params->op), "failed to process sym crypto op");
3710 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3711 "crypto op processing failed");
3713 if (ut_params->op->sym->m_dst) {
3714 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
3715 uint8_t *, plaintext_pad_len);
3717 auth_tag = plaintext + plaintext_pad_len;
3720 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3722 test_case->auth_tag.data,
3723 test_case->auth_tag.len,
3724 "HMAC_MD5 generated tag not as expected");
3726 return TEST_SUCCESS;
3730 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
3734 struct crypto_testsuite_params *ts_params = &testsuite_params;
3735 struct crypto_unittest_params *ut_params = &unittest_params;
3737 if (MD5_HMAC_create_session(ts_params, ut_params,
3738 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
3742 /* Generate Crypto op data structure */
3743 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3744 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3745 TEST_ASSERT_NOT_NULL(ut_params->op,
3746 "Failed to allocate symmetric crypto operation struct");
3748 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
3751 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3752 ut_params->op), "failed to process sym crypto op");
3754 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3755 "HMAC_MD5 crypto op processing failed");
3757 return TEST_SUCCESS;
3761 test_MD5_HMAC_generate_case_1(void)
3763 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
3767 test_MD5_HMAC_verify_case_1(void)
3769 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
3773 test_MD5_HMAC_generate_case_2(void)
3775 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
3779 test_MD5_HMAC_verify_case_2(void)
3781 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
3785 test_multi_session(void)
3787 struct crypto_testsuite_params *ts_params = &testsuite_params;
3788 struct crypto_unittest_params *ut_params = &unittest_params;
3790 struct rte_cryptodev_info dev_info;
3791 struct rte_cryptodev_sym_session **sessions;
3795 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
3798 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3800 sessions = rte_malloc(NULL,
3801 (sizeof(struct rte_cryptodev_sym_session *) *
3802 dev_info.sym.max_nb_sessions) + 1, 0);
3804 /* Create multiple crypto sessions*/
3805 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
3806 sessions[i] = rte_cryptodev_sym_session_create(
3807 ts_params->valid_devs[0],
3808 &ut_params->auth_xform);
3809 TEST_ASSERT_NOT_NULL(sessions[i],
3810 "Session creation failed at session number %u",
3813 /* Attempt to send a request on each session */
3814 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform(
3815 sessions[i], ut_params, ts_params),
3816 "Failed to perform decrypt on request "
3818 /* free crypto operation structure */
3820 rte_crypto_op_free(ut_params->op);
3823 * free mbuf - both obuf and ibuf are usually the same,
3824 * so check if they point at the same address is necessary,
3825 * to avoid freeing the mbuf twice.
3827 if (ut_params->obuf) {
3828 rte_pktmbuf_free(ut_params->obuf);
3829 if (ut_params->ibuf == ut_params->obuf)
3830 ut_params->ibuf = 0;
3831 ut_params->obuf = 0;
3833 if (ut_params->ibuf) {
3834 rte_pktmbuf_free(ut_params->ibuf);
3835 ut_params->ibuf = 0;
3839 /* Next session create should fail */
3840 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
3841 &ut_params->auth_xform);
3842 TEST_ASSERT_NULL(sessions[i],
3843 "Session creation succeeded unexpectedly!");
3845 for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
3846 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
3851 return TEST_SUCCESS;
3855 test_null_cipher_only_operation(void)
3857 struct crypto_testsuite_params *ts_params = &testsuite_params;
3858 struct crypto_unittest_params *ut_params = &unittest_params;
3860 /* Generate test mbuf data and space for digest */
3861 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3862 catch_22_quote, QUOTE_512_BYTES, 0);
3864 /* Setup Cipher Parameters */
3865 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3866 ut_params->cipher_xform.next = NULL;
3868 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3869 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3871 /* Create Crypto session*/
3872 ut_params->sess = rte_cryptodev_sym_session_create(
3873 ts_params->valid_devs[0], &ut_params->cipher_xform);
3874 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3876 /* Generate Crypto op data structure */
3877 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3878 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3879 TEST_ASSERT_NOT_NULL(ut_params->op,
3880 "Failed to allocate symmetric crypto operation struct");
3882 /* Set crypto operation data parameters */
3883 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3885 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3887 /* set crypto operation source mbuf */
3888 sym_op->m_src = ut_params->ibuf;
3890 sym_op->cipher.data.offset = 0;
3891 sym_op->cipher.data.length = QUOTE_512_BYTES;
3893 /* Process crypto operation */
3894 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3896 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3898 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3899 "crypto operation processing failed");
3902 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3903 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
3906 "Ciphertext data not as expected");
3908 return TEST_SUCCESS;
3912 test_null_auth_only_operation(void)
3914 struct crypto_testsuite_params *ts_params = &testsuite_params;
3915 struct crypto_unittest_params *ut_params = &unittest_params;
3917 /* Generate test mbuf data and space for digest */
3918 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3919 catch_22_quote, QUOTE_512_BYTES, 0);
3921 /* Setup HMAC Parameters */
3922 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3923 ut_params->auth_xform.next = NULL;
3925 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3926 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3928 /* Create Crypto session*/
3929 ut_params->sess = rte_cryptodev_sym_session_create(
3930 ts_params->valid_devs[0], &ut_params->auth_xform);
3931 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3933 /* Generate Crypto op data structure */
3934 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3935 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3936 TEST_ASSERT_NOT_NULL(ut_params->op,
3937 "Failed to allocate symmetric crypto operation struct");
3939 /* Set crypto operation data parameters */
3940 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3942 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3944 sym_op->m_src = ut_params->ibuf;
3946 sym_op->auth.data.offset = 0;
3947 sym_op->auth.data.length = QUOTE_512_BYTES;
3949 /* Process crypto operation */
3950 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3952 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3954 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3955 "crypto operation processing failed");
3957 return TEST_SUCCESS;
3961 test_null_cipher_auth_operation(void)
3963 struct crypto_testsuite_params *ts_params = &testsuite_params;
3964 struct crypto_unittest_params *ut_params = &unittest_params;
3966 /* Generate test mbuf data and space for digest */
3967 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3968 catch_22_quote, QUOTE_512_BYTES, 0);
3970 /* Setup Cipher Parameters */
3971 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3972 ut_params->cipher_xform.next = &ut_params->auth_xform;
3974 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3975 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3977 /* Setup HMAC Parameters */
3978 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3979 ut_params->auth_xform.next = NULL;
3981 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3982 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3984 /* Create Crypto session*/
3985 ut_params->sess = rte_cryptodev_sym_session_create(
3986 ts_params->valid_devs[0], &ut_params->cipher_xform);
3987 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3989 /* Generate Crypto op data structure */
3990 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3991 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3992 TEST_ASSERT_NOT_NULL(ut_params->op,
3993 "Failed to allocate symmetric crypto operation struct");
3995 /* Set crypto operation data parameters */
3996 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3998 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4000 sym_op->m_src = ut_params->ibuf;
4002 sym_op->cipher.data.offset = 0;
4003 sym_op->cipher.data.length = QUOTE_512_BYTES;
4005 sym_op->auth.data.offset = 0;
4006 sym_op->auth.data.length = QUOTE_512_BYTES;
4008 /* Process crypto operation */
4009 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4011 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4013 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4014 "crypto operation processing failed");
4017 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4018 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4021 "Ciphertext data not as expected");
4023 return TEST_SUCCESS;
4027 test_null_auth_cipher_operation(void)
4029 struct crypto_testsuite_params *ts_params = &testsuite_params;
4030 struct crypto_unittest_params *ut_params = &unittest_params;
4032 /* Generate test mbuf data and space for digest */
4033 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4034 catch_22_quote, QUOTE_512_BYTES, 0);
4036 /* Setup Cipher Parameters */
4037 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4038 ut_params->cipher_xform.next = NULL;
4040 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4041 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4043 /* Setup HMAC Parameters */
4044 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4045 ut_params->auth_xform.next = &ut_params->cipher_xform;
4047 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4048 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4050 /* Create Crypto session*/
4051 ut_params->sess = rte_cryptodev_sym_session_create(
4052 ts_params->valid_devs[0], &ut_params->cipher_xform);
4053 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4055 /* Generate Crypto op data structure */
4056 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4057 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4058 TEST_ASSERT_NOT_NULL(ut_params->op,
4059 "Failed to allocate symmetric crypto operation struct");
4061 /* Set crypto operation data parameters */
4062 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4064 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4066 sym_op->m_src = ut_params->ibuf;
4068 sym_op->cipher.data.offset = 0;
4069 sym_op->cipher.data.length = QUOTE_512_BYTES;
4071 sym_op->auth.data.offset = 0;
4072 sym_op->auth.data.length = QUOTE_512_BYTES;
4074 /* Process crypto operation */
4075 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4077 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4079 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4080 "crypto operation processing failed");
4083 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4084 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4087 "Ciphertext data not as expected");
4089 return TEST_SUCCESS;
4094 test_null_invalid_operation(void)
4096 struct crypto_testsuite_params *ts_params = &testsuite_params;
4097 struct crypto_unittest_params *ut_params = &unittest_params;
4099 /* Setup Cipher Parameters */
4100 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4101 ut_params->cipher_xform.next = NULL;
4103 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
4104 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4106 /* Create Crypto session*/
4107 ut_params->sess = rte_cryptodev_sym_session_create(
4108 ts_params->valid_devs[0], &ut_params->cipher_xform);
4109 TEST_ASSERT_NULL(ut_params->sess,
4110 "Session creation succeeded unexpectedly");
4113 /* Setup HMAC Parameters */
4114 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4115 ut_params->auth_xform.next = NULL;
4117 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
4118 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4120 /* Create Crypto session*/
4121 ut_params->sess = rte_cryptodev_sym_session_create(
4122 ts_params->valid_devs[0], &ut_params->auth_xform);
4123 TEST_ASSERT_NULL(ut_params->sess,
4124 "Session creation succeeded unexpectedly");
4126 return TEST_SUCCESS;
4130 #define NULL_BURST_LENGTH (32)
4133 test_null_burst_operation(void)
4135 struct crypto_testsuite_params *ts_params = &testsuite_params;
4136 struct crypto_unittest_params *ut_params = &unittest_params;
4138 unsigned i, burst_len = NULL_BURST_LENGTH;
4140 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
4141 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
4143 /* Setup Cipher Parameters */
4144 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4145 ut_params->cipher_xform.next = &ut_params->auth_xform;
4147 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4148 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4150 /* Setup HMAC Parameters */
4151 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4152 ut_params->auth_xform.next = NULL;
4154 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4155 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4157 /* Create Crypto session*/
4158 ut_params->sess = rte_cryptodev_sym_session_create(
4159 ts_params->valid_devs[0], &ut_params->cipher_xform);
4160 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4162 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4163 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
4164 burst_len, "failed to generate burst of crypto ops");
4166 /* Generate an operation for each mbuf in burst */
4167 for (i = 0; i < burst_len; i++) {
4168 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4170 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
4172 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
4176 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
4178 burst[i]->sym->m_src = m;
4181 /* Process crypto operation */
4182 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
4183 0, burst, burst_len),
4185 "Error enqueuing burst");
4187 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
4188 0, burst_dequeued, burst_len),
4190 "Error dequeuing burst");
4193 for (i = 0; i < burst_len; i++) {
4195 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
4196 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
4198 "data not as expected");
4200 rte_pktmbuf_free(burst[i]->sym->m_src);
4201 rte_crypto_op_free(burst[i]);
4204 return TEST_SUCCESS;
4210 static struct unit_test_suite cryptodev_qat_testsuite = {
4211 .suite_name = "Crypto QAT Unit Test Suite",
4212 .setup = testsuite_setup,
4213 .teardown = testsuite_teardown,
4214 .unit_test_cases = {
4215 TEST_CASE_ST(ut_setup, ut_teardown,
4216 test_device_configure_invalid_dev_id),
4217 TEST_CASE_ST(ut_setup, ut_teardown,
4218 test_device_configure_invalid_queue_pair_ids),
4219 TEST_CASE_ST(ut_setup, ut_teardown,
4220 test_queue_pair_descriptor_setup),
4221 TEST_CASE_ST(ut_setup, ut_teardown,
4222 test_multi_session),
4224 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_qat_all),
4225 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
4227 /** AES GCM Authenticated Encryption */
4228 TEST_CASE_ST(ut_setup, ut_teardown,
4229 test_mb_AES_GCM_authenticated_encryption_test_case_1),
4230 TEST_CASE_ST(ut_setup, ut_teardown,
4231 test_mb_AES_GCM_authenticated_encryption_test_case_2),
4232 TEST_CASE_ST(ut_setup, ut_teardown,
4233 test_mb_AES_GCM_authenticated_encryption_test_case_3),
4234 TEST_CASE_ST(ut_setup, ut_teardown,
4235 test_mb_AES_GCM_authenticated_encryption_test_case_4),
4236 TEST_CASE_ST(ut_setup, ut_teardown,
4237 test_mb_AES_GCM_authenticated_encryption_test_case_5),
4238 TEST_CASE_ST(ut_setup, ut_teardown,
4239 test_mb_AES_GCM_authenticated_encryption_test_case_6),
4240 TEST_CASE_ST(ut_setup, ut_teardown,
4241 test_mb_AES_GCM_authenticated_encryption_test_case_7),
4243 /** AES GCM Authenticated Decryption */
4244 TEST_CASE_ST(ut_setup, ut_teardown,
4245 test_mb_AES_GCM_authenticated_decryption_test_case_1),
4246 TEST_CASE_ST(ut_setup, ut_teardown,
4247 test_mb_AES_GCM_authenticated_decryption_test_case_2),
4248 TEST_CASE_ST(ut_setup, ut_teardown,
4249 test_mb_AES_GCM_authenticated_decryption_test_case_3),
4250 TEST_CASE_ST(ut_setup, ut_teardown,
4251 test_mb_AES_GCM_authenticated_decryption_test_case_4),
4252 TEST_CASE_ST(ut_setup, ut_teardown,
4253 test_mb_AES_GCM_authenticated_decryption_test_case_5),
4254 TEST_CASE_ST(ut_setup, ut_teardown,
4255 test_mb_AES_GCM_authenticated_decryption_test_case_6),
4256 TEST_CASE_ST(ut_setup, ut_teardown,
4257 test_mb_AES_GCM_authenticated_decryption_test_case_7),
4259 /** Snow3G encrypt only (UEA2) */
4260 TEST_CASE_ST(ut_setup, ut_teardown,
4261 test_snow3g_encryption_test_case_1),
4262 TEST_CASE_ST(ut_setup, ut_teardown,
4263 test_snow3g_encryption_test_case_2),
4264 TEST_CASE_ST(ut_setup, ut_teardown,
4265 test_snow3g_encryption_test_case_3),
4266 TEST_CASE_ST(ut_setup, ut_teardown,
4267 test_snow3g_encryption_test_case_4),
4268 TEST_CASE_ST(ut_setup, ut_teardown,
4269 test_snow3g_encryption_test_case_5),
4271 TEST_CASE_ST(ut_setup, ut_teardown,
4272 test_snow3g_encryption_test_case_1_oop),
4273 TEST_CASE_ST(ut_setup, ut_teardown,
4274 test_snow3g_decryption_test_case_1_oop),
4276 /** Snow3G decrypt only (UEA2) */
4277 TEST_CASE_ST(ut_setup, ut_teardown,
4278 test_snow3g_decryption_test_case_1),
4279 TEST_CASE_ST(ut_setup, ut_teardown,
4280 test_snow3g_decryption_test_case_2),
4281 TEST_CASE_ST(ut_setup, ut_teardown,
4282 test_snow3g_decryption_test_case_3),
4283 TEST_CASE_ST(ut_setup, ut_teardown,
4284 test_snow3g_decryption_test_case_4),
4285 TEST_CASE_ST(ut_setup, ut_teardown,
4286 test_snow3g_decryption_test_case_5),
4287 TEST_CASE_ST(ut_setup, ut_teardown,
4288 test_snow3g_hash_generate_test_case_1),
4289 TEST_CASE_ST(ut_setup, ut_teardown,
4290 test_snow3g_hash_generate_test_case_2),
4291 TEST_CASE_ST(ut_setup, ut_teardown,
4292 test_snow3g_hash_generate_test_case_3),
4293 TEST_CASE_ST(ut_setup, ut_teardown,
4294 test_snow3g_hash_verify_test_case_1),
4295 TEST_CASE_ST(ut_setup, ut_teardown,
4296 test_snow3g_hash_verify_test_case_2),
4297 TEST_CASE_ST(ut_setup, ut_teardown,
4298 test_snow3g_hash_verify_test_case_3),
4299 TEST_CASE_ST(ut_setup, ut_teardown,
4300 test_snow3g_cipher_auth_test_case_1),
4301 TEST_CASE_ST(ut_setup, ut_teardown,
4302 test_snow3g_auth_cipher_test_case_1),
4304 /** HMAC_MD5 Authentication */
4305 TEST_CASE_ST(ut_setup, ut_teardown,
4306 test_MD5_HMAC_generate_case_1),
4307 TEST_CASE_ST(ut_setup, ut_teardown,
4308 test_MD5_HMAC_verify_case_1),
4309 TEST_CASE_ST(ut_setup, ut_teardown,
4310 test_MD5_HMAC_generate_case_2),
4311 TEST_CASE_ST(ut_setup, ut_teardown,
4312 test_MD5_HMAC_verify_case_2),
4315 TEST_CASE_ST(ut_setup, ut_teardown,
4316 test_null_auth_only_operation),
4317 TEST_CASE_ST(ut_setup, ut_teardown,
4318 test_null_cipher_only_operation),
4319 TEST_CASE_ST(ut_setup, ut_teardown,
4320 test_null_cipher_auth_operation),
4321 TEST_CASE_ST(ut_setup, ut_teardown,
4322 test_null_auth_cipher_operation),
4324 TEST_CASE_ST(ut_setup, ut_teardown,
4325 test_kasumi_hash_generate_test_case_6),
4328 TEST_CASE_ST(ut_setup, ut_teardown,
4329 test_kasumi_encryption_test_case_1),
4330 TEST_CASE_ST(ut_setup, ut_teardown,
4331 test_kasumi_encryption_test_case_3),
4332 TEST_CASE_ST(ut_setup, ut_teardown,
4333 test_kasumi_auth_cipher_test_case_1),
4334 TEST_CASE_ST(ut_setup, ut_teardown,
4335 test_kasumi_cipher_auth_test_case_1),
4337 TEST_CASES_END() /**< NULL terminate unit test array */
4341 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
4342 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4343 .setup = testsuite_setup,
4344 .teardown = testsuite_teardown,
4345 .unit_test_cases = {
4346 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_mb_all),
4348 TEST_CASES_END() /**< NULL terminate unit test array */
4352 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = {
4353 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4354 .setup = testsuite_setup,
4355 .teardown = testsuite_teardown,
4356 .unit_test_cases = {
4357 /** AES GCM Authenticated Encryption */
4358 TEST_CASE_ST(ut_setup, ut_teardown,
4359 test_mb_AES_GCM_authenticated_encryption_test_case_1),
4360 TEST_CASE_ST(ut_setup, ut_teardown,
4361 test_mb_AES_GCM_authenticated_encryption_test_case_2),
4362 TEST_CASE_ST(ut_setup, ut_teardown,
4363 test_mb_AES_GCM_authenticated_encryption_test_case_3),
4364 TEST_CASE_ST(ut_setup, ut_teardown,
4365 test_mb_AES_GCM_authenticated_encryption_test_case_4),
4366 TEST_CASE_ST(ut_setup, ut_teardown,
4367 test_mb_AES_GCM_authenticated_encryption_test_case_5),
4368 TEST_CASE_ST(ut_setup, ut_teardown,
4369 test_mb_AES_GCM_authenticated_encryption_test_case_6),
4370 TEST_CASE_ST(ut_setup, ut_teardown,
4371 test_mb_AES_GCM_authenticated_encryption_test_case_7),
4373 /** AES GCM Authenticated Decryption */
4374 TEST_CASE_ST(ut_setup, ut_teardown,
4375 test_mb_AES_GCM_authenticated_decryption_test_case_1),
4376 TEST_CASE_ST(ut_setup, ut_teardown,
4377 test_mb_AES_GCM_authenticated_decryption_test_case_2),
4378 TEST_CASE_ST(ut_setup, ut_teardown,
4379 test_mb_AES_GCM_authenticated_decryption_test_case_3),
4380 TEST_CASE_ST(ut_setup, ut_teardown,
4381 test_mb_AES_GCM_authenticated_decryption_test_case_4),
4382 TEST_CASE_ST(ut_setup, ut_teardown,
4383 test_mb_AES_GCM_authenticated_decryption_test_case_5),
4384 TEST_CASE_ST(ut_setup, ut_teardown,
4385 test_mb_AES_GCM_authenticated_decryption_test_case_6),
4386 TEST_CASE_ST(ut_setup, ut_teardown,
4387 test_mb_AES_GCM_authenticated_decryption_test_case_7),
4389 TEST_CASES_END() /**< NULL terminate unit test array */
4393 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = {
4394 .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
4395 .setup = testsuite_setup,
4396 .teardown = testsuite_teardown,
4397 .unit_test_cases = {
4398 /** KASUMI encrypt only (UEA1) */
4399 TEST_CASE_ST(ut_setup, ut_teardown,
4400 test_kasumi_encryption_test_case_1),
4401 TEST_CASE_ST(ut_setup, ut_teardown,
4402 test_kasumi_encryption_test_case_2),
4403 TEST_CASE_ST(ut_setup, ut_teardown,
4404 test_kasumi_encryption_test_case_3),
4405 TEST_CASE_ST(ut_setup, ut_teardown,
4406 test_kasumi_encryption_test_case_4),
4407 TEST_CASE_ST(ut_setup, ut_teardown,
4408 test_kasumi_encryption_test_case_5),
4409 /** KASUMI decrypt only (UEA1) */
4410 TEST_CASE_ST(ut_setup, ut_teardown,
4411 test_kasumi_decryption_test_case_1),
4412 TEST_CASE_ST(ut_setup, ut_teardown,
4413 test_kasumi_decryption_test_case_2),
4414 TEST_CASE_ST(ut_setup, ut_teardown,
4415 test_kasumi_decryption_test_case_3),
4416 TEST_CASE_ST(ut_setup, ut_teardown,
4417 test_kasumi_decryption_test_case_4),
4418 TEST_CASE_ST(ut_setup, ut_teardown,
4419 test_kasumi_decryption_test_case_5),
4421 TEST_CASE_ST(ut_setup, ut_teardown,
4422 test_kasumi_encryption_test_case_1_oop),
4423 TEST_CASE_ST(ut_setup, ut_teardown,
4424 test_kasumi_decryption_test_case_1_oop),
4426 /** KASUMI hash only (UIA1) */
4427 TEST_CASE_ST(ut_setup, ut_teardown,
4428 test_kasumi_hash_generate_test_case_1),
4429 TEST_CASE_ST(ut_setup, ut_teardown,
4430 test_kasumi_hash_generate_test_case_2),
4431 TEST_CASE_ST(ut_setup, ut_teardown,
4432 test_kasumi_hash_generate_test_case_3),
4433 TEST_CASE_ST(ut_setup, ut_teardown,
4434 test_kasumi_hash_generate_test_case_4),
4435 TEST_CASE_ST(ut_setup, ut_teardown,
4436 test_kasumi_hash_generate_test_case_5),
4437 TEST_CASE_ST(ut_setup, ut_teardown,
4438 test_kasumi_hash_generate_test_case_6),
4439 TEST_CASE_ST(ut_setup, ut_teardown,
4440 test_kasumi_hash_verify_test_case_1),
4441 TEST_CASE_ST(ut_setup, ut_teardown,
4442 test_kasumi_hash_verify_test_case_2),
4443 TEST_CASE_ST(ut_setup, ut_teardown,
4444 test_kasumi_hash_verify_test_case_3),
4445 TEST_CASE_ST(ut_setup, ut_teardown,
4446 test_kasumi_hash_verify_test_case_4),
4447 TEST_CASE_ST(ut_setup, ut_teardown,
4448 test_kasumi_hash_verify_test_case_5),
4449 TEST_CASE_ST(ut_setup, ut_teardown,
4450 test_kasumi_auth_cipher_test_case_1),
4451 TEST_CASE_ST(ut_setup, ut_teardown,
4452 test_kasumi_cipher_auth_test_case_1),
4453 TEST_CASES_END() /**< NULL terminate unit test array */
4456 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = {
4457 .suite_name = "Crypto Device SW Snow3G Unit Test Suite",
4458 .setup = testsuite_setup,
4459 .teardown = testsuite_teardown,
4460 .unit_test_cases = {
4461 /** Snow3G encrypt only (UEA2) */
4462 TEST_CASE_ST(ut_setup, ut_teardown,
4463 test_snow3g_encryption_test_case_1),
4464 TEST_CASE_ST(ut_setup, ut_teardown,
4465 test_snow3g_encryption_test_case_2),
4466 TEST_CASE_ST(ut_setup, ut_teardown,
4467 test_snow3g_encryption_test_case_3),
4468 TEST_CASE_ST(ut_setup, ut_teardown,
4469 test_snow3g_encryption_test_case_4),
4470 TEST_CASE_ST(ut_setup, ut_teardown,
4471 test_snow3g_encryption_test_case_5),
4473 TEST_CASE_ST(ut_setup, ut_teardown,
4474 test_snow3g_encryption_test_case_1_oop),
4475 TEST_CASE_ST(ut_setup, ut_teardown,
4476 test_snow3g_decryption_test_case_1_oop),
4478 TEST_CASE_ST(ut_setup, ut_teardown,
4479 test_snow3g_encryption_test_case_1_offset_oop),
4481 /** Snow3G decrypt only (UEA2) */
4482 TEST_CASE_ST(ut_setup, ut_teardown,
4483 test_snow3g_decryption_test_case_1),
4484 TEST_CASE_ST(ut_setup, ut_teardown,
4485 test_snow3g_decryption_test_case_2),
4486 TEST_CASE_ST(ut_setup, ut_teardown,
4487 test_snow3g_decryption_test_case_3),
4488 TEST_CASE_ST(ut_setup, ut_teardown,
4489 test_snow3g_decryption_test_case_4),
4490 TEST_CASE_ST(ut_setup, ut_teardown,
4491 test_snow3g_decryption_test_case_5),
4492 TEST_CASE_ST(ut_setup, ut_teardown,
4493 test_snow3g_hash_generate_test_case_1),
4494 TEST_CASE_ST(ut_setup, ut_teardown,
4495 test_snow3g_hash_generate_test_case_2),
4496 TEST_CASE_ST(ut_setup, ut_teardown,
4497 test_snow3g_hash_generate_test_case_3),
4498 /* Tests with buffers which length is not byte-aligned */
4499 TEST_CASE_ST(ut_setup, ut_teardown,
4500 test_snow3g_hash_generate_test_case_4),
4501 TEST_CASE_ST(ut_setup, ut_teardown,
4502 test_snow3g_hash_generate_test_case_5),
4503 TEST_CASE_ST(ut_setup, ut_teardown,
4504 test_snow3g_hash_generate_test_case_6),
4505 TEST_CASE_ST(ut_setup, ut_teardown,
4506 test_snow3g_hash_verify_test_case_1),
4507 TEST_CASE_ST(ut_setup, ut_teardown,
4508 test_snow3g_hash_verify_test_case_2),
4509 TEST_CASE_ST(ut_setup, ut_teardown,
4510 test_snow3g_hash_verify_test_case_3),
4511 /* Tests with buffers which length is not byte-aligned */
4512 TEST_CASE_ST(ut_setup, ut_teardown,
4513 test_snow3g_hash_verify_test_case_4),
4514 TEST_CASE_ST(ut_setup, ut_teardown,
4515 test_snow3g_hash_verify_test_case_5),
4516 TEST_CASE_ST(ut_setup, ut_teardown,
4517 test_snow3g_hash_verify_test_case_6),
4518 TEST_CASE_ST(ut_setup, ut_teardown,
4519 test_snow3g_cipher_auth_test_case_1),
4520 TEST_CASE_ST(ut_setup, ut_teardown,
4521 test_snow3g_auth_cipher_test_case_1),
4523 TEST_CASES_END() /**< NULL terminate unit test array */
4527 static struct unit_test_suite cryptodev_null_testsuite = {
4528 .suite_name = "Crypto Device NULL Unit Test Suite",
4529 .setup = testsuite_setup,
4530 .teardown = testsuite_teardown,
4531 .unit_test_cases = {
4532 TEST_CASE_ST(ut_setup, ut_teardown,
4533 test_null_auth_only_operation),
4534 TEST_CASE_ST(ut_setup, ut_teardown,
4535 test_null_cipher_only_operation),
4536 TEST_CASE_ST(ut_setup, ut_teardown,
4537 test_null_cipher_auth_operation),
4538 TEST_CASE_ST(ut_setup, ut_teardown,
4539 test_null_auth_cipher_operation),
4540 TEST_CASE_ST(ut_setup, ut_teardown,
4541 test_null_invalid_operation),
4542 TEST_CASE_ST(ut_setup, ut_teardown,
4543 test_null_burst_operation),
4545 TEST_CASES_END() /**< NULL terminate unit test array */
4550 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
4552 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
4553 return unit_test_suite_runner(&cryptodev_qat_testsuite);
4557 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
4559 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
4561 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
4565 test_cryptodev_aesni_gcm(void)
4567 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
4569 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
4573 test_cryptodev_null(void)
4575 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
4577 return unit_test_suite_runner(&cryptodev_null_testsuite);
4581 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
4583 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
4585 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
4589 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
4591 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
4593 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
4596 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
4597 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
4598 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
4599 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
4600 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
4601 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);