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 static enum rte_cryptodev_type gbl_cryptodev_type;
48 struct crypto_testsuite_params {
49 struct rte_mempool *mbuf_pool;
50 struct rte_mempool *op_mpool;
51 struct rte_cryptodev_config conf;
52 struct rte_cryptodev_qp_conf qp_conf;
54 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
55 uint8_t valid_dev_count;
58 struct crypto_unittest_params {
59 struct rte_crypto_sym_xform cipher_xform;
60 struct rte_crypto_sym_xform auth_xform;
62 struct rte_cryptodev_sym_session *sess;
64 struct rte_crypto_op *op;
66 struct rte_mbuf *obuf, *ibuf;
72 * Forward declarations.
75 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
76 struct crypto_unittest_params *ut_params);
79 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
80 struct crypto_unittest_params *ut_params,
81 struct crypto_testsuite_params *ts_param);
83 static struct rte_mbuf *
84 setup_test_string(struct rte_mempool *mpool,
85 const char *string, size_t len, uint8_t blocksize)
87 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
88 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
90 memset(m->buf_addr, 0, m->buf_len);
92 char *dst = rte_pktmbuf_append(m, t_len);
99 rte_memcpy(dst, string, t_len);
107 hexdump_mbuf_data(FILE *f, const char *title, struct rte_mbuf *m)
109 rte_hexdump(f, title, rte_pktmbuf_mtod(m, const void *), m->data_len);
113 static struct rte_crypto_op *
114 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
117 hexdump_mbuf_data(stdout, "Enqueued Packet", ibuf);
120 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
121 printf("Error sending packet for encryption");
127 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
132 hexdump_mbuf_data(stdout, "Dequeued Packet", obuf);
138 static struct crypto_testsuite_params testsuite_params = { NULL };
139 static struct crypto_unittest_params unittest_params;
142 testsuite_setup(void)
144 struct crypto_testsuite_params *ts_params = &testsuite_params;
145 struct rte_cryptodev_info info;
146 unsigned i, nb_devs, dev_id;
150 memset(ts_params, 0, sizeof(*ts_params));
152 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
153 if (ts_params->mbuf_pool == NULL) {
154 /* Not already created so create */
155 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
157 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
159 if (ts_params->mbuf_pool == NULL) {
160 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
165 ts_params->op_mpool = rte_crypto_op_pool_create(
166 "MBUF_CRYPTO_SYM_OP_POOL",
167 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
168 NUM_MBUFS, MBUF_CACHE_SIZE,
170 sizeof(struct rte_crypto_sym_xform),
172 if (ts_params->op_mpool == NULL) {
173 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
177 /* Create 2 AESNI MB devices if required */
178 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
179 nb_devs = rte_cryptodev_count_devtype(
180 RTE_CRYPTODEV_AESNI_MB_PMD);
182 for (i = nb_devs; i < 2; i++) {
183 ret = rte_eal_vdev_init(
184 CRYPTODEV_NAME_AESNI_MB_PMD, NULL);
186 TEST_ASSERT(ret == 0,
187 "Failed to create instance %u of"
189 i, CRYPTODEV_NAME_AESNI_MB_PMD);
194 nb_devs = rte_cryptodev_count();
196 RTE_LOG(ERR, USER1, "No crypto devices found?");
200 /* Create list of valid crypto devs */
201 for (i = 0; i < nb_devs; i++) {
202 rte_cryptodev_info_get(i, &info);
203 if (info.dev_type == gbl_cryptodev_type)
204 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
207 if (ts_params->valid_dev_count < 1)
210 /* Set up all the qps on the first of the valid devices found */
211 for (i = 0; i < 1; i++) {
212 dev_id = ts_params->valid_devs[i];
214 rte_cryptodev_info_get(dev_id, &info);
217 * Since we can't free and re-allocate queue memory always set
218 * the queues on this device up to max size first so enough
219 * memory is allocated for any later re-configures needed by
223 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
224 ts_params->conf.socket_id = SOCKET_ID_ANY;
225 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
227 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
229 "Failed to configure cryptodev %u with %u qps",
230 dev_id, ts_params->conf.nb_queue_pairs);
232 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
234 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
235 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
236 dev_id, qp_id, &ts_params->qp_conf,
237 rte_cryptodev_socket_id(dev_id)),
238 "Failed to setup queue pair %u on "
248 testsuite_teardown(void)
250 struct crypto_testsuite_params *ts_params = &testsuite_params;
252 if (ts_params->mbuf_pool != NULL) {
253 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
254 rte_mempool_count(ts_params->mbuf_pool));
257 if (ts_params->op_mpool != NULL) {
258 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
259 rte_mempool_count(ts_params->op_mpool));
267 struct crypto_testsuite_params *ts_params = &testsuite_params;
268 struct crypto_unittest_params *ut_params = &unittest_params;
272 /* Clear unit test parameters before running test */
273 memset(ut_params, 0, sizeof(*ut_params));
275 /* Reconfigure device to default parameters */
276 ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE;
277 ts_params->conf.socket_id = SOCKET_ID_ANY;
278 ts_params->conf.session_mp.nb_objs =
279 (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) ?
280 DEFAULT_NUM_OPS_INFLIGHT :
281 DEFAULT_NUM_OPS_INFLIGHT;
283 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
285 "Failed to configure cryptodev %u",
286 ts_params->valid_devs[0]);
289 * Now reconfigure queues to size we actually want to use in this
292 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
294 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
295 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
296 ts_params->valid_devs[0], qp_id,
298 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
299 "Failed to setup queue pair %u on cryptodev %u",
300 qp_id, ts_params->valid_devs[0]);
304 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
306 /* Start the device */
307 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
308 "Failed to start cryptodev %u",
309 ts_params->valid_devs[0]);
317 struct crypto_testsuite_params *ts_params = &testsuite_params;
318 struct crypto_unittest_params *ut_params = &unittest_params;
319 struct rte_cryptodev_stats stats;
321 /* free crypto session structure */
322 if (ut_params->sess) {
323 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
325 ut_params->sess = NULL;
328 /* free crypto operation structure */
330 rte_crypto_op_free(ut_params->op);
333 * free mbuf - both obuf and ibuf are usually the same,
334 * but rte copes even if we call free twice
336 if (ut_params->obuf) {
337 rte_pktmbuf_free(ut_params->obuf);
340 if (ut_params->ibuf) {
341 rte_pktmbuf_free(ut_params->ibuf);
345 if (ts_params->mbuf_pool != NULL)
346 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
347 rte_mempool_count(ts_params->mbuf_pool));
349 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
351 /* Stop the device */
352 rte_cryptodev_stop(ts_params->valid_devs[0]);
356 test_device_configure_invalid_dev_id(void)
358 struct crypto_testsuite_params *ts_params = &testsuite_params;
359 uint16_t dev_id, num_devs = 0;
361 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
362 "Need at least %d devices for test", 1);
364 /* valid dev_id values */
365 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
367 /* Stop the device in case it's started so it can be configured */
368 rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
370 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
371 "Failed test for rte_cryptodev_configure: "
372 "invalid dev_num %u", dev_id);
374 /* invalid dev_id values */
377 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
378 "Failed test for rte_cryptodev_configure: "
379 "invalid dev_num %u", dev_id);
383 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
384 "Failed test for rte_cryptodev_configure:"
385 "invalid dev_num %u", dev_id);
391 test_device_configure_invalid_queue_pair_ids(void)
393 struct crypto_testsuite_params *ts_params = &testsuite_params;
395 /* Stop the device in case it's started so it can be configured */
396 rte_cryptodev_stop(ts_params->valid_devs[0]);
398 /* valid - one queue pairs */
399 ts_params->conf.nb_queue_pairs = 1;
401 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
403 "Failed to configure cryptodev: dev_id %u, qp_id %u",
404 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
407 /* valid - max value queue pairs */
408 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
410 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
412 "Failed to configure cryptodev: dev_id %u, qp_id %u",
413 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
416 /* invalid - zero queue pairs */
417 ts_params->conf.nb_queue_pairs = 0;
419 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
421 "Failed test for rte_cryptodev_configure, dev_id %u,"
423 ts_params->valid_devs[0],
424 ts_params->conf.nb_queue_pairs);
427 /* invalid - max value supported by field queue pairs */
428 ts_params->conf.nb_queue_pairs = UINT16_MAX;
430 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
432 "Failed test for rte_cryptodev_configure, dev_id %u,"
434 ts_params->valid_devs[0],
435 ts_params->conf.nb_queue_pairs);
438 /* invalid - max value + 1 queue pairs */
439 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
441 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
443 "Failed test for rte_cryptodev_configure, dev_id %u,"
445 ts_params->valid_devs[0],
446 ts_params->conf.nb_queue_pairs);
452 test_queue_pair_descriptor_setup(void)
454 struct crypto_testsuite_params *ts_params = &testsuite_params;
455 struct rte_cryptodev_info dev_info;
456 struct rte_cryptodev_qp_conf qp_conf = {
457 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
462 /* Stop the device in case it's started so it can be configured */
463 rte_cryptodev_stop(ts_params->valid_devs[0]);
466 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
468 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
470 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
471 &ts_params->conf), "Failed to configure cryptodev %u",
472 ts_params->valid_devs[0]);
476 * Test various ring sizes on this device. memzones can't be
477 * freed so are re-used if ring is released and re-created.
479 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
481 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
482 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
483 ts_params->valid_devs[0], qp_id, &qp_conf,
484 rte_cryptodev_socket_id(
485 ts_params->valid_devs[0])),
487 "rte_cryptodev_queue_pair_setup: num_inflights "
488 "%u on qp %u on cryptodev %u",
489 qp_conf.nb_descriptors, qp_id,
490 ts_params->valid_devs[0]);
493 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
495 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
496 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
497 ts_params->valid_devs[0], qp_id, &qp_conf,
498 rte_cryptodev_socket_id(
499 ts_params->valid_devs[0])),
501 " rte_cryptodev_queue_pair_setup: num_inflights"
502 " %u on qp %u on cryptodev %u",
503 qp_conf.nb_descriptors, qp_id,
504 ts_params->valid_devs[0]);
507 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
509 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
510 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
511 ts_params->valid_devs[0], qp_id, &qp_conf,
512 rte_cryptodev_socket_id(
513 ts_params->valid_devs[0])),
515 "rte_cryptodev_queue_pair_setup: num_inflights"
516 " %u on qp %u on cryptodev %u",
517 qp_conf.nb_descriptors, qp_id,
518 ts_params->valid_devs[0]);
521 /* invalid number of descriptors - max supported + 2 */
522 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
524 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
525 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
526 ts_params->valid_devs[0], qp_id, &qp_conf,
527 rte_cryptodev_socket_id(
528 ts_params->valid_devs[0])),
529 "Unexpectedly passed test for "
530 "rte_cryptodev_queue_pair_setup:"
531 "num_inflights %u on qp %u on cryptodev %u",
532 qp_conf.nb_descriptors, qp_id,
533 ts_params->valid_devs[0]);
536 /* invalid number of descriptors - max value of parameter */
537 qp_conf.nb_descriptors = UINT32_MAX-1;
539 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
540 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
541 ts_params->valid_devs[0], qp_id, &qp_conf,
542 rte_cryptodev_socket_id(
543 ts_params->valid_devs[0])),
544 "Unexpectedly passed test for "
545 "rte_cryptodev_queue_pair_setup:"
546 "num_inflights %u on qp %u on cryptodev %u",
547 qp_conf.nb_descriptors, qp_id,
548 ts_params->valid_devs[0]);
551 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
553 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
554 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
555 ts_params->valid_devs[0], qp_id, &qp_conf,
556 rte_cryptodev_socket_id(
557 ts_params->valid_devs[0])),
559 " rte_cryptodev_queue_pair_setup:"
560 "num_inflights %u on qp %u on cryptodev %u",
561 qp_conf.nb_descriptors, qp_id,
562 ts_params->valid_devs[0]);
565 /* invalid number of descriptors - max supported + 1 */
566 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
568 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
569 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
570 ts_params->valid_devs[0], qp_id, &qp_conf,
571 rte_cryptodev_socket_id(
572 ts_params->valid_devs[0])),
573 "Unexpectedly passed test for "
574 "rte_cryptodev_queue_pair_setup:"
575 "num_inflights %u on qp %u on cryptodev %u",
576 qp_conf.nb_descriptors, qp_id,
577 ts_params->valid_devs[0]);
580 /* test invalid queue pair id */
581 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
583 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */
585 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
586 ts_params->valid_devs[0],
588 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
589 "Failed test for rte_cryptodev_queue_pair_setup:"
590 "invalid qp %u on cryptodev %u",
591 qp_id, ts_params->valid_devs[0]);
593 qp_id = 0xffff; /*invalid*/
595 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
596 ts_params->valid_devs[0],
598 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
599 "Failed test for rte_cryptodev_queue_pair_setup:"
600 "invalid qp %u on cryptodev %u",
601 qp_id, ts_params->valid_devs[0]);
606 /* ***** Plaintext data for tests ***** */
608 const char catch_22_quote_1[] =
609 "There was only one catch and that was Catch-22, which "
610 "specified that a concern for one's safety in the face of "
611 "dangers that were real and immediate was the process of a "
612 "rational mind. Orr was crazy and could be grounded. All he "
613 "had to do was ask; and as soon as he did, he would no longer "
614 "be crazy and would have to fly more missions. Orr would be "
615 "crazy to fly more missions and sane if he didn't, but if he "
616 "was sane he had to fly them. If he flew them he was crazy "
617 "and didn't have to; but if he didn't want to he was sane and "
618 "had to. Yossarian was moved very deeply by the absolute "
619 "simplicity of this clause of Catch-22 and let out a "
620 "respectful whistle. \"That's some catch, that Catch-22\", he "
621 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
623 const char catch_22_quote[] =
624 "What a lousy earth! He wondered how many people were "
625 "destitute that same night even in his own prosperous country, "
626 "how many homes were shanties, how many husbands were drunk "
627 "and wives socked, and how many children were bullied, abused, "
628 "or abandoned. How many families hungered for food they could "
629 "not afford to buy? How many hearts were broken? How many "
630 "suicides would take place that same night, how many people "
631 "would go insane? How many cockroaches and landlords would "
632 "triumph? How many winners were losers, successes failures, "
633 "and rich men poor men? How many wise guys were stupid? How "
634 "many happy endings were unhappy endings? How many honest men "
635 "were liars, brave men cowards, loyal men traitors, how many "
636 "sainted men were corrupt, how many people in positions of "
637 "trust had sold their souls to bodyguards, how many had never "
638 "had souls? How many straight-and-narrow paths were crooked "
639 "paths? How many best families were worst families and how "
640 "many good people were bad people? When you added them all up "
641 "and then subtracted, you might be left with only the children, "
642 "and perhaps with Albert Einstein and an old violinist or "
643 "sculptor somewhere.";
645 #define QUOTE_480_BYTES (480)
646 #define QUOTE_512_BYTES (512)
647 #define QUOTE_768_BYTES (768)
648 #define QUOTE_1024_BYTES (1024)
652 /* ***** SHA1 Hash Tests ***** */
654 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
656 static uint8_t hmac_sha1_key[] = {
657 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
658 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
659 0xDE, 0xF4, 0xDE, 0xAD };
661 /* ***** SHA224 Hash Tests ***** */
663 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
666 /* ***** AES-CBC Cipher Tests ***** */
668 #define CIPHER_KEY_LENGTH_AES_CBC (16)
669 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
671 static uint8_t aes_cbc_key[] = {
672 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
673 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
675 static uint8_t aes_cbc_iv[] = {
676 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
677 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
680 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
682 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
683 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
684 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
685 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
686 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
687 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
688 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
689 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
690 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
691 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
692 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
693 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
694 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
695 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
696 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
697 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
698 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
699 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
700 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
701 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
702 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
703 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
704 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
705 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
706 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
707 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
708 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
709 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
710 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
711 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
712 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
713 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
714 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
715 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
716 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
717 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
718 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
719 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
720 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
721 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
722 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
723 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
724 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
725 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
726 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
727 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
728 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
729 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
730 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
731 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
732 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
733 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
734 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
735 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
736 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
737 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
738 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
739 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
740 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
741 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
742 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
743 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
744 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
745 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
746 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
749 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
750 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
751 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
752 0x18, 0x8c, 0x1d, 0x32
757 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
759 struct crypto_testsuite_params *ts_params = &testsuite_params;
760 struct crypto_unittest_params *ut_params = &unittest_params;
762 /* Generate test mbuf data and space for digest */
763 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
764 catch_22_quote, QUOTE_512_BYTES, 0);
766 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
767 DIGEST_BYTE_LENGTH_SHA1);
768 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
770 /* Setup Cipher Parameters */
771 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
772 ut_params->cipher_xform.next = &ut_params->auth_xform;
774 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
775 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
776 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
777 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
779 /* Setup HMAC Parameters */
780 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
782 ut_params->auth_xform.next = NULL;
784 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
785 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
786 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
787 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
788 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
790 /* Create crypto session*/
791 ut_params->sess = rte_cryptodev_sym_session_create(
792 ts_params->valid_devs[0],
793 &ut_params->cipher_xform);
794 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
796 /* Generate crypto op data structure */
797 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
798 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
799 TEST_ASSERT_NOT_NULL(ut_params->op,
800 "Failed to allocate symmetric crypto operation struct");
802 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
804 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
806 /* set crypto operation source mbuf */
807 sym_op->m_src = ut_params->ibuf;
809 /* Set crypto operation authentication parameters */
810 sym_op->auth.digest.data = ut_params->digest;
811 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
812 ut_params->ibuf, QUOTE_512_BYTES);
813 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
815 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
816 sym_op->auth.data.length = QUOTE_512_BYTES;
818 /* Set crypto operation cipher parameters */
819 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
820 CIPHER_IV_LENGTH_AES_CBC);
821 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
822 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
824 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
825 CIPHER_IV_LENGTH_AES_CBC);
827 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
828 sym_op->cipher.data.length = QUOTE_512_BYTES;
830 /* Process crypto operation */
831 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
832 ut_params->op), "failed to process sym crypto op");
834 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
835 "crypto op processing failed");
838 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
839 uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
841 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
842 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
844 "ciphertext data not as expected");
846 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
848 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
849 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
850 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
851 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
852 DIGEST_BYTE_LENGTH_SHA1,
853 "Generated digest data not as expected");
859 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless(void)
861 struct crypto_testsuite_params *ts_params = &testsuite_params;
862 struct crypto_unittest_params *ut_params = &unittest_params;
864 /* Generate test mbuf data and space for digest */
865 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
866 catch_22_quote, QUOTE_512_BYTES, 0);
868 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
869 DIGEST_BYTE_LENGTH_SHA1);
870 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
872 /* Generate Crypto op data structure */
873 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
874 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
875 TEST_ASSERT_NOT_NULL(ut_params->op,
876 "Failed to allocate symmetric crypto operation struct");
878 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(ut_params->op, 2),
879 "failed to allocate space for crypto transforms");
881 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
883 /* set crypto operation source mbuf */
884 sym_op->m_src = ut_params->ibuf;
886 /* Set crypto operation data parameters */
887 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
889 /* cipher parameters */
890 sym_op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
891 sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
892 sym_op->xform->cipher.key.data = aes_cbc_key;
893 sym_op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
895 /* hash parameters */
896 sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
898 sym_op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
899 sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
900 sym_op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1;
901 sym_op->xform->next->auth.key.data = hmac_sha1_key;
902 sym_op->xform->next->auth.digest_length =
903 DIGEST_BYTE_LENGTH_SHA1;
905 sym_op->auth.digest.data = ut_params->digest;
906 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
907 ut_params->ibuf, QUOTE_512_BYTES);
908 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
911 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
912 sym_op->auth.data.length = QUOTE_512_BYTES;
914 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
915 CIPHER_IV_LENGTH_AES_CBC);
916 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
917 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
919 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
920 CIPHER_IV_LENGTH_AES_CBC);
922 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
923 sym_op->cipher.data.length = QUOTE_512_BYTES;
925 /* Process crypto operation */
926 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
927 ut_params->op), "failed to process sym crypto op");
929 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
930 "crypto op processing failed");
932 ut_params->obuf = ut_params->op->sym->m_src;
935 TEST_ASSERT_BUFFERS_ARE_EQUAL(
936 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
937 CIPHER_IV_LENGTH_AES_CBC,
938 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
940 "Ciphertext data not as expected");
942 TEST_ASSERT_BUFFERS_ARE_EQUAL(
943 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
944 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
945 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
946 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
947 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
948 DIGEST_BYTE_LENGTH_SHA1,
949 "Generated digest data not as expected");
956 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify(void)
958 struct crypto_testsuite_params *ts_params = &testsuite_params;
959 struct crypto_unittest_params *ut_params = &unittest_params;
961 /* Generate test mbuf data and digest */
962 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
964 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
967 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
968 DIGEST_BYTE_LENGTH_SHA1);
969 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
971 rte_memcpy(ut_params->digest,
972 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
973 DIGEST_BYTE_LENGTH_SHA1);
975 /* Setup Cipher Parameters */
976 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
977 ut_params->cipher_xform.next = NULL;
979 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
980 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
981 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
982 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
984 /* Setup HMAC Parameters */
985 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
986 ut_params->auth_xform.next = &ut_params->cipher_xform;
988 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
989 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
990 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
991 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
992 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
994 /* Create Crypto session*/
996 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
997 &ut_params->auth_xform);
998 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1000 /* Generate Crypto op data structure */
1001 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1002 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1003 TEST_ASSERT_NOT_NULL(ut_params->op,
1004 "Failed to allocate symmetric crypto operation struct");
1006 /* attach symmetric crypto session to crypto operations */
1007 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1009 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1011 /* set crypto operation source mbuf */
1012 sym_op->m_src = ut_params->ibuf;
1014 sym_op->auth.digest.data = ut_params->digest;
1015 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1016 ut_params->ibuf, QUOTE_512_BYTES);
1017 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1019 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1020 sym_op->auth.data.length = QUOTE_512_BYTES;
1022 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1023 CIPHER_IV_LENGTH_AES_CBC);
1024 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1025 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1027 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1028 CIPHER_IV_LENGTH_AES_CBC);
1030 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1031 sym_op->cipher.data.length = QUOTE_512_BYTES;
1034 /* Process crypto operation */
1035 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1036 ut_params->op), "failed to process sym crypto op");
1038 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1039 "crypto op processing failed");
1041 ut_params->obuf = ut_params->op->sym->m_src;
1045 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1046 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1047 CIPHER_IV_LENGTH_AES_CBC,
1050 "Ciphertext data not as expected");
1052 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1053 "Digest verification failed");
1056 return TEST_SUCCESS;
1060 /* ***** AES-CBC / HMAC-SHA256 Hash Tests ***** */
1062 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
1064 static uint8_t hmac_sha256_key[] = {
1065 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1066 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1067 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1068 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
1070 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest[] = {
1071 0xc8, 0x57, 0x57, 0x31, 0x03, 0xe0, 0x03, 0x55,
1072 0x07, 0xc8, 0x9e, 0x7f, 0x48, 0x9a, 0x61, 0x9a,
1073 0x68, 0xee, 0x03, 0x0e, 0x71, 0x75, 0xc7, 0xf4,
1074 0x2e, 0x45, 0x26, 0x32, 0x7c, 0x12, 0x15, 0x15 };
1077 test_AES_CBC_HMAC_SHA256_encrypt_digest(void)
1079 struct crypto_testsuite_params *ts_params = &testsuite_params;
1080 struct crypto_unittest_params *ut_params = &unittest_params;
1082 /* Generate test mbuf data and space for digest */
1083 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1084 catch_22_quote, QUOTE_512_BYTES, 0);
1086 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1087 DIGEST_BYTE_LENGTH_SHA256);
1088 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1090 /* Setup Cipher Parameters */
1091 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1092 ut_params->cipher_xform.next = &ut_params->auth_xform;
1094 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1095 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1096 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1097 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1099 /* Setup HMAC Parameters */
1100 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1101 ut_params->auth_xform.next = NULL;
1103 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1104 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1105 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1106 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1107 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1109 /* Create Crypto session*/
1110 ut_params->sess = rte_cryptodev_sym_session_create(
1111 ts_params->valid_devs[0],
1112 &ut_params->cipher_xform);
1113 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1115 /* Generate Crypto op data structure */
1116 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1117 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1118 TEST_ASSERT_NOT_NULL(ut_params->op,
1119 "Failed to allocate symmetric crypto operation struct");
1121 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1123 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1125 /* set crypto operation source mbuf */
1126 sym_op->m_src = ut_params->ibuf;
1128 sym_op->auth.digest.data = ut_params->digest;
1129 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1130 ut_params->ibuf, QUOTE_512_BYTES);
1131 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1133 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1134 sym_op->auth.data.length = QUOTE_512_BYTES;
1136 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1137 CIPHER_IV_LENGTH_AES_CBC);
1138 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1139 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1141 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1142 CIPHER_IV_LENGTH_AES_CBC);
1144 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1145 sym_op->cipher.data.length = QUOTE_512_BYTES;
1147 /* Process crypto operation */
1148 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1149 ut_params->op), "failed to process sym crypto op");
1151 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1152 "crypto op processing failed");
1154 ut_params->obuf = ut_params->op->sym->m_src;
1157 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1158 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1159 CIPHER_IV_LENGTH_AES_CBC,
1160 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1162 "Ciphertext data not as expected");
1164 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1165 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1166 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1167 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1168 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1169 TRUNCATED_DIGEST_BYTE_LENGTH_SHA256 :
1170 DIGEST_BYTE_LENGTH_SHA256,
1171 "Generated digest data not as expected");
1174 return TEST_SUCCESS;
1178 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify(void)
1180 struct crypto_testsuite_params *ts_params = &testsuite_params;
1181 struct crypto_unittest_params *ut_params = &unittest_params;
1183 /* Generate test mbuf data and digest */
1184 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1186 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1187 QUOTE_512_BYTES, 0);
1189 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1190 DIGEST_BYTE_LENGTH_SHA256);
1191 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1193 rte_memcpy(ut_params->digest,
1194 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1195 DIGEST_BYTE_LENGTH_SHA256);
1197 /* Setup Cipher Parameters */
1198 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1199 ut_params->cipher_xform.next = NULL;
1201 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1202 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1203 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1204 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1206 /* Setup HMAC Parameters */
1207 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1208 ut_params->auth_xform.next = &ut_params->cipher_xform;
1210 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1211 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1212 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1213 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1214 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1216 /* Create Crypto session*/
1218 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1219 &ut_params->auth_xform);
1220 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1222 /* Generate Crypto op data structure */
1223 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1224 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1225 TEST_ASSERT_NOT_NULL(ut_params->op,
1226 "Failed to allocate symmetric crypto operation struct");
1229 /* Set crypto operation data parameters */
1230 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1232 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1234 /* set crypto operation source mbuf */
1235 sym_op->m_src = ut_params->ibuf;
1237 sym_op->auth.digest.data = ut_params->digest;
1238 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1239 ut_params->ibuf, QUOTE_512_BYTES);
1240 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1242 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1243 sym_op->auth.data.length = QUOTE_512_BYTES;
1245 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1246 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1247 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1248 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1250 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1251 CIPHER_IV_LENGTH_AES_CBC);
1253 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1254 sym_op->cipher.data.length = QUOTE_512_BYTES;
1256 /* Process crypto operation */
1257 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1258 ut_params->op), "failed to process sym crypto op");
1260 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1261 "crypto op processing failed");
1263 ut_params->obuf = ut_params->op->sym->m_src;
1266 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1267 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1268 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1270 "Plaintext data not as expected");
1272 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1273 "Digest verification failed");
1275 return TEST_SUCCESS;
1278 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1280 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1282 static uint8_t hmac_sha512_key[] = {
1283 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1284 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1285 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1286 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1287 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1288 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1289 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1290 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1292 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1293 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1294 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1295 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1296 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1297 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1298 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1299 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1300 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1303 test_AES_CBC_HMAC_SHA512_encrypt_digest(void)
1305 struct crypto_testsuite_params *ts_params = &testsuite_params;
1306 struct crypto_unittest_params *ut_params = &unittest_params;
1308 /* Generate test mbuf data and space for digest */
1309 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1310 catch_22_quote, QUOTE_512_BYTES, 0);
1312 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1313 DIGEST_BYTE_LENGTH_SHA512);
1314 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1316 /* Setup Cipher Parameters */
1317 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1318 ut_params->cipher_xform.next = &ut_params->auth_xform;
1320 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1321 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1322 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1323 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1325 /* Setup HMAC Parameters */
1326 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1327 ut_params->auth_xform.next = NULL;
1329 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1330 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1331 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1332 ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1333 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1335 /* Create Crypto session*/
1337 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1338 &ut_params->cipher_xform);
1340 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1342 /* Generate Crypto op data structure */
1343 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1344 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1345 TEST_ASSERT_NOT_NULL(ut_params->op,
1346 "Failed to allocate symmetric crypto operation struct");
1348 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1350 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1352 /* set crypto operation source mbuf */
1353 sym_op->m_src = ut_params->ibuf;
1355 sym_op->auth.digest.data = ut_params->digest;
1356 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1357 ut_params->ibuf, QUOTE_512_BYTES);
1358 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1360 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1361 sym_op->auth.data.length = QUOTE_512_BYTES;
1363 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1364 CIPHER_IV_LENGTH_AES_CBC);
1365 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1366 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1368 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1369 CIPHER_IV_LENGTH_AES_CBC);
1371 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1372 sym_op->cipher.data.length = QUOTE_512_BYTES;
1374 /* Process crypto operation */
1375 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1376 ut_params->op), "failed to process sym crypto op");
1378 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1379 "crypto op processing failed");
1381 ut_params->obuf = ut_params->op->sym->m_src;
1384 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1385 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1386 CIPHER_IV_LENGTH_AES_CBC,
1387 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1389 "Ciphertext data not as expected");
1391 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1392 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1393 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1394 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1395 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1396 TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 :
1397 DIGEST_BYTE_LENGTH_SHA512,
1398 "Generated digest data not as expected");
1400 return TEST_SUCCESS;
1405 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1406 struct crypto_unittest_params *ut_params);
1409 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1410 struct crypto_unittest_params *ut_params,
1411 struct crypto_testsuite_params *ts_params);
1414 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify(void)
1416 struct crypto_unittest_params *ut_params = &unittest_params;
1417 struct crypto_testsuite_params *ts_params = &testsuite_params;
1419 TEST_ASSERT(test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1420 ut_params) == TEST_SUCCESS,
1421 "Failed to create session params");
1423 /* Create Crypto session*/
1425 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1426 &ut_params->auth_xform);
1427 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1429 return test_AES_CBC_HMAC_SHA512_decrypt_perform(ut_params->sess,
1430 ut_params, ts_params);
1434 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1435 struct crypto_unittest_params *ut_params)
1438 /* Setup Cipher Parameters */
1439 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1440 ut_params->cipher_xform.next = NULL;
1442 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1443 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1444 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1445 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1447 /* Setup HMAC Parameters */
1448 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1449 ut_params->auth_xform.next = &ut_params->cipher_xform;
1451 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1452 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1453 ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1454 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1455 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1457 return TEST_SUCCESS;
1462 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1463 struct crypto_unittest_params *ut_params,
1464 struct crypto_testsuite_params *ts_params)
1466 /* Generate test mbuf data and digest */
1467 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1469 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1470 QUOTE_512_BYTES, 0);
1472 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1473 DIGEST_BYTE_LENGTH_SHA512);
1474 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1476 rte_memcpy(ut_params->digest,
1477 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1478 DIGEST_BYTE_LENGTH_SHA512);
1480 /* Generate Crypto op data structure */
1481 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1482 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1483 TEST_ASSERT_NOT_NULL(ut_params->op,
1484 "Failed to allocate symmetric crypto operation struct");
1486 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1488 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1490 /* set crypto operation source mbuf */
1491 sym_op->m_src = ut_params->ibuf;
1493 sym_op->auth.digest.data = ut_params->digest;
1494 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1495 ut_params->ibuf, QUOTE_512_BYTES);
1496 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1498 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1499 sym_op->auth.data.length = QUOTE_512_BYTES;
1501 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1502 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1503 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1504 ut_params->ibuf, 0);
1505 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1507 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1508 CIPHER_IV_LENGTH_AES_CBC);
1510 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1511 sym_op->cipher.data.length = QUOTE_512_BYTES;
1513 /* Process crypto operation */
1514 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1515 ut_params->op), "failed to process sym crypto op");
1517 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1518 "crypto op processing failed");
1520 ut_params->obuf = ut_params->op->sym->m_src;
1523 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1524 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1525 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1527 "Plaintext data not as expected");
1530 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1531 "Digest verification failed");
1533 return TEST_SUCCESS;
1536 /* ***** AES-CBC / HMAC-AES_XCBC Chain Tests ***** */
1538 static uint8_t aes_cbc_hmac_aes_xcbc_key[] = {
1539 0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
1540 0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
1543 static const uint8_t catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest[] = {
1544 0xE0, 0xAC, 0x9A, 0xC4, 0x22, 0x64, 0x35, 0x89,
1545 0x77, 0x1D, 0x8B, 0x75
1549 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void)
1551 struct crypto_testsuite_params *ts_params = &testsuite_params;
1552 struct crypto_unittest_params *ut_params = &unittest_params;
1554 /* Generate test mbuf data and space for digest */
1555 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1556 catch_22_quote, QUOTE_512_BYTES, 0);
1558 /* Setup Cipher Parameters */
1559 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1560 ut_params->cipher_xform.next = &ut_params->auth_xform;
1562 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1563 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1564 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1565 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1567 /* Setup HMAC Parameters */
1568 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1569 ut_params->auth_xform.next = NULL;
1571 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1572 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1573 ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1574 ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1575 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1577 /* Create Crypto session*/
1578 ut_params->sess = rte_cryptodev_sym_session_create(
1579 ts_params->valid_devs[0],
1580 &ut_params->cipher_xform);
1581 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1583 /* Generate Crypto op data structure */
1584 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1585 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1586 TEST_ASSERT_NOT_NULL(ut_params->op,
1587 "Failed to allocate symmetric crypto operation struct");
1589 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1591 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1593 /* set crypto operation source mbuf */
1594 sym_op->m_src = ut_params->ibuf;
1596 /* Set operation cipher parameters */
1597 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1598 sym_op->m_src, CIPHER_IV_LENGTH_AES_CBC);
1599 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(sym_op->m_src);
1600 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1602 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1603 CIPHER_IV_LENGTH_AES_CBC);
1605 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1606 sym_op->cipher.data.length = QUOTE_512_BYTES;
1608 /* Set operation authentication parameters */
1609 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1610 sym_op->m_src, DIGEST_BYTE_LENGTH_AES_XCBC);
1611 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1613 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES);
1614 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC;
1616 memset(sym_op->auth.digest.data, 0, DIGEST_BYTE_LENGTH_AES_XCBC);
1618 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1619 sym_op->auth.data.length = QUOTE_512_BYTES;
1622 /* Process crypto operation */
1623 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1625 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to process sym crypto op");
1627 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1628 "crypto op processing failed");
1631 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1632 rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1633 uint8_t *, CIPHER_IV_LENGTH_AES_CBC),
1634 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1636 "Ciphertext data not as expected");
1638 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1639 rte_pktmbuf_mtod_offset(
1640 ut_params->op->sym->m_src, uint8_t *,
1641 CIPHER_IV_LENGTH_AES_CBC +
1643 catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
1644 DIGEST_BYTE_LENGTH_AES_XCBC,
1645 "Generated digest data not as expected");
1647 return TEST_SUCCESS;
1651 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void)
1653 struct crypto_testsuite_params *ts_params = &testsuite_params;
1654 struct crypto_unittest_params *ut_params = &unittest_params;
1656 /* Generate test mbuf data and space for digest */
1657 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1658 (const char *)catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1659 QUOTE_512_BYTES, 0);
1661 /* Setup Cipher Parameters */
1662 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1663 ut_params->cipher_xform.next = NULL;
1665 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1666 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1667 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1668 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1670 /* Setup HMAC Parameters */
1671 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1672 ut_params->auth_xform.next = &ut_params->cipher_xform;
1674 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1675 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1676 ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1677 ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1678 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1680 /* Create Crypto session*/
1682 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1683 &ut_params->auth_xform);
1684 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1686 /* Generate Crypto op data structure */
1687 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1688 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1689 TEST_ASSERT_NOT_NULL(ut_params->op,
1690 "Failed to allocate symmetric crypto operation struct");
1692 /* Set crypto operation data parameters */
1693 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1695 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1697 /* set crypto operation source mbuf */
1698 sym_op->m_src = ut_params->ibuf;
1701 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1702 ut_params->ibuf, DIGEST_BYTE_LENGTH_AES_XCBC);
1703 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1704 "no room to append digest");
1706 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1707 ut_params->ibuf, QUOTE_512_BYTES);
1708 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC;
1710 rte_memcpy(sym_op->auth.digest.data,
1711 catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
1712 DIGEST_BYTE_LENGTH_AES_XCBC);
1714 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1715 sym_op->auth.data.length = QUOTE_512_BYTES;
1717 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1718 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1719 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1720 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1722 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1723 CIPHER_IV_LENGTH_AES_CBC);
1725 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1726 sym_op->cipher.data.length = QUOTE_512_BYTES;
1728 /* Process crypto operation */
1729 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1730 ut_params->op), "failed to process sym crypto op");
1732 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1733 "crypto op processing failed");
1735 ut_params->obuf = ut_params->op->sym->m_src;
1738 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1739 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1740 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1742 "Ciphertext data not as expected");
1744 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1745 "Digest verification failed");
1747 return TEST_SUCCESS;
1751 /* ***** AES-GCM Tests ***** */
1756 struct crypto_testsuite_params *ts_params = &testsuite_params;
1757 struct rte_cryptodev_stats stats;
1758 struct rte_cryptodev *dev;
1759 cryptodev_stats_get_t temp_pfn;
1761 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1762 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
1763 &stats) == -ENODEV),
1764 "rte_cryptodev_stats_get invalid dev failed");
1765 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
1766 "rte_cryptodev_stats_get invalid Param failed");
1767 dev = &rte_cryptodevs[ts_params->valid_devs[0]];
1768 temp_pfn = dev->dev_ops->stats_get;
1769 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
1770 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
1772 "rte_cryptodev_stats_get invalid Param failed");
1773 dev->dev_ops->stats_get = temp_pfn;
1775 /* Test expected values */
1777 test_AES_CBC_HMAC_SHA1_encrypt_digest();
1779 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1781 "rte_cryptodev_stats_get failed");
1782 TEST_ASSERT((stats.enqueued_count == 1),
1783 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1784 TEST_ASSERT((stats.dequeued_count == 1),
1785 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1786 TEST_ASSERT((stats.enqueue_err_count == 0),
1787 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1788 TEST_ASSERT((stats.dequeue_err_count == 0),
1789 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1791 /* invalid device but should ignore and not reset device stats*/
1792 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
1793 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1795 "rte_cryptodev_stats_get failed");
1796 TEST_ASSERT((stats.enqueued_count == 1),
1797 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1799 /* check that a valid reset clears stats */
1800 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1801 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1803 "rte_cryptodev_stats_get failed");
1804 TEST_ASSERT((stats.enqueued_count == 0),
1805 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1806 TEST_ASSERT((stats.dequeued_count == 0),
1807 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1809 return TEST_SUCCESS;
1814 test_multi_session(void)
1816 struct crypto_testsuite_params *ts_params = &testsuite_params;
1817 struct crypto_unittest_params *ut_params = &unittest_params;
1819 struct rte_cryptodev_info dev_info;
1820 struct rte_cryptodev_sym_session **sessions;
1824 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
1827 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
1829 sessions = rte_malloc(NULL,
1830 (sizeof(struct rte_cryptodev_sym_session *) *
1831 dev_info.sym.max_nb_sessions) + 1, 0);
1833 /* Create multiple crypto sessions*/
1834 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
1835 sessions[i] = rte_cryptodev_sym_session_create(
1836 ts_params->valid_devs[0],
1837 &ut_params->auth_xform);
1838 TEST_ASSERT_NOT_NULL(sessions[i],
1839 "Session creation failed at session number %u",
1842 /* Attempt to send a request on each session */
1843 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform(
1844 sessions[i], ut_params, ts_params),
1845 "Failed to perform decrypt on request "
1847 /* free crypto operation structure */
1849 rte_crypto_op_free(ut_params->op);
1852 * free mbuf - both obuf and ibuf are usually the same,
1853 * but rte copes even if we call free twice
1855 if (ut_params->obuf) {
1856 rte_pktmbuf_free(ut_params->obuf);
1857 ut_params->obuf = 0;
1861 /* Next session create should fail */
1862 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1863 &ut_params->auth_xform);
1864 TEST_ASSERT_NULL(sessions[i],
1865 "Session creation succeeded unexpectedly!");
1867 for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
1868 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
1873 return TEST_SUCCESS;
1877 test_not_in_place_crypto(void)
1879 struct crypto_testsuite_params *ts_params = &testsuite_params;
1880 struct crypto_unittest_params *ut_params = &unittest_params;
1881 struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1883 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
1885 /* Create multiple crypto sessions*/
1887 ut_params->sess = rte_cryptodev_sym_session_create(
1888 ts_params->valid_devs[0], &ut_params->auth_xform);
1890 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1893 /* Generate test mbuf data and digest */
1894 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1896 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1897 QUOTE_512_BYTES, 0);
1899 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1900 DIGEST_BYTE_LENGTH_SHA512);
1901 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1903 rte_memcpy(ut_params->digest,
1904 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1905 DIGEST_BYTE_LENGTH_SHA512);
1907 /* Generate Crypto op data structure */
1908 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1909 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1910 TEST_ASSERT_NOT_NULL(ut_params->op,
1911 "Failed to allocate symmetric crypto operation struct");
1914 /* Set crypto operation data parameters */
1915 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1917 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1919 /* set crypto operation source mbuf */
1920 sym_op->m_src = ut_params->ibuf;
1921 sym_op->m_dst = dst_m;
1923 sym_op->auth.digest.data = ut_params->digest;
1924 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1925 ut_params->ibuf, QUOTE_512_BYTES);
1926 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1928 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1929 sym_op->auth.data.length = QUOTE_512_BYTES;
1932 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1933 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1934 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1935 ut_params->ibuf, 0);
1936 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1938 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1939 CIPHER_IV_LENGTH_AES_CBC);
1941 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1942 sym_op->cipher.data.length = QUOTE_512_BYTES;
1944 /* Process crypto operation */
1945 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1947 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
1949 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1950 "crypto operation processing failed");
1953 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1954 rte_pktmbuf_mtod(ut_params->op->sym->m_dst, char *),
1957 "Plaintext data not as expected");
1961 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1962 "Digest verification failed");
1964 return TEST_SUCCESS;
1968 static struct unit_test_suite cryptodev_qat_testsuite = {
1969 .suite_name = "Crypto QAT Unit Test Suite",
1970 .setup = testsuite_setup,
1971 .teardown = testsuite_teardown,
1972 .unit_test_cases = {
1973 TEST_CASE_ST(ut_setup, ut_teardown,
1974 test_device_configure_invalid_dev_id),
1975 TEST_CASE_ST(ut_setup, ut_teardown,
1976 test_device_configure_invalid_queue_pair_ids),
1977 TEST_CASE_ST(ut_setup, ut_teardown,
1978 test_queue_pair_descriptor_setup),
1979 TEST_CASE_ST(ut_setup, ut_teardown,
1980 test_multi_session),
1982 TEST_CASE_ST(ut_setup, ut_teardown,
1983 test_AES_CBC_HMAC_SHA1_encrypt_digest),
1984 TEST_CASE_ST(ut_setup, ut_teardown,
1985 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
1987 TEST_CASE_ST(ut_setup, ut_teardown,
1988 test_AES_CBC_HMAC_SHA256_encrypt_digest),
1989 TEST_CASE_ST(ut_setup, ut_teardown,
1990 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
1992 TEST_CASE_ST(ut_setup, ut_teardown,
1993 test_AES_CBC_HMAC_SHA512_encrypt_digest),
1994 TEST_CASE_ST(ut_setup, ut_teardown,
1995 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
1997 TEST_CASE_ST(ut_setup, ut_teardown,
1998 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
1999 TEST_CASE_ST(ut_setup, ut_teardown,
2000 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
2002 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
2004 TEST_CASES_END() /**< NULL terminate unit test array */
2008 static struct unit_test_suite cryptodev_aesni_mb_testsuite = {
2009 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
2010 .setup = testsuite_setup,
2011 .teardown = testsuite_teardown,
2012 .unit_test_cases = {
2013 TEST_CASE_ST(ut_setup, ut_teardown,
2014 test_AES_CBC_HMAC_SHA1_encrypt_digest),
2015 TEST_CASE_ST(ut_setup, ut_teardown,
2016 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
2018 TEST_CASE_ST(ut_setup, ut_teardown,
2019 test_AES_CBC_HMAC_SHA256_encrypt_digest),
2020 TEST_CASE_ST(ut_setup, ut_teardown,
2021 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
2023 TEST_CASE_ST(ut_setup, ut_teardown,
2024 test_AES_CBC_HMAC_SHA512_encrypt_digest),
2025 TEST_CASE_ST(ut_setup, ut_teardown,
2026 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
2028 TEST_CASE_ST(ut_setup, ut_teardown,
2029 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
2030 TEST_CASE_ST(ut_setup, ut_teardown,
2031 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
2033 TEST_CASE_ST(ut_setup, ut_teardown,
2034 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless),
2036 TEST_CASE_ST(ut_setup, ut_teardown,
2037 test_not_in_place_crypto),
2039 TEST_CASES_END() /**< NULL terminate unit test array */
2044 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
2046 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
2047 return unit_test_suite_runner(&cryptodev_qat_testsuite);
2049 static struct test_command cryptodev_qat_cmd = {
2050 .command = "cryptodev_qat_autotest",
2051 .callback = test_cryptodev_qat,
2055 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
2057 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
2059 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
2062 static struct test_command cryptodev_aesni_mb_cmd = {
2063 .command = "cryptodev_aesni_mb_autotest",
2064 .callback = test_cryptodev_aesni_mb,
2067 REGISTER_TEST_COMMAND(cryptodev_qat_cmd);
2068 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd);