* [PATCH] test/crypto: add further ZUC testcases
@ 2022-12-21 14:04 Ciara Power
2022-12-21 14:25 ` [PATCH v2] " Ciara Power
2022-12-21 15:20 ` [PATCH] " Zhang, Fan
0 siblings, 2 replies; 6+ messages in thread
From: Ciara Power @ 2022-12-21 14:04 UTC (permalink / raw)
To: Akhil Goyal, Fan Zhang; +Cc: dev, kai.ji, Ciara Power
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.power@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
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH v2] test/crypto: add further ZUC testcases
2022-12-21 14:04 [PATCH] test/crypto: add further ZUC testcases Ciara Power
@ 2022-12-21 14:25 ` Ciara Power
2023-01-04 15:09 ` [EXT] " Tejasree Kondoj
2022-12-21 15:20 ` [PATCH] " Zhang, Fan
1 sibling, 1 reply; 6+ messages in thread
From: Ciara Power @ 2022-12-21 14:25 UTC (permalink / raw)
To: Akhil Goyal, Fan Zhang; +Cc: dev, kai.ji, Ciara Power
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.power@intel.com>
---
v2: fixed variable initialisation.
---
app/test/test_cryptodev.c | 446 +++++++++++++++++++++++++++++++-------
1 file changed, 363 insertions(+), 83 deletions(-)
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index d6ae762df9..4af17d14f7 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -5950,15 +5950,18 @@ 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 = 0;
+ unsigned int ciphertext_len = 0;
struct rte_cryptodev_info dev_info;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
@@ -5980,7 +5983,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 +5996,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 +6035,57 @@ 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 = 0;
+ unsigned int ciphertext_len = 0;
+ 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 +6112,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 +6149,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 +6170,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 +6251,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 +6272,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 +6294,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 +7252,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 +7564,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 +16335,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 +16373,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 +16438,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
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] test/crypto: add further ZUC testcases
2022-12-21 14:04 [PATCH] test/crypto: add further ZUC testcases Ciara Power
2022-12-21 14:25 ` [PATCH v2] " Ciara Power
@ 2022-12-21 15:20 ` Zhang, Fan
2023-01-05 13:45 ` Power, Ciara
1 sibling, 1 reply; 6+ messages in thread
From: Zhang, Fan @ 2022-12-21 15:20 UTC (permalink / raw)
To: Ciara Power, Akhil Goyal; +Cc: dev, kai.ji, fanzhang.oss
Hi Ciara,
On 12/21/2022 2:04 PM, Ciara Power wrote:
> 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.
<snip>
> + if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
<snip>
> + } else {
> + if (ut_params->obuf)
> + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
> + else
> + plaintext = ciphertext;
> +
> + debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
> +
The below line looks a bit off: bits len = bytes len * 8 right?
> + 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");
<snip>
> 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;
Just a piece of advice: Instead of allocating 2 buffers and we may use
only one in either direction,
we may use
uint8_t buffers[2048];
uint8_t *ciphertext_buffer = NULL, *plaintext_buffer = NULL;
And pointing either ciphertext_buffer or plaintext_buffer to buffers
based on the direction value?
> + 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)
Just a nit,
we may pass "enum rte_crypto_auth_operation" as parameter below, instead
of a "verify" for passing.
This also makes the changes below more readable.
> +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()
> }
> };
^ permalink raw reply [flat|nested] 6+ messages in thread
* RE: [EXT] [PATCH v2] test/crypto: add further ZUC testcases
2022-12-21 14:25 ` [PATCH v2] " Ciara Power
@ 2023-01-04 15:09 ` Tejasree Kondoj
2023-01-05 11:01 ` Akhil Goyal
0 siblings, 1 reply; 6+ messages in thread
From: Tejasree Kondoj @ 2023-01-04 15:09 UTC (permalink / raw)
To: Ciara Power, Akhil Goyal, Fan Zhang; +Cc: dev, kai.ji
Acked-by: Tejasree Kondoj <ktejasree@marvell.com>
> -----Original Message-----
> From: Ciara Power <ciara.power@intel.com>
> Sent: Wednesday, December 21, 2022 7:56 PM
> To: Akhil Goyal <gakhil@marvell.com>; Fan Zhang
> <fanzhang.oss@gmail.com>
> Cc: dev@dpdk.org; kai.ji@intel.com; Ciara Power <ciara.power@intel.com>
> Subject: [EXT] [PATCH v2] test/crypto: add further ZUC testcases
>
> External Email
>
> ----------------------------------------------------------------------
> 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.power@intel.com>
>
> ---
> v2: fixed variable initialisation.
> ---
> app/test/test_cryptodev.c | 446 +++++++++++++++++++++++++++++++-------
> 1 file changed, 363 insertions(+), 83 deletions(-)
>
> diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index
> d6ae762df9..4af17d14f7 100644
> --- a/app/test/test_cryptodev.c
> +++ b/app/test/test_cryptodev.c
> @@ -5950,15 +5950,18 @@ 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 = 0;
> + unsigned int ciphertext_len = 0;
> struct rte_cryptodev_info dev_info;
>
> rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -
> 5980,7 +5983,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 +5996,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 +6035,57 @@ 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 = 0;
> + unsigned int ciphertext_len = 0;
> + 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 +6112,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 +6149,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 +6170,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 +6251,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 +6272,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 +6294,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 +7252,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 +7564,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 +16335,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 +16373,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 +16438,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
^ permalink raw reply [flat|nested] 6+ messages in thread
* RE: [EXT] [PATCH v2] test/crypto: add further ZUC testcases
2023-01-04 15:09 ` [EXT] " Tejasree Kondoj
@ 2023-01-05 11:01 ` Akhil Goyal
0 siblings, 0 replies; 6+ messages in thread
From: Akhil Goyal @ 2023-01-05 11:01 UTC (permalink / raw)
To: Tejasree Kondoj, Ciara Power, Fan Zhang; +Cc: dev, kai.ji
> Acked-by: Tejasree Kondoj <ktejasree@marvell.com>
>
> > 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.power@intel.com>
> >
> > ---
> > v2: fixed variable initialisation.
Applied to dpdk-next-crypto
Thanks.
^ permalink raw reply [flat|nested] 6+ messages in thread
* RE: [PATCH] test/crypto: add further ZUC testcases
2022-12-21 15:20 ` [PATCH] " Zhang, Fan
@ 2023-01-05 13:45 ` Power, Ciara
0 siblings, 0 replies; 6+ messages in thread
From: Power, Ciara @ 2023-01-05 13:45 UTC (permalink / raw)
To: Zhang, Fan, Akhil Goyal; +Cc: dev, Ji, Kai
Hi Fan,
> -----Original Message-----
> From: Zhang, Fan <fanzhang.oss@gmail.com>
> Sent: Wednesday 21 December 2022 15:21
> To: Power, Ciara <ciara.power@intel.com>; Akhil Goyal
> <gakhil@marvell.com>
> Cc: dev@dpdk.org; Ji, Kai <kai.ji@intel.com>; fanzhang.oss@gmail.com
> Subject: Re: [PATCH] test/crypto: add further ZUC testcases
>
> Hi Ciara,
>
> On 12/21/2022 2:04 PM, Ciara Power wrote:
> > 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.
> <snip>
> > + if (direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
> <snip>
> > + } else {
> > + if (ut_params->obuf)
> > + plaintext = rte_pktmbuf_mtod(ut_params->obuf,
> uint8_t *);
> > + else
> > + plaintext = ciphertext;
> > +
> > + debug_hexdump(stdout, "plaintext:", plaintext,
> ciphertext_len);
> > +
> The below line looks a bit off: bits len = bytes len * 8 right?
[CP]
Yes think this should be : (tdata->validCipherOffsetInBits.len >> 3)
> > + 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");
> <snip>
> > 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;
>
> Just a piece of advice: Instead of allocating 2 buffers and we may use only
> one in either direction,
>
> we may use
>
> uint8_t buffers[2048];
>
> uint8_t *ciphertext_buffer = NULL, *plaintext_buffer = NULL;
>
> And pointing either ciphertext_buffer or plaintext_buffer to buffers based
> on the direction value?
[CP]
Good idea.
Probably no need to even have individual ct/pt buffer pointers either here
>
> > + 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)
>
> Just a nit,
>
> we may pass "enum rte_crypto_auth_operation" as parameter below,
> instead of a "verify" for passing.
>
> This also makes the changes below more readable.
>
[CP]
Yes, will make this change, thanks.
> > +test_zuc_authentication(const struct wireless_test_data *tdata,
> > +uint8_t verify)
[CP]
I missed these suggestions for my v2, which has since been merged.
I will send a small improvement patch to make these changes - thanks!
Ciara
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2023-01-05 13:45 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-12-21 14:04 [PATCH] test/crypto: add further ZUC testcases Ciara Power
2022-12-21 14:25 ` [PATCH v2] " Ciara Power
2023-01-04 15:09 ` [EXT] " Tejasree Kondoj
2023-01-05 11:01 ` Akhil Goyal
2022-12-21 15:20 ` [PATCH] " Zhang, Fan
2023-01-05 13:45 ` Power, Ciara
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).