From: "Zhang, Fan" <fanzhang.oss@gmail.com>
To: Ciara Power <ciara.power@intel.com>, Akhil Goyal <gakhil@marvell.com>
Cc: dev@dpdk.org, kai.ji@intel.com, fanzhang.oss@gmail.com
Subject: Re: [PATCH] test/crypto: add further ZUC testcases
Date: Wed, 21 Dec 2022 15:20:57 +0000 [thread overview]
Message-ID: <11bb2aaa-220c-86e1-96f1-c81a68d37c6e@gmail.com> (raw)
In-Reply-To: <20221221140451.75074-1-ciara.power@intel.com>
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()
> }
> };
next prev parent reply other threads:[~2022-12-21 15:21 UTC|newest]
Thread overview: 6+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-12-21 14:04 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 ` Zhang, Fan [this message]
2023-01-05 13:45 ` [PATCH] " Power, Ciara
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=11bb2aaa-220c-86e1-96f1-c81a68d37c6e@gmail.com \
--to=fanzhang.oss@gmail.com \
--cc=ciara.power@intel.com \
--cc=dev@dpdk.org \
--cc=gakhil@marvell.com \
--cc=kai.ji@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).