process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
{
if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
- printf("Error sending packet for encryption");
+ RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
return NULL;
}
while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
rte_pause();
+ if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
+ RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
+ return NULL;
+ }
+
return op;
}
/* Create Crypto session*/
ut_params->sess = rte_cryptodev_sym_session_create(
ts_params->session_mpool);
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
+ if (status == -ENOTSUP)
+ return status;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
return 0;
}
/* Create Crypto session*/
ut_params->sess = rte_cryptodev_sym_session_create(
ts_params->session_mpool);
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+
+ if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
+ ut_params->auth_xform.next = NULL;
+ ut_params->cipher_xform.next = &ut_params->auth_xform;
+ status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+ &ut_params->cipher_xform,
+ ts_params->session_priv_mpool);
+
+ } else
+ status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+ &ut_params->auth_xform,
+ ts_params->session_priv_mpool);
+
+ if (status == -ENOTSUP)
+ return status;
- status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
- &ut_params->auth_xform,
- ts_params->session_priv_mpool);
TEST_ASSERT_EQUAL(status, 0, "session init failed");
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
return 0;
}
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
+ enum rte_crypto_cipher_algorithm cipher_algo =
+ ut_params->cipher_xform.cipher.algo;
+ enum rte_crypto_auth_algorithm auth_algo =
+ ut_params->auth_xform.auth.algo;
+
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
RTE_CRYPTO_OP_TYPE_SYMMETRIC);
TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
"no room to append auth tag");
ut_params->digest = sym_op->auth.digest.data;
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
- ut_params->ibuf, data_pad_len);
+
+ if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ ut_params->ibuf, data_pad_len);
+ } else {
+ struct rte_mbuf *m = ut_params->ibuf;
+ unsigned int offset = data_pad_len;
+
+ while (offset > m->data_len && m->next != NULL) {
+ offset -= m->data_len;
+ m = m->next;
+ }
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ m, offset);
+ }
+
if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
memset(sym_op->auth.digest.data, 0, auth_tag_len);
else
iv_ptr += cipher_iv_len;
rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
- sym_op->cipher.data.length = cipher_len;
- sym_op->cipher.data.offset = cipher_offset;
- sym_op->auth.data.length = auth_len;
- sym_op->auth.data.offset = auth_offset;
+ if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
+ cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
+ cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
+ sym_op->cipher.data.length = cipher_len;
+ sym_op->cipher.data.offset = cipher_offset;
+ } else {
+ sym_op->cipher.data.length = cipher_len >> 3;
+ sym_op->cipher.data.offset = cipher_offset >> 3;
+ }
+
+ if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
+ auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
+ auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
+ sym_op->auth.data.length = auth_len;
+ sym_op->auth.data.offset = auth_offset;
+ } else {
+ sym_op->auth.data.length = auth_len >> 3;
+ sym_op->auth.data.offset = auth_offset >> 3;
+ }
return 0;
}
static int
-create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
+create_wireless_algo_auth_cipher_operation(
+ const uint8_t *auth_tag, unsigned int auth_tag_len,
const uint8_t *cipher_iv, uint8_t cipher_iv_len,
const uint8_t *auth_iv, uint8_t auth_iv_len,
unsigned int data_pad_len,
unsigned int cipher_len, unsigned int cipher_offset,
unsigned int auth_len, unsigned int auth_offset,
- uint8_t op_mode, uint8_t do_sgl)
+ uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
}
}
+ /* Copy digest for the verification */
+ if (verify)
+ memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
+
/* Copy cipher and auth IVs at the end of the crypto operation */
uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
ut_params->op, uint8_t *, IV_OFFSET);
/* Create SNOW 3G operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
tdata->auth_iv.data, tdata->auth_iv.len,
(tdata->digest.offset_bytes == 0 ?
tdata->cipher.offset_bits,
tdata->validAuthLenInBits.len,
tdata->auth.offset_bits,
- op_mode, 0);
+ op_mode, 0, verify);
if (retval < 0)
return retval;
/* Create SNOW 3G operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
tdata->auth_iv.data, tdata->auth_iv.len,
(tdata->digest.offset_bytes == 0 ?
tdata->cipher.offset_bits,
tdata->validAuthLenInBits.len,
tdata->auth.offset_bits,
- op_mode, 1);
+ op_mode, 1, verify);
if (retval < 0)
return retval;
/* Create KASUMI operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
NULL, 0,
(tdata->digest.offset_bytes == 0 ?
tdata->validCipherOffsetInBits.len,
tdata->validAuthLenInBits.len,
0,
- op_mode, 0);
+ op_mode, 0, verify);
if (retval < 0)
return retval;
/* Create KASUMI operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
NULL, 0,
(tdata->digest.offset_bytes == 0 ?
tdata->validCipherOffsetInBits.len,
tdata->validAuthLenInBits.len,
0,
- op_mode, 1);
+ op_mode, 1, verify);
if (retval < 0)
return retval;
/* Create ZUC operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
tdata->auth_iv.data, tdata->auth_iv.len,
(tdata->digest.offset_bytes == 0 ?
tdata->validCipherOffsetInBits.len,
tdata->validAuthLenInBits.len,
0,
- op_mode, 0);
+ op_mode, 0, verify);
if (retval < 0)
return retval;
/* Create ZUC operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest.len,
+ tdata->digest.data, tdata->digest.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
NULL, 0,
(tdata->digest.offset_bytes == 0 ?
tdata->validCipherOffsetInBits.len,
tdata->validAuthLenInBits.len,
0,
- op_mode, 1);
+ op_mode, 1, verify);
if (retval < 0)
return retval;
unsigned int ciphertext_len;
struct rte_cryptodev_info dev_info;
+ struct rte_crypto_op *op;
- /* Check if device supports particular algorithms */
+ /* Check if device supports particular algorithms separately */
if (test_mixed_check_if_unsupported(tdata))
return -ENOTSUP;
}
/* Create the session */
- retval = create_wireless_algo_auth_cipher_session(
- ts_params->valid_devs[0],
- (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
- : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
- (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
- : RTE_CRYPTO_AUTH_OP_GENERATE),
- tdata->auth_algo,
- tdata->cipher_algo,
- tdata->auth_key.data, tdata->auth_key.len,
- tdata->auth_iv.len, tdata->digest_enc.len,
- tdata->cipher_iv.len);
-
+ if (verify)
+ retval = create_wireless_algo_cipher_auth_session(
+ ts_params->valid_devs[0],
+ RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ tdata->auth_algo,
+ tdata->cipher_algo,
+ tdata->auth_key.data, tdata->auth_key.len,
+ tdata->auth_iv.len, tdata->digest_enc.len,
+ tdata->cipher_iv.len);
+ else
+ retval = create_wireless_algo_auth_cipher_session(
+ ts_params->valid_devs[0],
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_AUTH_OP_GENERATE,
+ tdata->auth_algo,
+ tdata->cipher_algo,
+ tdata->auth_key.data, tdata->auth_key.len,
+ tdata->auth_iv.len, tdata->digest_enc.len,
+ tdata->cipher_iv.len);
if (retval < 0)
return retval;
/* Create the operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest_enc.len,
+ tdata->digest_enc.data, tdata->digest_enc.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
tdata->auth_iv.data, tdata->auth_iv.len,
(tdata->digest_enc.offset == 0 ?
- (verify ? ciphertext_pad_len : plaintext_pad_len)
+ plaintext_pad_len
: tdata->digest_enc.offset),
tdata->validCipherLen.len_bits,
tdata->cipher.offset_bits,
tdata->validAuthLen.len_bits,
tdata->auth.offset_bits,
- op_mode, 0);
+ op_mode, 0, verify);
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
+ /* Check if the op failed because the device doesn't */
+ /* support this particular combination of algorithms */
+ if (op == NULL && ut_params->op->status ==
+ RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
+ printf("Device doesn't support this mixed combination. "
+ "Test Skipped.\n");
+ return -ENOTSUP;
+ }
+ ut_params->op = op;
+
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = (op_mode == IN_PLACE ?
(tdata->cipher.offset_bits >> 3);
debug_hexdump(stdout, "plaintext:", plaintext,
- (tdata->plaintext.len_bits >> 3) -
- tdata->digest_enc.len);
+ tdata->plaintext.len_bits >> 3);
debug_hexdump(stdout, "plaintext expected:",
tdata->plaintext.data,
- (tdata->plaintext.len_bits >> 3) -
- tdata->digest_enc.len);
+ tdata->plaintext.len_bits >> 3);
} else {
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
"Generated auth tag not as expected");
}
+
+ TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "crypto op processing failed");
+
return 0;
}
uint8_t digest_buffer[10000];
struct rte_cryptodev_info dev_info;
+ struct rte_crypto_op *op;
/* Check if device supports particular algorithms */
if (test_mixed_check_if_unsupported(tdata))
}
/* Create the session */
- retval = create_wireless_algo_auth_cipher_session(
- ts_params->valid_devs[0],
- (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
- : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
- (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
- : RTE_CRYPTO_AUTH_OP_GENERATE),
- tdata->auth_algo,
- tdata->cipher_algo,
- tdata->auth_key.data, tdata->auth_key.len,
- tdata->auth_iv.len, tdata->digest_enc.len,
- tdata->cipher_iv.len);
-
+ if (verify)
+ retval = create_wireless_algo_cipher_auth_session(
+ ts_params->valid_devs[0],
+ RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ tdata->auth_algo,
+ tdata->cipher_algo,
+ tdata->auth_key.data, tdata->auth_key.len,
+ tdata->auth_iv.len, tdata->digest_enc.len,
+ tdata->cipher_iv.len);
+ else
+ retval = create_wireless_algo_auth_cipher_session(
+ ts_params->valid_devs[0],
+ RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_AUTH_OP_GENERATE,
+ tdata->auth_algo,
+ tdata->cipher_algo,
+ tdata->auth_key.data, tdata->auth_key.len,
+ tdata->auth_iv.len, tdata->digest_enc.len,
+ tdata->cipher_iv.len);
if (retval < 0)
return retval;
plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
- plaintext_pad_len, 15, 0);
+ ciphertext_pad_len, 15, 0);
TEST_ASSERT_NOT_NULL(ut_params->ibuf,
"Failed to allocate input buffer in mempool");
/* Create the operation */
retval = create_wireless_algo_auth_cipher_operation(
- tdata->digest_enc.len,
+ tdata->digest_enc.data, tdata->digest_enc.len,
tdata->cipher_iv.data, tdata->cipher_iv.len,
tdata->auth_iv.data, tdata->auth_iv.len,
(tdata->digest_enc.offset == 0 ?
- (verify ? ciphertext_pad_len : plaintext_pad_len)
+ plaintext_pad_len
: tdata->digest_enc.offset),
tdata->validCipherLen.len_bits,
tdata->cipher.offset_bits,
tdata->validAuthLen.len_bits,
tdata->auth.offset_bits,
- op_mode, 1);
+ op_mode, 1, verify);
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
+ /* Check if the op failed because the device doesn't */
+ /* support this particular combination of algorithms */
+ if (op == NULL && ut_params->op->status ==
+ RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
+ printf("Device doesn't support this mixed combination. "
+ "Test Skipped.\n");
+ return -ENOTSUP;
+ }
+
+ ut_params->op = op;
+
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = (op_mode == IN_PLACE ?
tdata->digest_enc.len,
"Generated auth tag not as expected");
}
+
+ TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "crypto op processing failed");
+
return 0;
}
&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
}
+/** MIXED AUTH + CIPHER */
+
+static int
+test_auth_zuc_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_zuc_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_aes_cmac_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_zuc_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_snow_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_snow_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_snow_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_aes_cmac_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_null_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_null_cipher_snow_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_null_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_null_cipher_zuc_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_snow_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_snow_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_zuc_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_zuc_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_null_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+}
+
+static int
+test_auth_aes_cmac_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+}
+
+static int
+test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
+{
+ return test_mixed_auth_cipher(
+ &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+}
+
static int
test_3DES_chain_qat_all(void)
{
ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
- TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
- RTE_CRYPTO_OP_STATUS_SUCCESS,
- "authentication not failed");
- ut_params->obuf = ut_params->op->sym->m_src;
- TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+ TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
return 0;
}
ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
- TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
- RTE_CRYPTO_OP_STATUS_SUCCESS,
- "authentication not failed");
- ut_params->obuf = ut_params->op->sym->m_src;
- TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+ TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
return 0;
}
ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
- TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
- RTE_CRYPTO_OP_STATUS_SUCCESS,
- "authentication not failed");
-
- ut_params->obuf = ut_params->op->sym->m_src;
- TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+ TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
return 0;
}
const unsigned int auth_tag_len = tdata->auth_tag.len;
const unsigned int iv_len = tdata->iv.len;
unsigned int aad_len = tdata->aad.len;
+ unsigned int aad_len_pad = 0;
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
+ aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
+
sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, aad_len);
+ ut_params->ibuf, aad_len_pad);
TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
"no room to prepend aad");
sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
}
sym_op->aead.data.length = tdata->plaintext.len;
- sym_op->aead.data.offset = aad_len;
+ sym_op->aead.data.offset = aad_len_pad;
return 0;
}
int ecx = 0;
void *digest_mem = NULL;
- uint32_t prepend_len = tdata->aad.len;
+ uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
if (tdata->plaintext.len % fragsz != 0) {
if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_authenticated_encryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
TEST_CASE_ST(ut_setup, ut_teardown,
test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
+ /** AUTH ZUC + CIPHER SNOW3G */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_zuc_cipher_snow_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_zuc_cipher_snow_test_case_1),
+ /** AUTH AES CMAC + CIPHER SNOW3G */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_aes_cmac_cipher_snow_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_aes_cmac_cipher_snow_test_case_1),
+ /** AUTH ZUC + CIPHER AES CTR */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_zuc_cipher_aes_ctr_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
+ /** AUTH SNOW3G + CIPHER AES CTR */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_snow_cipher_aes_ctr_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_snow_cipher_aes_ctr_test_case_1),
+ /** AUTH SNOW3G + CIPHER ZUC */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_snow_cipher_zuc_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_snow_cipher_zuc_test_case_1),
+ /** AUTH AES CMAC + CIPHER ZUC */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_aes_cmac_cipher_zuc_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
+
+ /** AUTH NULL + CIPHER SNOW3G */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_null_cipher_snow_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_null_cipher_snow_test_case_1),
+ /** AUTH NULL + CIPHER ZUC */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_null_cipher_zuc_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_null_cipher_zuc_test_case_1),
+ /** AUTH SNOW3G + CIPHER NULL */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_snow_cipher_null_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_snow_cipher_null_test_case_1),
+ /** AUTH ZUC + CIPHER NULL */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_zuc_cipher_null_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_zuc_cipher_null_test_case_1),
+ /** AUTH NULL + CIPHER AES CTR */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_null_cipher_aes_ctr_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_null_cipher_aes_ctr_test_case_1),
+ /** AUTH AES CMAC + CIPHER NULL */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_auth_aes_cmac_cipher_null_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_auth_aes_cmac_cipher_null_test_case_1),
+
TEST_CASES_END() /**< NULL terminate unit test array */
}
};