X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=2494bae608f67a1ff18b699758ec6bc672c4c706;hb=94b0ad8e0aa556230183f4c4d06b68bfd145dce3;hp=5ced183bee6297917609f1f80fc789c2db52c9d9;hpb=1bd407fac80bf50719130f68cb3f5b00ca23e6df;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 5ced183bee..2494bae608 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -35,7 +35,6 @@ #include #include #include -#include #include #include @@ -43,12 +42,15 @@ #include "test.h" #include "test_cryptodev.h" +#include "test_cryptodev_snow3g_test_vectors.h" +#include "test_cryptodev_snow3g_hash_test_vectors.h" +#include "test_cryptodev_gcm_test_vectors.h" static enum rte_cryptodev_type gbl_cryptodev_type; struct crypto_testsuite_params { struct rte_mempool *mbuf_pool; - struct rte_mempool *mbuf_ol_pool; + struct rte_mempool *op_mpool; struct rte_cryptodev_config conf; struct rte_cryptodev_qp_conf qp_conf; @@ -62,14 +64,16 @@ struct crypto_unittest_params { struct rte_cryptodev_sym_session *sess; - struct rte_mbuf_offload *ol; - struct rte_crypto_sym_op *op; + struct rte_crypto_op *op; struct rte_mbuf *obuf, *ibuf; uint8_t *digest; }; +#define ALIGN_POW2_ROUNDUP(num, align) \ + (((num) + (align) - 1) & ~((align) - 1)) + /* * Forward declarations. */ @@ -112,19 +116,21 @@ hexdump_mbuf_data(FILE *f, const char *title, struct rte_mbuf *m) } #endif -static struct rte_mbuf * -process_crypto_request(uint8_t dev_id, struct rte_mbuf *ibuf) +static struct rte_crypto_op * +process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) { - struct rte_mbuf *obuf = NULL; #if HEX_DUMP hexdump_mbuf_data(stdout, "Enqueued Packet", ibuf); #endif - if (rte_cryptodev_enqueue_burst(dev_id, 0, &ibuf, 1) != 1) { + if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { printf("Error sending packet for encryption"); return NULL; } - while (rte_cryptodev_dequeue_burst(dev_id, 0, &obuf, 1) == 0) + + op = NULL; + + while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) rte_pause(); #if HEX_DUMP @@ -132,7 +138,7 @@ process_crypto_request(uint8_t dev_id, struct rte_mbuf *ibuf) hexdump_mbuf_data(stdout, "Dequeued Packet", obuf); #endif - return obuf; + return op; } static struct crypto_testsuite_params testsuite_params = { NULL }; @@ -162,13 +168,14 @@ testsuite_setup(void) } } - ts_params->mbuf_ol_pool = rte_pktmbuf_offload_pool_create( - "MBUF_OFFLOAD_POOL", + ts_params->op_mpool = rte_crypto_op_pool_create( + "MBUF_CRYPTO_SYM_OP_POOL", + RTE_CRYPTO_OP_TYPE_SYMMETRIC, NUM_MBUFS, MBUF_CACHE_SIZE, DEFAULT_NUM_XFORMS * sizeof(struct rte_crypto_sym_xform), rte_socket_id()); - if (ts_params->mbuf_ol_pool == NULL) { + if (ts_params->op_mpool == NULL) { RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); return TEST_FAILED; } @@ -190,6 +197,52 @@ testsuite_setup(void) } } + /* Create 2 AESNI GCM devices if required */ + if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) { + nb_devs = rte_cryptodev_count_devtype( + RTE_CRYPTODEV_AESNI_GCM_PMD); + if (nb_devs < 2) { + for (i = nb_devs; i < 2; i++) { + TEST_ASSERT_SUCCESS(rte_eal_vdev_init( + CRYPTODEV_NAME_AESNI_GCM_PMD, NULL), + "Failed to create instance %u of" + " pmd : %s", + i, CRYPTODEV_NAME_AESNI_GCM_PMD); + } + } + } + + /* Create 2 Snow3G devices if required */ + if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) { + nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); + if (nb_devs < 2) { + for (i = nb_devs; i < 2; i++) { + TEST_ASSERT_SUCCESS(rte_eal_vdev_init( + CRYPTODEV_NAME_SNOW3G_PMD, NULL), + "Failed to create instance %u of" + " pmd : %s", + i, CRYPTODEV_NAME_SNOW3G_PMD); + } + } + } + + /* Create 2 NULL devices if required */ + if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) { + nb_devs = rte_cryptodev_count_devtype( + RTE_CRYPTODEV_NULL_PMD); + if (nb_devs < 2) { + for (i = nb_devs; i < 2; i++) { + int dev_id = rte_eal_vdev_init( + CRYPTODEV_NAME_NULL_PMD, NULL); + + TEST_ASSERT(dev_id >= 0, + "Failed to create instance %u of" + " pmd : %s", + i, CRYPTODEV_NAME_NULL_PMD); + } + } + } + nb_devs = rte_cryptodev_count(); if (nb_devs < 1) { RTE_LOG(ERR, USER1, "No crypto devices found?"); @@ -253,10 +306,9 @@ testsuite_teardown(void) rte_mempool_count(ts_params->mbuf_pool)); } - - if (ts_params->mbuf_ol_pool != NULL) { + if (ts_params->op_mpool != NULL) { RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", - rte_mempool_count(ts_params->mbuf_ol_pool)); + rte_mempool_count(ts_params->op_mpool)); } } @@ -326,8 +378,8 @@ ut_teardown(void) } /* free crypto operation structure */ - if (ut_params->ol) - rte_pktmbuf_offload_free(ut_params->ol); + if (ut_params->op) + rte_crypto_op_free(ut_params->op); /* * free mbuf - both obuf and ibuf are usually the same, @@ -793,53 +845,59 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) &ut_params->cipher_xform); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + /* Set crypto operation authentication parameters */ + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + /* Set crypto operation cipher parameters */ + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + - CIPHER_IV_LENGTH_AES_CBC, + uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, CIPHER_IV_LENGTH_AES_CBC); + + TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext, catch_22_quote_2_512_bytes_AES_CBC_ciphertext, QUOTE_512_BYTES, "ciphertext data not as expected"); - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + - CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, + uint8_t *digest = ciphertext + QUOTE_512_BYTES; + + TEST_ASSERT_BUFFERS_ARE_EQUAL(digest, catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : @@ -864,60 +922,66 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless(void) TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; - - TEST_ASSERT_NOT_NULL(rte_pktmbuf_offload_alloc_crypto_sym_xforms( - ut_params->ol, 2), + TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(ut_params->op, 2), "failed to allocate space for crypto transforms"); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + /* Set crypto operation data parameters */ - ut_params->op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; + sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; /* cipher parameters */ - ut_params->op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - ut_params->op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; - ut_params->op->xform->cipher.key.data = aes_cbc_key; - ut_params->op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; + sym_op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; + sym_op->xform->cipher.key.data = aes_cbc_key; + sym_op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; /* hash parameters */ - ut_params->op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH; + sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - ut_params->op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; - ut_params->op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1; - ut_params->op->xform->next->auth.key.data = hmac_sha1_key; - ut_params->op->xform->next->auth.digest_length = + sym_op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; + sym_op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1; + sym_op->xform->next->auth.key.data = hmac_sha1_key; + sym_op->xform->next->auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -986,42 +1050,48 @@ test_AES_CBC_HMAC_SHA1_decrypt_digest_verify(void) TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + /* attach symmetric crypto session to crypto operations */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + ut_params->obuf = ut_params->op->sym->m_src; + /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1089,47 +1159,51 @@ test_AES_CBC_HMAC_SHA256_encrypt_digest(void) ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256; /* Create Crypto session*/ - ut_params->sess = - rte_cryptodev_sym_session_create(ts_params->valid_devs[0], - &ut_params->cipher_xform); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], + &ut_params->cipher_xform); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1198,42 +1272,47 @@ test_AES_CBC_HMAC_SHA256_decrypt_digest_verify(void) TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); - - ut_params->op = &ut_params->ol->op.crypto; + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256; + + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1312,43 +1391,46 @@ test_AES_CBC_HMAC_SHA512_encrypt_digest(void) TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1448,43 +1530,46 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, DIGEST_BYTE_LENGTH_SHA512); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + rte_crypto_op_attach_sym_session(ut_params->op, sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; + + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, 0); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1522,10 +1607,6 @@ test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void) ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, catch_22_quote, QUOTE_512_BYTES, 0); - ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - DIGEST_BYTE_LENGTH_AES_XCBC); - TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); - /* Setup Cipher Parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; ut_params->cipher_xform.next = &ut_params->auth_xform; @@ -1546,54 +1627,71 @@ test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void) ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC; /* Create Crypto session*/ - ut_params->sess = - rte_cryptodev_sym_session_create(ts_params->valid_devs[0], - &ut_params->cipher_xform); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], + &ut_params->cipher_xform); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->iv.data = (uint8_t *) - rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + /* Set operation cipher parameters */ + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + sym_op->m_src, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(sym_op->m_src); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; + + /* Set operation authentication parameters */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + sym_op->m_src, DIGEST_BYTE_LENGTH_AES_XCBC); + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->m_src, + CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES); + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC; + + memset(sym_op->auth.digest.data, 0, DIGEST_BYTE_LENGTH_AES_XCBC); + + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + - CIPHER_IV_LENGTH_AES_CBC, + rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, CIPHER_IV_LENGTH_AES_CBC), catch_22_quote_2_512_bytes_AES_CBC_ciphertext, QUOTE_512_BYTES, "Ciphertext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + - CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, + rte_pktmbuf_mtod_offset( + ut_params->op->sym->m_src, uint8_t *, + CIPHER_IV_LENGTH_AES_CBC + + QUOTE_512_BYTES), catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest, DIGEST_BYTE_LENGTH_AES_XCBC, "Generated digest data not as expected"); @@ -1612,14 +1710,6 @@ test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void) (const char *)catch_22_quote_2_512_bytes_AES_CBC_ciphertext, QUOTE_512_BYTES, 0); - ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - DIGEST_BYTE_LENGTH_AES_XCBC); - TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); - - rte_memcpy(ut_params->digest, - catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest, - DIGEST_BYTE_LENGTH_AES_XCBC); - /* Setup Cipher Parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; ut_params->cipher_xform.next = NULL; @@ -1646,35 +1736,55 @@ test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void) TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - ut_params->op = &ut_params->ol->op.crypto; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, DIGEST_BYTE_LENGTH_AES_XCBC); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, QUOTE_512_BYTES); + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC; + + rte_memcpy(sym_op->auth.digest.data, + catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest, + DIGEST_BYTE_LENGTH_AES_XCBC); + + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; + + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + ut_params->obuf = ut_params->op->sym->m_src; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -1689,209 +1799,1976 @@ test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void) return TEST_SUCCESS; } +/* ***** Snow3G Tests ***** */ +static int +create_snow3g_hash_session(uint8_t dev_id, + const uint8_t *key, const uint8_t key_len, + const uint8_t aad_len, const uint8_t auth_len, + enum rte_crypto_auth_operation op) +{ + uint8_t hash_key[key_len]; -/* ***** AES-GCM Tests ***** */ + struct crypto_unittest_params *ut_params = &unittest_params; + memcpy(hash_key, key, key_len); +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "key:", key, key_len); +#endif + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.op = op; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2; + ut_params->auth_xform.auth.key.length = key_len; + ut_params->auth_xform.auth.key.data = hash_key; + ut_params->auth_xform.auth.digest_length = auth_len; + ut_params->auth_xform.auth.add_auth_data_length = aad_len; + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->auth_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; +} static int -test_stats(void) +create_snow3g_cipher_session(uint8_t dev_id, + enum rte_crypto_cipher_operation op, + const uint8_t *key, const uint8_t key_len) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct rte_cryptodev_stats stats; - struct rte_cryptodev *dev; - cryptodev_stats_get_t temp_pfn; + uint8_t cipher_key[key_len]; - rte_cryptodev_stats_reset(ts_params->valid_devs[0]); - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, - &stats) == -ENODEV), - "rte_cryptodev_stats_get invalid dev failed"); - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), - "rte_cryptodev_stats_get invalid Param failed"); - dev = &rte_cryptodevs[ts_params->valid_devs[0]]; - temp_pfn = dev->dev_ops->stats_get; - dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) - == -ENOTSUP), - "rte_cryptodev_stats_get invalid Param failed"); - dev->dev_ops->stats_get = temp_pfn; + struct crypto_unittest_params *ut_params = &unittest_params; - /* Test expected values */ - ut_setup(); - test_AES_CBC_HMAC_SHA1_encrypt_digest(); - ut_teardown(); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.enqueue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + memcpy(cipher_key, key, key_len); - /* invalid device but should ignore and not reset device stats*/ - rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - /* check that a valid reset clears stats */ - rte_cryptodev_stats_reset(ts_params->valid_devs[0]); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; + ut_params->cipher_xform.cipher.op = op; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = key_len; - return TEST_SUCCESS; +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "key:", key, key_len); +#endif + /* Create Crypto session */ + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params-> + cipher_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; } - static int -test_multi_session(void) +create_snow3g_cipher_operation(const uint8_t *iv, const unsigned iv_len, + const unsigned cipher_len, + const unsigned cipher_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + unsigned iv_pad_len = 0; - struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_session **sessions; + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); - uint16_t i; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + /* iv */ + iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf + , iv_pad_len); - sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) * - dev_info.sym.max_nb_sessions) + 1, 0); + TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - /* Create multiple crypto sessions*/ - for (i = 0; i < dev_info.sym.max_nb_sessions; i++) { - sessions[i] = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], - &ut_params->auth_xform); - TEST_ASSERT_NOT_NULL(sessions[i], - "Session creation failed at session number %u", - i); + memset(sym_op->cipher.iv.data, 0, iv_pad_len); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = iv_pad_len; - /* Attempt to send a request on each session */ - TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform( - sessions[i], ut_params, ts_params), - "Failed to perform decrypt on request " - "number %u.", i); - } + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + return 0; +} - /* Next session create should fail */ - sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0], - &ut_params->auth_xform); - TEST_ASSERT_NULL(sessions[i], - "Session creation succeeded unexpectedly!"); - for (i = 0; i < dev_info.sym.max_nb_sessions; i++) - rte_cryptodev_sym_session_free(ts_params->valid_devs[0], +static int +create_snow3g_cipher_auth_session(uint8_t dev_id, + enum rte_crypto_cipher_operation cipher_op, + enum rte_crypto_auth_operation auth_op, + const uint8_t *key, const uint8_t key_len, + const uint8_t aad_len, const uint8_t auth_len) +{ + uint8_t cipher_auth_key[key_len]; + + struct crypto_unittest_params *ut_params = &unittest_params; + + memcpy(cipher_auth_key, key, key_len); + + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2; + ut_params->auth_xform.auth.key.length = key_len; + /* Hash key = cipher key */ + ut_params->auth_xform.auth.key.data = cipher_auth_key; + ut_params->auth_xform.auth.digest_length = auth_len; + ut_params->auth_xform.auth.add_auth_data_length = aad_len; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = cipher_auth_key; + ut_params->cipher_xform.cipher.key.length = key_len; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "key:", key, key_len); +#endif + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->cipher_xform); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; +} + +static int +create_snow3g_auth_cipher_session(uint8_t dev_id, + enum rte_crypto_cipher_operation cipher_op, + enum rte_crypto_auth_operation auth_op, + const uint8_t *key, const uint8_t key_len, + const uint8_t aad_len, const uint8_t auth_len) + { + uint8_t auth_cipher_key[key_len]; + + struct crypto_unittest_params *ut_params = &unittest_params; + + memcpy(auth_cipher_key, key, key_len); + + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.next = &ut_params->cipher_xform; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2; + ut_params->auth_xform.auth.key.length = key_len; + ut_params->auth_xform.auth.key.data = auth_cipher_key; + ut_params->auth_xform.auth.digest_length = auth_len; + ut_params->auth_xform.auth.add_auth_data_length = aad_len; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = auth_cipher_key; + ut_params->cipher_xform.cipher.key.length = key_len; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "key:", key, key_len); +#endif + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->auth_xform); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + return 0; +} + +static int +create_snow3g_hash_operation(const uint8_t *auth_tag, + const unsigned auth_tag_len, + const uint8_t *aad, const unsigned aad_len, + unsigned data_pad_len, + enum rte_crypto_auth_operation op, + const unsigned auth_len, const unsigned auth_offset) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + + struct crypto_unittest_params *ut_params = &unittest_params; + + unsigned aad_buffer_len; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + + /* aad */ + /* + * Always allocate the aad up to the block size. + * The cryptodev API calls out - + * - the array must be big enough to hold the AAD, plus any + * space to round this up to the nearest multiple of the + * block size (16 bytes). + */ + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); + sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, aad_buffer_len); + TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, + "no room to prepend aad"); + sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( + ut_params->ibuf); + sym_op->auth.aad.length = aad_len; + + memset(sym_op->auth.aad.data, 0, aad_buffer_len); + rte_memcpy(sym_op->auth.aad.data, aad, aad_len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "aad:", + sym_op->auth.aad.data, aad_len); +#endif + + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); + + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); + ut_params->digest = sym_op->auth.digest.data; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, data_pad_len + aad_len); + sym_op->auth.digest.length = auth_tag_len; + if (op == RTE_CRYPTO_AUTH_OP_GENERATE) + memset(sym_op->auth.digest.data, 0, auth_tag_len); + else + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + sym_op->auth.digest.length); +#endif + + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; + + return 0; +} + +static int +create_snow3g_cipher_hash_operation(const uint8_t *auth_tag, + const unsigned auth_tag_len, + const uint8_t *aad, const unsigned aad_len, + unsigned data_pad_len, + enum rte_crypto_auth_operation op, + const uint8_t *iv, const unsigned iv_len, + const unsigned cipher_len, const unsigned cipher_offset, + const unsigned auth_len, const unsigned auth_offset) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + unsigned iv_pad_len = 0; + unsigned aad_buffer_len; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + + + /* iv */ + iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, iv_pad_len); + TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); + + memset(sym_op->cipher.iv.data, 0, iv_pad_len); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = iv_pad_len; + + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + + /* aad */ + /* + * Always allocate the aad up to the block size. + * The cryptodev API calls out - + * - the array must be big enough to hold the AAD, plus any + * space to round this up to the nearest multiple of the + * block size (16 bytes). + */ + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); + + sym_op->auth.aad.data = + (uint8_t *)rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *); + TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, + "no room to prepend aad"); + sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( + ut_params->ibuf); + sym_op->auth.aad.length = aad_len; + + memset(sym_op->auth.aad.data, 0, aad_buffer_len); + rte_memcpy(sym_op->auth.aad.data, aad, aad_len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "aad:", + sym_op->auth.aad.data, aad_len); +#endif + + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); + + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); + ut_params->digest = sym_op->auth.digest.data; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, data_pad_len + aad_len); + sym_op->auth.digest.length = auth_tag_len; + if (op == RTE_CRYPTO_AUTH_OP_GENERATE) + memset(sym_op->auth.digest.data, 0, auth_tag_len); + else + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + + #ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + sym_op->auth.digest.length); + #endif + + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; + + return 0; +} + +static int +create_snow3g_auth_cipher_operation(const unsigned auth_tag_len, + const uint8_t *iv, const unsigned iv_len, + const uint8_t *aad, const unsigned aad_len, + unsigned data_pad_len, + const unsigned cipher_len, const unsigned cipher_offset, + const unsigned auth_len, const unsigned auth_offset) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + unsigned iv_pad_len = 0; + unsigned aad_buffer_len = 0; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); + + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); + + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, data_pad_len); + sym_op->auth.digest.length = auth_tag_len; + + memset(sym_op->auth.digest.data, 0, auth_tag_len); + + #ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + sym_op->auth.digest.length); + #endif + /* iv */ + iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, iv_pad_len); + TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); + + memset(sym_op->cipher.iv.data, 0, iv_pad_len); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = iv_pad_len; + + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + + /* aad */ + /* + * Always allocate the aad up to the block size. + * The cryptodev API calls out - + * - the array must be big enough to hold the AAD, plus any + * space to round this up to the nearest multiple of the + * block size (16 bytes). + */ + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); + + sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, aad_buffer_len); + TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, + "no room to prepend aad"); + sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( + ut_params->ibuf); + sym_op->auth.aad.length = aad_len; + + memset(sym_op->auth.aad.data, 0, aad_buffer_len); + rte_memcpy(sym_op->auth.aad.data, aad, aad_len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "aad:", + sym_op->auth.aad.data, aad_len); +#endif + + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = auth_offset + cipher_offset; + + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset + cipher_offset; + + return 0; +} + +static int +test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + unsigned plaintext_pad_len; + uint8_t *plaintext; + + /* Create SNOW3G session */ + retval = create_snow3g_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_GENERATE); + if (retval < 0) + return retval; + + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = tdata->plaintext.len >> 3; + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); + + /* Create SNOW3G opertaion */ + retval = create_snow3g_hash_operation(NULL, tdata->digest.len, + tdata->aad.data, tdata->aad.len, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + ut_params->obuf = ut_params->op->sym->m_src; + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len + tdata->aad.len; + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "Snow3G Generated auth tag not as expected"); + + return 0; +} + +static int +test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + unsigned plaintext_pad_len; + uint8_t *plaintext; + + /* Create SNOW3G session */ + retval = create_snow3g_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_VERIFY); + if (retval < 0) + return retval; + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = tdata->plaintext.len >> 3; + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); + + /* Create SNOW3G operation */ + retval = create_snow3g_hash_operation(tdata->digest.data, + tdata->digest.len, + tdata->aad.data, tdata->aad.len, + plaintext_pad_len, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len + tdata->aad.len; + + /* Validate obuf */ + if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) + return 0; + else + return -1; + + return 0; +} + + +static int +test_snow3g_hash_generate_test_case_1(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_1); +} + +static int +test_snow3g_hash_generate_test_case_2(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_2); +} + +static int +test_snow3g_hash_generate_test_case_3(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_3); +} + +static int +test_snow3g_hash_verify_test_case_1(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); + +} + +static int +test_snow3g_hash_verify_test_case_2(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); +} + +static int +test_snow3g_hash_verify_test_case_3(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); +} + +static int +test_snow3g_encryption(const struct snow3g_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext; + uint8_t plaintext_pad_len; + uint8_t lastByteValidBits = 8; + uint8_t lastByteMask = 0xFF; + + /* Create SNOW3G session */ + retval = create_snow3g_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + tdata->key.data, tdata->key.len); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* + * Append data which is padded to a + * multiple of the algorithms block size + */ + /*tdata->plaintext.len = tdata->plaintext.len >> 3;*/ + plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 16); + + plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + /* Create SNOW3G operation */ + retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len); + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + + ut_params->obuf = ut_params->op->sym->m_src; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + tdata->iv.len; + else + ciphertext = plaintext; + + lastByteValidBits = (tdata->validDataLenInBits.len % 8); + if (lastByteValidBits == 0) + lastByteValidBits = 8; + lastByteMask = lastByteMask << (8 - lastByteValidBits); + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len >> 3, + "Snow3G Ciphertext data not as expected"); + return 0; +} + +static int test_snow3g_decryption(const struct snow3g_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext; + uint8_t ciphertext_pad_len; + uint8_t lastByteValidBits = 8; + uint8_t lastByteMask = 0xFF; + + /* Create SNOW3G session */ + retval = create_snow3g_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_DECRYPT, + tdata->key.data, tdata->key.len); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* + * Append data which is padded to a + * multiple of the algorithms block size + */ + ciphertext_pad_len = RTE_ALIGN_CEIL((tdata->ciphertext.len >> 3), 16); + + ciphertext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len >> 3); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); +#endif + /* Create SNOW3G operation */ + retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len); + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + tdata->iv.len; + else + plaintext = ciphertext; + lastByteValidBits = (tdata->validDataLenInBits.len % 8); + if (lastByteValidBits == 0) + lastByteValidBits = 8; + lastByteMask = lastByteMask << (8 - lastByteValidBits); + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL(plaintext, + tdata->plaintext.data, + tdata->plaintext.len >> 3, + "Snow3G Plaintext data not as expected"); + return 0; +} + +static int +test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext; + uint8_t plaintext_pad_len; + uint8_t lastByteValidBits = 8; + uint8_t lastByteMask = 0xFF; + + /* Create SNOW3G session */ + retval = create_snow3g_cipher_auth_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->digest.len); + if (retval < 0) + return retval; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = tdata->plaintext.len >> 3; + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + + /* Create SNOW3G operation */ + retval = create_snow3g_cipher_hash_operation(tdata->digest.data, + tdata->digest.len, tdata->aad.data, + tdata->aad.len, /*tdata->plaintext.len,*/ + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->iv.data, tdata->iv.len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + tdata->iv.len; + else + ciphertext = plaintext; + lastByteValidBits = (tdata->validDataLenInBits.len % 8); + if (lastByteValidBits == 0) + lastByteValidBits = 8; + lastByteMask = lastByteMask << (8-lastByteValidBits); + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len >> 3, + "Snow3G Ciphertext data not as expected"); + + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len + tdata->aad.len; + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "Snow3G Generated auth tag not as expected"); + return 0; +} +static int +test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext; + uint8_t plaintext_pad_len; + uint8_t lastByteValidBits = 8; + uint8_t lastByteMask = 0xFF; + + /* Create SNOW3G session */ + retval = create_snow3g_auth_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->digest.len); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 8); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + + /* Create SNOW3G operation */ + retval = create_snow3g_auth_cipher_operation( + tdata->digest.len, + tdata->iv.data, tdata->iv.len, + tdata->aad.data, tdata->aad.len, + plaintext_pad_len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len + ); + + if (retval < 0) + return retval; + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + tdata->aad.len + tdata->iv.len; + else + ciphertext = plaintext; + + lastByteValidBits = (tdata->validDataLenInBits.len % 8); + if (lastByteValidBits == 0) + lastByteValidBits = 8; + lastByteMask = lastByteMask << (8-lastByteValidBits); + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len + tdata->aad.len + tdata->iv.len; + #ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len >> 3, + "Snow3G Ciphertext data not as expected"); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "Snow3G Generated auth tag not as expected"); + return 0; +} + +static int +test_snow3g_encryption_test_case_1(void) +{ + return test_snow3g_encryption(&snow3g_test_case_1); +} + +static int +test_snow3g_encryption_test_case_2(void) +{ + return test_snow3g_encryption(&snow3g_test_case_2); +} + +static int +test_snow3g_encryption_test_case_3(void) +{ + return test_snow3g_encryption(&snow3g_test_case_3); +} + +static int +test_snow3g_encryption_test_case_4(void) +{ + return test_snow3g_encryption(&snow3g_test_case_4); +} + +static int +test_snow3g_encryption_test_case_5(void) +{ + return test_snow3g_encryption(&snow3g_test_case_5); +} + +static int +test_snow3g_decryption_test_case_1(void) +{ + return test_snow3g_decryption(&snow3g_test_case_1); +} + +static int +test_snow3g_decryption_test_case_2(void) +{ + return test_snow3g_decryption(&snow3g_test_case_2); +} + +static int +test_snow3g_decryption_test_case_3(void) +{ + return test_snow3g_decryption(&snow3g_test_case_3); +} + +static int +test_snow3g_decryption_test_case_4(void) +{ + return test_snow3g_decryption(&snow3g_test_case_4); +} + +static int +test_snow3g_decryption_test_case_5(void) +{ + return test_snow3g_decryption(&snow3g_test_case_5); +} +static int +test_snow3g_authenticated_encryption_test_case_1(void) +{ + return test_snow3g_authenticated_encryption(&snow3g_test_case_3); +} + +static int +test_snow3g_encrypted_authentication_test_case_1(void) +{ + return test_snow3g_encrypted_authentication(&snow3g_test_case_6); +} + +/* ***** AES-GCM Tests ***** */ + +static int +create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op, + const uint8_t *key, const uint8_t key_len, + const uint8_t aad_len, const uint8_t auth_len) +{ + uint8_t cipher_key[key_len]; + + struct crypto_unittest_params *ut_params = &unittest_params; + + + memcpy(cipher_key, key, key_len); + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; + ut_params->cipher_xform.cipher.op = op; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = key_len; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "key:", key, key_len); +#endif + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM; + + ut_params->auth_xform.auth.digest_length = auth_len; + ut_params->auth_xform.auth.add_auth_data_length = aad_len; + ut_params->auth_xform.auth.key.length = 0; + ut_params->auth_xform.auth.key.data = NULL; + + if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { + ut_params->cipher_xform.next = &ut_params->auth_xform; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->cipher_xform); + } else {/* Create Crypto session*/ + ut_params->auth_xform.next = &ut_params->cipher_xform; + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->auth_xform); + } + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + return 0; +} + +static int +create_gcm_operation(enum rte_crypto_cipher_operation op, + const uint8_t *auth_tag, const unsigned auth_tag_len, + const uint8_t *iv, const unsigned iv_len, + const uint8_t *aad, const unsigned aad_len, + const unsigned data_len, unsigned data_pad_len) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + unsigned iv_pad_len = 0, aad_buffer_len; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + + + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, data_pad_len); + sym_op->auth.digest.length = auth_tag_len; + + if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "digest:", + ut_params->op->digest.data, + ut_params->op->digest.length); +#endif + } + + /* iv */ + iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, iv_pad_len); + TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); + + memset(sym_op->cipher.iv.data, 0, iv_pad_len); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.length = iv_pad_len; + + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + + /* CalcY0 */ + if (iv_len != 16) + sym_op->cipher.iv.data[15] = 1; + + /* + * Always allocate the aad up to the block size. + * The cryptodev API calls out - + * - the array must be big enough to hold the AAD, plus any + * space to round this up to the nearest multiple of the + * block size (16 bytes). + */ + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); + + sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, aad_buffer_len); + TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, + "no room to prepend aad"); + sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( + ut_params->ibuf); + sym_op->auth.aad.length = aad_len; + + memset(sym_op->auth.aad.data, 0, aad_buffer_len); + rte_memcpy(sym_op->auth.aad.data, aad, aad_len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "iv:", ut_params->op->iv.data, iv_pad_len); + rte_hexdump(stdout, "aad:", + ut_params->op->additional_auth.data, aad_len); +#endif + sym_op->cipher.data.length = data_len; + sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len; + + sym_op->auth.data.offset = aad_buffer_len + iv_pad_len; + sym_op->auth.data.length = data_len; + + return 0; +} + +static int +test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext, *auth_tag; + uint16_t plaintext_pad_len; + + /* Create GCM session */ + retval = create_gcm_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len); + if (retval < 0) + return retval; + + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* + * Append data which is padded to a multiple + * of the algorithms block size + */ + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + /* Create GCM opertaion */ + retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, + tdata->auth_tag.data, tdata->auth_tag.len, + tdata->iv.data, tdata->iv.len, + tdata->aad.data, tdata->aad.len, + tdata->plaintext.len, plaintext_pad_len); + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + if (ut_params->op->sym->m_dst) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, + uint8_t *, plaintext_pad_len); + } else { + ciphertext = plaintext; + auth_tag = plaintext + plaintext_pad_len; + } + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); + rte_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len, + "GCM Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->auth_tag.data, + tdata->auth_tag.len, + "GCM Generated auth tag not as expected"); + + return 0; + +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_1(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_2(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_3(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_4(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_5(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_6(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6); +} + +static int +test_mb_AES_GCM_authenticated_encryption_test_case_7(void) +{ + return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7); +} + +static int +test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext, *ciphertext; + uint16_t ciphertext_pad_len; + + /* Create GCM session */ + retval = create_gcm_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_DECRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len); + if (retval < 0) + return retval; + + + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); + + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len); + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); +#endif + /* Create GCM opertaion */ + retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, + tdata->auth_tag.data, tdata->auth_tag.len, + tdata->iv.data, tdata->iv.len, + tdata->aad.data, tdata->aad.len, + tdata->ciphertext.len, ciphertext_pad_len); + if (retval < 0) + return retval; + + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + if (ut_params->op->sym->m_dst) + plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + else + plaintext = ciphertext; + +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); +#endif + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "GCM plaintext data not as expected"); + + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "GCM authentication failed"); + return 0; +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_1(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_2(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_3(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_4(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_5(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_6(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6); +} + +static int +test_mb_AES_GCM_authenticated_decryption_test_case_7(void) +{ + return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7); +} + +static int +test_stats(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct rte_cryptodev_stats stats; + struct rte_cryptodev *dev; + cryptodev_stats_get_t temp_pfn; + + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, + &stats) == -ENODEV), + "rte_cryptodev_stats_get invalid dev failed"); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), + "rte_cryptodev_stats_get invalid Param failed"); + dev = &rte_cryptodevs[ts_params->valid_devs[0]]; + temp_pfn = dev->dev_ops->stats_get; + dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) + == -ENOTSUP), + "rte_cryptodev_stats_get invalid Param failed"); + dev->dev_ops->stats_get = temp_pfn; + + /* Test expected values */ + ut_setup(); + test_AES_CBC_HMAC_SHA1_encrypt_digest(); + ut_teardown(); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.enqueue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + /* invalid device but should ignore and not reset device stats*/ + rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + /* check that a valid reset clears stats */ + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + return TEST_SUCCESS; +} + + +static int +test_multi_session(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_session **sessions; + + uint16_t i; + + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); + + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + + sessions = rte_malloc(NULL, + (sizeof(struct rte_cryptodev_sym_session *) * + dev_info.sym.max_nb_sessions) + 1, 0); + + /* Create multiple crypto sessions*/ + for (i = 0; i < dev_info.sym.max_nb_sessions; i++) { + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], + &ut_params->auth_xform); + TEST_ASSERT_NOT_NULL(sessions[i], + "Session creation failed at session number %u", + i); + + /* Attempt to send a request on each session */ + TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform( + sessions[i], ut_params, ts_params), + "Failed to perform decrypt on request " + "number %u.", i); + /* free crypto operation structure */ + if (ut_params->op) + rte_crypto_op_free(ut_params->op); + + /* + * free mbuf - both obuf and ibuf are usually the same, + * but rte copes even if we call free twice + */ + if (ut_params->obuf) { + rte_pktmbuf_free(ut_params->obuf); + ut_params->obuf = 0; + } + } + + /* Next session create should fail */ + sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0], + &ut_params->auth_xform); + TEST_ASSERT_NULL(sessions[i], + "Session creation succeeded unexpectedly!"); + + for (i = 0; i < dev_info.sym.max_nb_sessions; i++) + rte_cryptodev_sym_session_free(ts_params->valid_devs[0], sessions[i]); - rte_free(sessions); + rte_free(sessions); + + return TEST_SUCCESS; +} + +static int +test_not_in_place_crypto(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); + + /* Create multiple crypto sessions*/ + + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->auth_xform); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + + /* Generate test mbuf data and digest */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + (const char *) + catch_22_quote_2_512_bytes_AES_CBC_ciphertext, + QUOTE_512_BYTES, 0); + + ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + DIGEST_BYTE_LENGTH_SHA512); + TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); + + rte_memcpy(ut_params->digest, + catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, + DIGEST_BYTE_LENGTH_SHA512); + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + sym_op->m_dst = dst_m; + + sym_op->auth.digest.data = ut_params->digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, QUOTE_512_BYTES); + sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; + + sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.length = QUOTE_512_BYTES; + + + sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); + sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset( + ut_params->ibuf, 0); + sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; + + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, + CIPHER_IV_LENGTH_AES_CBC); + + sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.length = QUOTE_512_BYTES; + + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + rte_pktmbuf_mtod(ut_params->op->sym->m_dst, char *), + catch_22_quote, + QUOTE_512_BYTES, + "Plaintext data not as expected"); + + return TEST_SUCCESS; +} + +static int +test_null_cipher_only_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + /* Generate test mbuf data and space for digest */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + catch_22_quote, QUOTE_512_BYTES, 0); + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->cipher_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; + + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); + + return TEST_SUCCESS; +} + +static int +test_null_auth_only_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + /* Generate test mbuf data and space for digest */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + catch_22_quote, QUOTE_512_BYTES, 0); + + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->auth_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + sym_op->m_src = ut_params->ibuf; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); + + return TEST_SUCCESS; +} + +static int +test_null_cipher_auth_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + /* Generate test mbuf data and space for digest */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + catch_22_quote, QUOTE_512_BYTES, 0); + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->cipher_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + sym_op->m_src = ut_params->ibuf; + + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); return TEST_SUCCESS; } static int -test_not_in_place_crypto(void) +test_null_auth_cipher_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool); - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); + /* Generate test mbuf data and space for digest */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + catch_22_quote, QUOTE_512_BYTES, 0); - /* Create multiple crypto sessions*/ + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->auth_xform); + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = &ut_params->cipher_xform; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->cipher_xform); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - /* Generate test mbuf data and digest */ - ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, - (const char *) - catch_22_quote_2_512_bytes_AES_CBC_ciphertext, - QUOTE_512_BYTES, 0); + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - DIGEST_BYTE_LENGTH_SHA512); - TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - rte_memcpy(ut_params->digest, - catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, - DIGEST_BYTE_LENGTH_SHA512); + sym_op->m_src = ut_params->ibuf; - /* Generate Crypto op data structure */ - ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, - RTE_PKTMBUF_OL_CRYPTO_SYM); - TEST_ASSERT_NOT_NULL(ut_params->ol, - "Failed to allocate pktmbuf offload"); + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; - ut_params->op = &ut_params->ol->op.crypto; + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); - /* Set crypto operation data parameters */ - rte_crypto_sym_op_attach_session(ut_params->op, ut_params->sess); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); - ut_params->op->digest.data = ut_params->digest; - ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( - ut_params->ibuf, QUOTE_512_BYTES); - ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); - ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset( - ut_params->ibuf, 0); - ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; + return TEST_SUCCESS; +} - rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, - CIPHER_IV_LENGTH_AES_CBC); - ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; +static int +test_null_invalid_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; - ut_params->op->data.to_hash.length = QUOTE_512_BYTES; + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - ut_params->op->dst.m = dst_m; - ut_params->op->dst.offset = 0; + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->cipher_xform); + TEST_ASSERT_NULL(ut_params->sess, + "Session creation succeeded unexpectedly"); - /* Process crypto operation */ - ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], - ut_params->ibuf); - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->op->dst.m, char *), - catch_22_quote, - QUOTE_512_BYTES, - "Plaintext data not as expected"); + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - /* Validate obuf */ + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "Digest verification failed"); + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->auth_xform); + TEST_ASSERT_NULL(ut_params->sess, + "Session creation succeeded unexpectedly"); return TEST_SUCCESS; } +#define NULL_BURST_LENGTH (32) + +static int +test_null_burst_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + unsigned i, burst_len = NULL_BURST_LENGTH; + + struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; + struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->valid_devs[0], &ut_params->cipher_xform); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), + burst_len, "failed to generate burst of crypto ops"); + + /* Generate an operation for each mbuf in burst */ + for (i = 0; i < burst_len; i++) { + struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); + + unsigned *data = (unsigned *)rte_pktmbuf_append(m, + sizeof(unsigned)); + *data = i; + + rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); + + burst[i]->sym->m_src = m; + } + + /* Process crypto operation */ + TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], + 0, burst, burst_len), + burst_len, + "Error enqueuing burst"); + + TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], + 0, burst_dequeued, burst_len), + burst_len, + "Error dequeuing burst"); + + + for (i = 0; i < burst_len; i++) { + TEST_ASSERT_EQUAL( + *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), + *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, + uint32_t *), + "data not as expected"); + + rte_pktmbuf_free(burst[i]->sym->m_src); + rte_crypto_op_free(burst[i]); + } + + return TEST_SUCCESS; +} + static struct unit_test_suite cryptodev_qat_testsuite = { .suite_name = "Crypto QAT Unit Test Suite", .setup = testsuite_setup, @@ -1925,9 +3802,79 @@ static struct unit_test_suite cryptodev_qat_testsuite = { test_AES_CBC_HMAC_AES_XCBC_encrypt_digest), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify), - TEST_CASE_ST(ut_setup, ut_teardown, test_stats), + /** AES GCM Authenticated Encryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_7), + + /** AES GCM Authenticated Decryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_7), + + /** Snow3G encrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_5), + + /** Snow3G decrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encrypted_authentication_test_case_1), TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -1967,6 +3914,119 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite = { } }; +static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { + .suite_name = "Crypto Device AESNI GCM Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + /** AES GCM Authenticated Encryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_encryption_test_case_7), + + /** AES GCM Authenticated Decryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_mb_AES_GCM_authenticated_decryption_test_case_7), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { + .suite_name = "Crypto Device SW Snow3G Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + /** Snow3G encrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_5), + + + /** Snow3G decrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encrypted_authentication_test_case_1), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static struct unit_test_suite cryptodev_null_testsuite = { + .suite_name = "Crypto Device NULL Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_auth_only_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_cipher_only_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_cipher_auth_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_auth_cipher_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_invalid_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_burst_operation), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static int test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) { @@ -1991,5 +4051,47 @@ static struct test_command cryptodev_aesni_mb_cmd = { .callback = test_cryptodev_aesni_mb, }; +static int +test_cryptodev_aesni_gcm(void) +{ + gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD; + + return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite); +} + +static struct test_command cryptodev_aesni_gcm_cmd = { + .command = "cryptodev_aesni_gcm_autotest", + .callback = test_cryptodev_aesni_gcm, +}; + +static int +test_cryptodev_null(void) +{ + gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD; + + return unit_test_suite_runner(&cryptodev_null_testsuite); +} + +static struct test_command cryptodev_null_cmd = { + .command = "cryptodev_null_autotest", + .callback = test_cryptodev_null, +}; + +static int +test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) +{ + gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD; + + return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite); +} + +static struct test_command cryptodev_sw_snow3g_cmd = { + .command = "cryptodev_sw_snow3g_autotest", + .callback = test_cryptodev_sw_snow3g, +}; + REGISTER_TEST_COMMAND(cryptodev_qat_cmd); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd); +REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_cmd); +REGISTER_TEST_COMMAND(cryptodev_null_cmd); +REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_cmd);