Previously no ZUC decryption only or hash verify testcases existed,
only encryption and authentication.
This commit adds testcases for ZUC 128 and 256 decryption,
and hash verify.
Signed-off-by: Ciara Power <ciara.po...@intel.com>
---
app/test/test_cryptodev.c | 444 +++++++++++++++++++++++++++++++-------
1 file changed, 361 insertions(+), 83 deletions(-)
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index d6ae762df9..0b3221b8b5 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -5950,15 +5950,17 @@ check_auth_capability(const struct
crypto_testsuite_params *ts_params,
}
static int
-test_zuc_encryption(const struct wireless_test_data *tdata)
+test_zuc_cipher(const struct wireless_test_data *tdata,
+ enum rte_crypto_cipher_operation direction)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
int retval;
- uint8_t *plaintext, *ciphertext;
- unsigned plaintext_pad_len;
- unsigned plaintext_len;
+ uint8_t *plaintext = NULL;
+ uint8_t *ciphertext = NULL;
+ unsigned int plaintext_pad_len, ciphertext_pad_len;
+ unsigned int plaintext_len, ciphertext_len;
struct rte_cryptodev_info dev_info;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
@@ -5980,7 +5982,7 @@ test_zuc_encryption(const struct wireless_test_data
*tdata)
/* Create ZUC session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
- RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ direction,
RTE_CRYPTO_CIPHER_ZUC_EEA3,
tdata->key.data, tdata->key.len,
tdata->cipher_iv.len);
@@ -5993,15 +5995,27 @@ test_zuc_encryption(const struct wireless_test_data
*tdata)
memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
rte_pktmbuf_tailroom(ut_params->ibuf));
- plaintext_len = ceil_byte_length(tdata->plaintext.len);
- /* Append data which is padded to a multiple */
- /* of the algorithms block size */
- plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
- plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+ plaintext_len = ceil_byte_length(tdata->plaintext.len);
+ /* Append data which is padded to a multiple */
+ /* of the algorithms block size */
+ plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
plaintext_pad_len);
- memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+ memcpy(plaintext, tdata->plaintext.data, plaintext_len);
- debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+ debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+ } else {
+ ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+ /* Append data which is padded to a multiple */
+ /* of the algorithms block size */
+ ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
+ ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ ciphertext_pad_len);
+ memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
+
+ debug_hexdump(stdout, "ciphertext:", ciphertext,
ciphertext_len);
+ }
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -6020,34 +6034,56 @@ test_zuc_encryption(const struct wireless_test_data
*tdata)
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
- if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
- else
- ciphertext = plaintext;
- debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+ if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+ if (ut_params->obuf)
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t
*);
+ else
+ ciphertext = plaintext;
+
+ debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ ciphertext,
+ tdata->ciphertext.data,
+ tdata->validCipherLenInBits.len,
+ "ZUC Ciphertext data not as expected");
+ } else {
+ if (ut_params->obuf)
+ plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t
*);
+ else
+ plaintext = ciphertext;
+
+ debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+
+ const uint8_t *reference_plaintext = tdata->plaintext.data +
+ (tdata->validCipherOffsetInBits.len);
+
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ plaintext,
+ reference_plaintext,
+ tdata->validCipherLenInBits.len,
+ "ZUC Plaintext data not as expected");
+ }
- /* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
- ciphertext,
- tdata->ciphertext.data,
- tdata->validCipherLenInBits.len,
- "ZUC Ciphertext data not as expected");
return 0;
}
static int
-test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
+test_zuc_cipher_sgl(const struct wireless_test_data *tdata,
+ enum rte_crypto_cipher_operation direction)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
int retval;
- unsigned int plaintext_pad_len;
- unsigned int plaintext_len;
- const uint8_t *ciphertext;
- uint8_t ciphertext_buffer[2048];
+ unsigned int plaintext_pad_len, ciphertext_pad_len;
+ unsigned int plaintext_len, ciphertext_len;
+ const uint8_t *ciphertext, *plaintext;
+ uint8_t ciphertext_buffer[2048], plaintext_buffer[2048];
struct rte_cryptodev_info dev_info;
/* Check if device supports ZUC EEA3 */
@@ -6074,21 +6110,36 @@ test_zuc_encryption_sgl(const struct wireless_test_data
*tdata)
return TEST_SKIPPED;
}
- plaintext_len = ceil_byte_length(tdata->plaintext.len);
+ if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+ plaintext_len = ceil_byte_length(tdata->plaintext.len);
- /* Append data which is padded to a multiple */
- /* of the algorithms block size */
- plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+ /* Append data which is padded to a multiple */
+ /* of the algorithms block size */
+ plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
- ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
- plaintext_pad_len, 10, 0);
+ ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+ plaintext_pad_len, 10, 0);
- pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
- tdata->plaintext.data);
+ pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
+ tdata->plaintext.data);
+ } else {
+ ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+
+ /* Append data which is padded to a multiple */
+ /* of the algorithms block size */
+ ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
+
+ ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+ ciphertext_pad_len, 10, 0);
+
+ pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
+ tdata->ciphertext.data);
+
+ }
/* Create ZUC session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
- RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ direction,
RTE_CRYPTO_CIPHER_ZUC_EEA3,
tdata->key.data, tdata->key.len,
tdata->cipher_iv.len);
@@ -6096,8 +6147,10 @@ test_zuc_encryption_sgl(const struct wireless_test_data
*tdata)
return retval;
/* Clear mbuf payload */
-
- pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+ if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
+ pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
tdata->plaintext.data);
+ else
+ pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
tdata->ciphertext.data);
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -6115,28 +6168,48 @@ test_zuc_encryption_sgl(const struct wireless_test_data
*tdata)
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
- if (ut_params->obuf)
- ciphertext = rte_pktmbuf_read(ut_params->obuf,
- 0, plaintext_len, ciphertext_buffer);
- else
- ciphertext = rte_pktmbuf_read(ut_params->ibuf,
- 0, plaintext_len, ciphertext_buffer);
- /* Validate obuf */
- debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+ if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+ if (ut_params->obuf)
+ ciphertext = rte_pktmbuf_read(ut_params->obuf,
+ 0, plaintext_len, ciphertext_buffer);
+ else
+ ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+ 0, plaintext_len, ciphertext_buffer);
- /* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
- ciphertext,
- tdata->ciphertext.data,
- tdata->validCipherLenInBits.len,
- "ZUC Ciphertext data not as expected");
+ /* Validate obuf */
+ debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ ciphertext,
+ tdata->ciphertext.data,
+ tdata->validCipherLenInBits.len,
+ "ZUC Ciphertext data not as expected");
+ } else {
+ if (ut_params->obuf)
+ plaintext = rte_pktmbuf_read(ut_params->obuf,
+ 0, ciphertext_len, plaintext_buffer);
+ else
+ plaintext = rte_pktmbuf_read(ut_params->ibuf,
+ 0, ciphertext_len, plaintext_buffer);
+
+ /* Validate obuf */
+ debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ plaintext,
+ tdata->plaintext.data,
+ tdata->validCipherLenInBits.len,
+ "ZUC Plaintext data not as expected");
+ }
return 0;
}
static int
-test_zuc_authentication(const struct wireless_test_data *tdata)
+test_zuc_authentication(const struct wireless_test_data *tdata, uint8_t verify)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
@@ -6176,7 +6249,8 @@ test_zuc_authentication(const struct wireless_test_data
*tdata)
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->auth_iv.len, tdata->digest.len,
- RTE_CRYPTO_AUTH_OP_GENERATE,
+ (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+ : RTE_CRYPTO_AUTH_OP_GENERATE),
RTE_CRYPTO_AUTH_ZUC_EIA3);
if (retval != 0)
return retval;
@@ -6196,9 +6270,12 @@ test_zuc_authentication(const struct wireless_test_data
*tdata)
memcpy(plaintext, tdata->plaintext.data, plaintext_len);
/* Create ZUC operation */
- retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
+ retval = create_wireless_algo_hash_operation(tdata->digest.data,
+ tdata->digest.len,
tdata->auth_iv.data, tdata->auth_iv.len,
- plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+ plaintext_pad_len,
+ (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+ : RTE_CRYPTO_AUTH_OP_GENERATE),
tdata->validAuthLenInBits.len,
0);
if (retval < 0)
@@ -6215,12 +6292,21 @@ test_zuc_authentication(const struct wireless_test_data
*tdata)
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+ plaintext_pad_len;
+ if (!verify) {
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL(
+ ut_params->digest,
+ tdata->digest.data,
+ tdata->digest.len,
+ "ZUC Generated auth tag not as expected");
+ return 0;
+ }
+
/* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- ut_params->digest,
- tdata->digest.data,
- tdata->digest.len,
- "ZUC Generated auth tag not as expected");
+ if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
+ return 0;
+ else
+ return -1;
return 0;
}
@@ -7164,103 +7250,217 @@ test_kasumi_cipher_auth_test_case_1(void)
static int
test_zuc_encryption_test_case_1(void)
{
- return test_zuc_encryption(&zuc_test_case_cipher_193b);
+ return test_zuc_cipher(&zuc_test_case_cipher_193b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc_encryption_test_case_2(void)
{
- return test_zuc_encryption(&zuc_test_case_cipher_800b);
+ return test_zuc_cipher(&zuc_test_case_cipher_800b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc_encryption_test_case_3(void)
{
- return test_zuc_encryption(&zuc_test_case_cipher_1570b);
+ return test_zuc_cipher(&zuc_test_case_cipher_1570b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc_encryption_test_case_4(void)
{
- return test_zuc_encryption(&zuc_test_case_cipher_2798b);
+ return test_zuc_cipher(&zuc_test_case_cipher_2798b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc_encryption_test_case_5(void)
{
- return test_zuc_encryption(&zuc_test_case_cipher_4019b);
+ return test_zuc_cipher(&zuc_test_case_cipher_4019b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc_encryption_test_case_6_sgl(void)
{
- return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
+ return test_zuc_cipher_sgl(&zuc_test_case_cipher_193b,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_1(void)
+{
+ return test_zuc_cipher(&zuc_test_case_cipher_193b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_2(void)
+{
+ return test_zuc_cipher(&zuc_test_case_cipher_800b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_3(void)
+{
+ return test_zuc_cipher(&zuc_test_case_cipher_1570b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_4(void)
+{
+ return test_zuc_cipher(&zuc_test_case_cipher_2798b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_5(void)
+{
+ return test_zuc_cipher(&zuc_test_case_cipher_4019b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc_decryption_test_case_6_sgl(void)
+{
+ return test_zuc_cipher_sgl(&zuc_test_case_cipher_193b,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
}
static int
test_zuc_hash_generate_test_case_1(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_1b);
+ return test_zuc_authentication(&zuc_test_case_auth_1b, 0);
}
static int
test_zuc_hash_generate_test_case_2(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_90b);
+ return test_zuc_authentication(&zuc_test_case_auth_90b, 0);
}
static int
test_zuc_hash_generate_test_case_3(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_577b);
+ return test_zuc_authentication(&zuc_test_case_auth_577b, 0);
}
static int
test_zuc_hash_generate_test_case_4(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_2079b);
+ return test_zuc_authentication(&zuc_test_case_auth_2079b, 0);
}
static int
test_zuc_hash_generate_test_case_5(void)
{
- return test_zuc_authentication(&zuc_test_auth_5670b);
+ return test_zuc_authentication(&zuc_test_auth_5670b, 0);
}
static int
test_zuc_hash_generate_test_case_6(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_128b);
+ return test_zuc_authentication(&zuc_test_case_auth_128b, 0);
}
static int
test_zuc_hash_generate_test_case_7(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_2080b);
+ return test_zuc_authentication(&zuc_test_case_auth_2080b, 0);
}
static int
test_zuc_hash_generate_test_case_8(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_584b);
+ return test_zuc_authentication(&zuc_test_case_auth_584b, 0);
}
static int
test_zuc_hash_generate_test_case_9(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b, 0);
}
static int
test_zuc_hash_generate_test_case_10(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b, 0);
}
static int
test_zuc_hash_generate_test_case_11(void)
{
- return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b, 0);
+}
+
+static int
+test_zuc_hash_verify_test_case_1(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_1b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_2(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_90b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_3(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_577b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_4(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_2079b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_5(void)
+{
+ return test_zuc_authentication(&zuc_test_auth_5670b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_6(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_128b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_7(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_2080b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_8(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_584b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_9(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_10(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b, 1);
+}
+
+static int
+test_zuc_hash_verify_test_case_11(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b, 1);
}
static int
@@ -7362,25 +7562,53 @@ test_zuc_auth_cipher_verify_test_case_2_oop(void)
static int
test_zuc256_encryption_test_case_1(void)
{
- return test_zuc_encryption(&zuc256_test_case_cipher_1);
+ return test_zuc_cipher(&zuc256_test_case_cipher_1,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
}
static int
test_zuc256_encryption_test_case_2(void)
{
- return test_zuc_encryption(&zuc256_test_case_cipher_2);
+ return test_zuc_cipher(&zuc256_test_case_cipher_2,
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT);
+}
+
+static int
+test_zuc256_decryption_test_case_1(void)
+{
+ return test_zuc_cipher(&zuc256_test_case_cipher_1,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+}
+
+static int
+test_zuc256_decryption_test_case_2(void)
+{
+ return test_zuc_cipher(&zuc256_test_case_cipher_2,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
}
static int
test_zuc256_authentication_test_case_1(void)
{
- return test_zuc_authentication(&zuc256_test_case_auth_1);
+ return test_zuc_authentication(&zuc256_test_case_auth_1, 0);
}
static int
test_zuc256_authentication_test_case_2(void)
{
- return test_zuc_authentication(&zuc256_test_case_auth_2);
+ return test_zuc_authentication(&zuc256_test_case_auth_2, 0);
+}
+
+static int
+test_zuc256_authentication_verify_test_case_1(void)
+{
+ return test_zuc_authentication(&zuc256_test_case_auth_1, 1);
+}
+
+static int
+test_zuc256_authentication_verify_test_case_2(void)
+{
+ return test_zuc_authentication(&zuc256_test_case_auth_2, 1);
}
static int
@@ -16105,6 +16333,20 @@ static struct unit_test_suite cryptodev_zuc_testsuite
= {
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_encryption_test_case_6_sgl),
+ /** ZUC decrypt only (EEA3) */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_3),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_4),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_decryption_test_case_6_sgl),
+
/** ZUC authenticate (EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_1),
@@ -16129,6 +16371,30 @@ static struct unit_test_suite cryptodev_zuc_testsuite
= {
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_11),
+ /** ZUC verify (EIA3) */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_3),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_4),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_6),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_7),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_8),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_9),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_10),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_verify_test_case_11),
+
/** ZUC alg-chain (EEA3/EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
@@ -16170,12 +16436,24 @@ static struct unit_test_suite cryptodev_zuc_testsuite
= {
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc256_encryption_test_case_2),
+ /** ZUC-256 decrypt only **/
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_decryption_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_decryption_test_case_2),
+
/** ZUC-256 authentication only **/
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc256_authentication_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc256_authentication_test_case_2),
+ /** ZUC-256 authentication verify only **/
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_authentication_verify_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_authentication_verify_test_case_2),
+
TEST_CASES_END()
}
};
--
2.34.1
