Usually, IV will change for each crypto operation.
Therefore, instead of pointing at the same location,
IV is copied after each crypto operation.
This will let the IV to be passed as an offset from
the beginning of the crypto operation, instead of
a pointer.
Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Acked-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Akhil Goyal <akhil.goyal@nxp.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
RTE_CRYPTO_OP_TYPE_SYMMETRIC,
NUM_MBUFS, MBUF_CACHE_SIZE,
DEFAULT_NUM_XFORMS *
RTE_CRYPTO_OP_TYPE_SYMMETRIC,
NUM_MBUFS, MBUF_CACHE_SIZE,
DEFAULT_NUM_XFORMS *
- sizeof(struct rte_crypto_sym_xform),
+ sizeof(struct rte_crypto_sym_xform) +
+ MAXIMUM_IV_LENGTH,
rte_socket_id());
if (ts_params->op_mpool == NULL) {
RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
rte_socket_id());
if (ts_params->op_mpool == NULL) {
RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
ut_params->ibuf, QUOTE_512_BYTES);
sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
ut_params->ibuf, QUOTE_512_BYTES);
sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
- sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+ sym_op->auth.data.offset = 0;
sym_op->auth.data.length = QUOTE_512_BYTES;
/* Set crypto operation cipher parameters */
sym_op->auth.data.length = QUOTE_512_BYTES;
/* Set crypto operation cipher parameters */
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
- CIPHER_IV_LENGTH_AES_CBC);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
- rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
- CIPHER_IV_LENGTH_AES_CBC);
+ rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
- sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+ sym_op->cipher.data.offset = 0;
sym_op->cipher.data.length = QUOTE_512_BYTES;
/* Process crypto operation */
sym_op->cipher.data.length = QUOTE_512_BYTES;
/* Process crypto operation */
"crypto op processing failed");
/* Validate obuf */
"crypto op processing failed");
/* Validate obuf */
- uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
- uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
+ uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
+ uint8_t *);
TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
ut_params->ibuf, QUOTE_512_BYTES);
sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
ut_params->ibuf, QUOTE_512_BYTES);
sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
- sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+ sym_op->auth.data.offset = 0;
sym_op->auth.data.length = QUOTE_512_BYTES;
sym_op->auth.data.length = QUOTE_512_BYTES;
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
- ut_params->ibuf, 0);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
- rte_memcpy(sym_op->cipher.iv.data, iv,
- CIPHER_IV_LENGTH_AES_CBC);
+ rte_memcpy(sym_op->cipher.iv.data, iv, CIPHER_IV_LENGTH_AES_CBC);
- sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+ sym_op->cipher.data.offset = 0;
sym_op->cipher.data.length = QUOTE_512_BYTES;
/* Process crypto operation */
sym_op->cipher.data.length = QUOTE_512_BYTES;
/* Process crypto operation */
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
- rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
- CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
+ rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
+ catch_22_quote,
QUOTE_512_BYTES,
"Plaintext data not as expected");
QUOTE_512_BYTES,
"Plaintext data not as expected");
-create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
- const unsigned cipher_len,
- const unsigned cipher_offset,
- enum rte_crypto_cipher_algorithm algo)
+create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
+ unsigned int cipher_len,
+ unsigned int cipher_offset)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- unsigned iv_pad_len = 0;
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
sym_op->m_src = ut_params->ibuf;
/* iv */
sym_op->m_src = ut_params->ibuf;
/* iv */
- if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
- else
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
- , iv_pad_len);
-
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
- sym_op->cipher.iv.length = iv_pad_len;
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
+ sym_op->cipher.iv.length = iv_len;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
-create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
- const unsigned cipher_len,
- const unsigned cipher_offset,
- enum rte_crypto_cipher_algorithm algo)
+create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
+ unsigned int cipher_len,
+ unsigned int cipher_offset)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- unsigned iv_pad_len = 0;
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
sym_op->m_dst = ut_params->obuf;
/* iv */
sym_op->m_dst = ut_params->obuf;
/* iv */
- if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
- else
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
- iv_pad_len);
-
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- /* For OOP operation both buffers must have the same size */
- if (ut_params->obuf)
- rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len);
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
- sym_op->cipher.iv.length = iv_pad_len;
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
+ sym_op->cipher.iv.length = iv_len;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
static int
create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
enum rte_crypto_auth_operation op,
static int
create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
enum rte_crypto_auth_operation op,
- enum rte_crypto_auth_algorithm auth_algo,
- enum rte_crypto_cipher_algorithm cipher_algo)
+ enum rte_crypto_auth_algorithm auth_algo)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
const uint8_t *iv = tdata->iv.data;
const uint8_t iv_len = tdata->iv.len;
const unsigned int cipher_len = tdata->validCipherLenInBits.len;
const uint8_t *iv = tdata->iv.data;
const uint8_t iv_len = tdata->iv.len;
const unsigned int cipher_len = tdata->validCipherLenInBits.len;
- const unsigned int cipher_offset = tdata->iv.len << 3;
+ const unsigned int cipher_offset = 0;
const unsigned int auth_len = tdata->validAuthLenInBits.len;
const unsigned int auth_offset = tdata->aad.len << 3;
const unsigned int auth_len = tdata->validAuthLenInBits.len;
const unsigned int auth_offset = tdata->aad.len << 3;
- unsigned int iv_pad_len = 0;
unsigned int aad_buffer_len;
/* Generate Crypto op data structure */
unsigned int aad_buffer_len;
/* Generate Crypto op data structure */
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
/* iv */
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
/* iv */
- if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
- else
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
-
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
- sym_op->cipher.iv.length = iv_pad_len;
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
+ sym_op->cipher.iv.length = iv_len;
+
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
sym_op->cipher.data.offset = cipher_offset + auth_offset;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
sym_op->cipher.data.offset = cipher_offset + auth_offset;
{
return create_wireless_cipher_hash_operation(tdata,
RTE_CRYPTO_AUTH_OP_GENERATE,
{
return create_wireless_cipher_hash_operation(tdata,
RTE_CRYPTO_AUTH_OP_GENERATE,
- RTE_CRYPTO_AUTH_ZUC_EIA3,
- RTE_CRYPTO_CIPHER_ZUC_EEA3);
+ RTE_CRYPTO_AUTH_ZUC_EIA3);
unsigned data_pad_len,
enum rte_crypto_auth_operation op,
enum rte_crypto_auth_algorithm auth_algo,
unsigned data_pad_len,
enum rte_crypto_auth_operation op,
enum rte_crypto_auth_algorithm auth_algo,
- enum rte_crypto_cipher_algorithm cipher_algo,
const uint8_t *iv, const uint8_t iv_len,
const unsigned cipher_len, const unsigned cipher_offset,
const unsigned auth_len, const unsigned auth_offset)
const uint8_t *iv, const uint8_t iv_len,
const unsigned cipher_len, const unsigned cipher_offset,
const unsigned auth_len, const unsigned auth_offset)
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- unsigned iv_pad_len = 0;
unsigned aad_buffer_len;
/* Generate Crypto op data structure */
unsigned aad_buffer_len;
/* Generate Crypto op data structure */
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
/* iv */
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
/* iv */
- if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
- else
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
-
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
- sym_op->cipher.iv.length = iv_pad_len;
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
+ sym_op->cipher.iv.length = iv_len;
+
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
sym_op->cipher.data.offset = cipher_offset + auth_offset;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
sym_op->cipher.data.length = cipher_len;
sym_op->cipher.data.offset = cipher_offset + auth_offset;
unsigned data_pad_len,
const unsigned cipher_len, const unsigned cipher_offset,
const unsigned auth_len, const unsigned auth_offset,
unsigned data_pad_len,
const unsigned cipher_len, const unsigned cipher_offset,
const unsigned auth_len, const unsigned auth_offset,
- enum rte_crypto_auth_algorithm auth_algo,
- enum rte_crypto_cipher_algorithm cipher_algo)
+ enum rte_crypto_auth_algorithm auth_algo)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- unsigned iv_pad_len = 0;
unsigned aad_buffer_len = 0;
/* Generate Crypto op data structure */
unsigned aad_buffer_len = 0;
/* Generate Crypto op data structure */
sym_op->auth.aad.data, aad_len);
/* iv */
sym_op->auth.aad.data, aad_len);
/* iv */
- if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
- else
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
- sym_op->cipher.iv.length = iv_pad_len;
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
+ sym_op->cipher.iv.length = iv_len;
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
/* Create KASUMI operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
/* Create KASUMI operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
plaintext_len, buffer);
else
plaintext_len, buffer);
else
- ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
plaintext_len, buffer);
/* Validate obuf */
plaintext_len, buffer);
/* Validate obuf */
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
plaintext_pad_len, buffer);
else
plaintext_pad_len, buffer);
else
- ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
plaintext_pad_len, buffer);
/* Validate obuf */
plaintext_pad_len, buffer);
/* Validate obuf */
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
plaintext = ciphertext;
else
plaintext = ciphertext;
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
plaintext = ciphertext;
else
plaintext = ciphertext;
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
plaintext_len, buffer);
else
plaintext_len, buffer);
else
- ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+ ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
plaintext_len, buffer);
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
plaintext_len, buffer);
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3) +
- extra_offset,
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
plaintext = ciphertext;
else
plaintext = ciphertext;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
plaintext = ciphertext;
else
plaintext = ciphertext;
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len + tdata->aad.len;
else
ciphertext = plaintext;
else
ciphertext = plaintext;
"ZUC Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
"ZUC Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+ + plaintext_pad_len + tdata->aad.len;
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
tdata->aad.len, /*tdata->plaintext.len,*/
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->aad.len, /*tdata->plaintext.len,*/
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3)
);
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3)
);
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len + tdata->aad.len;
else
ciphertext = plaintext;
else
ciphertext = plaintext;
"SNOW 3G Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
"SNOW 3G Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+ + plaintext_pad_len + tdata->aad.len;
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3),
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3),
- RTE_CRYPTO_AUTH_SNOW3G_UIA2,
- RTE_CRYPTO_CIPHER_SNOW3G_UEA2
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->aad.len + tdata->iv.len;
else
ciphertext = plaintext;
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
else
ciphertext = plaintext;
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+ + plaintext_pad_len + tdata->aad.len;
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
/* Validate obuf */
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
/* Validate obuf */
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3),
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3),
- RTE_CRYPTO_AUTH_KASUMI_F9,
- RTE_CRYPTO_CIPHER_KASUMI_F8
+ RTE_CRYPTO_AUTH_KASUMI_F9
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len + tdata->aad.len;
else
ciphertext = plaintext;
else
ciphertext = plaintext;
tdata->validCipherLenInBits.len,
"KASUMI Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
tdata->validCipherLenInBits.len,
"KASUMI Ciphertext data not as expected");
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+ + plaintext_pad_len + tdata->aad.len;
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
tdata->aad.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->aad.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_KASUMI_F9,
- RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3)
);
tdata->validAuthLenInBits.len,
(tdata->aad.len << 3)
);
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
ut_params->obuf = ut_params->op->sym->m_src;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->aad.len + tdata->iv.len;
else
ciphertext = plaintext;
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
else
ciphertext = plaintext;
ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+ + plaintext_pad_len + tdata->aad.len;
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
/* Validate obuf */
TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
- ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
- + tdata->iv.len;
+ ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
else
ciphertext = plaintext;
else
ciphertext = plaintext;
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len, tdata->plaintext.len,
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len, tdata->plaintext.len,
- (tdata->iv.len << 3),
- RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
if (retval < 0)
return retval;
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_read(ut_params->obuf,
ut_params->obuf = ut_params->op->sym->m_dst;
if (ut_params->obuf)
ciphertext = rte_pktmbuf_read(ut_params->obuf,
- tdata->iv.len, plaintext_len, ciphertext_buffer);
+ 0, plaintext_len, ciphertext_buffer);
else
ciphertext = rte_pktmbuf_read(ut_params->ibuf,
else
ciphertext = rte_pktmbuf_read(ut_params->ibuf,
- tdata->iv.len, plaintext_len, ciphertext_buffer);
+ 0, plaintext_len, ciphertext_buffer);
/* Validate obuf */
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
/* Validate obuf */
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
struct crypto_unittest_params *ut_params = &unittest_params;
uint8_t *plaintext, *ciphertext;
struct crypto_unittest_params *ut_params = &unittest_params;
uint8_t *plaintext, *ciphertext;
- unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len;
+ unsigned int aad_pad_len, plaintext_pad_len;
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
sym_op->auth.aad.length);
TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
sym_op->auth.aad.length);
- /* Prepend iv */
- iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ /* Append IV at the end of the crypto operation*/
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = tdata->iv.len;
rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
sym_op->cipher.iv.length = tdata->iv.len;
rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
if (ut_params->obuf) {
ciphertext = (uint8_t *)rte_pktmbuf_append(
ut_params->obuf,
if (ut_params->obuf) {
ciphertext = (uint8_t *)rte_pktmbuf_append(
ut_params->obuf,
- plaintext_pad_len + aad_pad_len +
- iv_pad_len);
+ plaintext_pad_len + aad_pad_len);
TEST_ASSERT_NOT_NULL(ciphertext,
"no room to append ciphertext");
TEST_ASSERT_NOT_NULL(ciphertext,
"no room to append ciphertext");
- memset(ciphertext + aad_pad_len + iv_pad_len, 0,
+ memset(ciphertext + aad_pad_len, 0,
tdata->ciphertext.len);
}
} else {
tdata->ciphertext.len);
}
} else {
if (ut_params->obuf) {
plaintext = (uint8_t *)rte_pktmbuf_append(
ut_params->obuf,
if (ut_params->obuf) {
plaintext = (uint8_t *)rte_pktmbuf_append(
ut_params->obuf,
- plaintext_pad_len + aad_pad_len +
- iv_pad_len);
+ plaintext_pad_len + aad_pad_len);
TEST_ASSERT_NOT_NULL(plaintext,
"no room to append plaintext");
TEST_ASSERT_NOT_NULL(plaintext,
"no room to append plaintext");
- memset(plaintext + aad_pad_len + iv_pad_len, 0,
+ memset(plaintext + aad_pad_len, 0,
tdata->plaintext.len);
}
}
tdata->plaintext.len);
}
}
ut_params->obuf ? ut_params->obuf :
ut_params->ibuf,
plaintext_pad_len +
ut_params->obuf ? ut_params->obuf :
ut_params->ibuf,
plaintext_pad_len +
- aad_pad_len + iv_pad_len);
sym_op->auth.digest.length = tdata->auth_tag.len;
} else {
sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
sym_op->auth.digest.length = tdata->auth_tag.len;
} else {
sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
"no room to append digest");
sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
ut_params->ibuf,
"no room to append digest");
sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
ut_params->ibuf,
- plaintext_pad_len + aad_pad_len + iv_pad_len);
+ plaintext_pad_len + aad_pad_len);
sym_op->auth.digest.length = tdata->auth_tag.len;
rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
sym_op->auth.digest.length = tdata->auth_tag.len;
rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
}
sym_op->cipher.data.length = tdata->plaintext.len;
}
sym_op->cipher.data.length = tdata->plaintext.len;
- sym_op->cipher.data.offset = aad_pad_len + iv_pad_len;
+ sym_op->cipher.data.offset = aad_pad_len;
sym_op->auth.data.length = tdata->plaintext.len;
sym_op->auth.data.length = tdata->plaintext.len;
- sym_op->auth.data.offset = aad_pad_len + iv_pad_len;
+ sym_op->auth.data.offset = aad_pad_len;
struct crypto_unittest_params *ut_params = &unittest_params;
struct rte_crypto_sym_op *sym_op;
struct crypto_unittest_params *ut_params = &unittest_params;
struct rte_crypto_sym_op *sym_op;
- iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
/*
aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
/*
sym_op->auth.digest.length);
}
sym_op->auth.digest.length);
}
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = tdata->iv.len;
rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
sym_op->cipher.iv.length = tdata->iv.len;
rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
- TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
+ TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, tdata->iv.len);
sym_op->cipher.data.length = 0;
sym_op->cipher.data.offset = 0;
sym_op->cipher.data.length = 0;
sym_op->cipher.data.offset = 0;
sym_op->auth.digest.data,
sym_op->auth.digest.length);
sym_op->auth.digest.data,
sym_op->auth.digest.length);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, reference->iv.len);
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = reference->iv.len;
sym_op->cipher.iv.length = reference->iv.len;
- memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
+ rte_memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
sym_op->cipher.data.length = 0;
sym_op->cipher.data.offset = 0;
sym_op->cipher.data.length = 0;
sym_op->cipher.data.offset = 0;
sym_op->auth.digest.data,
sym_op->auth.digest.length);
sym_op->auth.digest.data,
sym_op->auth.digest.length);
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, reference->iv.len);
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = reference->iv.len;
sym_op->cipher.iv.length = reference->iv.len;
- memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
+ rte_memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
sym_op->cipher.data.length = reference->ciphertext.len;
sym_op->cipher.data.length = reference->ciphertext.len;
- sym_op->cipher.data.offset = reference->iv.len;
+ sym_op->cipher.data.offset = 0;
sym_op->auth.data.length = reference->ciphertext.len;
sym_op->auth.data.length = reference->ciphertext.len;
- sym_op->auth.data.offset = reference->iv.len;
+ sym_op->auth.data.offset = 0;
const unsigned int iv_len = tdata->iv.len;
const unsigned int aad_len = tdata->aad.len;
const unsigned int iv_len = tdata->iv.len;
const unsigned int aad_len = tdata->aad.len;
- unsigned int iv_pad_len = 0;
-
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
RTE_CRYPTO_OP_TYPE_SYMMETRIC);
/* Generate Crypto op data structure */
ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
RTE_CRYPTO_OP_TYPE_SYMMETRIC);
sym_op->auth.digest.length);
}
sym_op->auth.digest.length);
}
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
- sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, iv_pad_len);
-
- TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
- "no room to prepend iv");
-
- memset(sym_op->cipher.iv.data, 0, iv_pad_len);
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op,
+ IV_OFFSET);
sym_op->cipher.iv.length = iv_len;
sym_op->cipher.iv.length = iv_len;
- rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len);
+ rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_len);
sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
ut_params->ibuf, aad_len);
sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
ut_params->ibuf, aad_len);
memset(sym_op->auth.aad.data, 0, aad_len);
rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
memset(sym_op->auth.aad.data, 0, aad_len);
rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
- TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
+ TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_len);
TEST_HEXDUMP(stdout, "aad:",
sym_op->auth.aad.data, aad_len);
sym_op->cipher.data.length = tdata->plaintext.len;
TEST_HEXDUMP(stdout, "aad:",
sym_op->auth.aad.data, aad_len);
sym_op->cipher.data.length = tdata->plaintext.len;
- sym_op->cipher.data.offset = aad_len + iv_pad_len;
+ sym_op->cipher.data.offset = aad_len;
- sym_op->auth.data.offset = aad_len + iv_pad_len;
+ sym_op->auth.data.offset = aad_len;
sym_op->auth.data.length = tdata->plaintext.len;
return 0;
sym_op->auth.data.length = tdata->plaintext.len;
return 0;
int ecx = 0;
void *digest_mem = NULL;
int ecx = 0;
void *digest_mem = NULL;
- uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16)
- + tdata->aad.len;
+ uint32_t prepend_len = tdata->aad.len;
if (tdata->plaintext.len % fragsz != 0) {
if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
if (tdata->plaintext.len % fragsz != 0) {
if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
- * Copyright(c) 2015-2016 Intel Corporation. All rights reserved.
+ * Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA384 (24)
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 (32)
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA384 (24)
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 (32)
+#define MAXIMUM_IV_LENGTH (16)
+
+#define IV_OFFSET (sizeof(struct rte_crypto_op) + \
+ sizeof(struct rte_crypto_sym_op) + DEFAULT_NUM_XFORMS * \
+ sizeof(struct rte_crypto_sym_xform))
+
/**
* Write (spread) data from buffer to mbuf data
*
/**
* Write (spread) data from buffer to mbuf data
*
- if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
- buf_len += tdata->iv.len;
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
buf_len += digest_len;
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
buf_len += digest_len;
pktmbuf_write(ibuf, 0, tdata->ciphertext.len,
tdata->ciphertext.data);
pktmbuf_write(ibuf, 0, tdata->ciphertext.len,
tdata->ciphertext.data);
- if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
- rte_memcpy(rte_pktmbuf_prepend(ibuf, tdata->iv.len),
- tdata->iv.data, tdata->iv.len);
- }
buf_p = rte_pktmbuf_append(ibuf, digest_len);
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY)
rte_memcpy(buf_p, tdata->digest.data, digest_len);
buf_p = rte_pktmbuf_append(ibuf, digest_len);
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY)
rte_memcpy(buf_p, tdata->digest.data, digest_len);
cipher_xform->cipher.key.data = cipher_key;
cipher_xform->cipher.key.length = tdata->cipher_key.len;
cipher_xform->cipher.key.data = cipher_key;
cipher_xform->cipher.key.length = tdata->cipher_key.len;
- sym_op->cipher.data.offset = tdata->iv.len;
+ sym_op->cipher.data.offset = 0;
sym_op->cipher.data.length = tdata->ciphertext.len;
sym_op->cipher.data.length = tdata->ciphertext.len;
- sym_op->cipher.iv.data = rte_pktmbuf_mtod(sym_op->m_src,
- uint8_t *);
+ sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+ uint8_t *, IV_OFFSET);
+ sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+ IV_OFFSET);
sym_op->cipher.iv.length = tdata->iv.len;
sym_op->cipher.iv.length = tdata->iv.len;
- sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(
- sym_op->m_src);
+ rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data,
+ tdata->iv.len);
}
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
}
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
- uint32_t auth_data_offset = 0;
uint32_t digest_offset = tdata->ciphertext.len;
uint32_t digest_offset = tdata->ciphertext.len;
- if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
- digest_offset += tdata->iv.len;
- auth_data_offset += tdata->iv.len;
- }
-
auth_xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
auth_xform->auth.algo = tdata->auth_algo;
auth_xform->auth.key.length = tdata->auth_key.len;
auth_xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
auth_xform->auth.algo = tdata->auth_algo;
auth_xform->auth.key.length = tdata->auth_key.len;
- sym_op->auth.data.offset = auth_data_offset;
+ sym_op->auth.data.offset = 0;
sym_op->auth.data.length = tdata->ciphertext.len;
sym_op->auth.digest.length = digest_len;
}
sym_op->auth.data.length = tdata->ciphertext.len;
sym_op->auth.digest.length = digest_len;
}
compare_len = tdata->plaintext.len;
}
compare_len = tdata->plaintext.len;
}
- if (memcmp(rte_pktmbuf_read(iobuf, tdata->iv.len, compare_len,
+ if (memcmp(rte_pktmbuf_read(iobuf, 0, compare_len,
buffer), compare_ref, compare_len)) {
snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
"FAILED: %s", __LINE__,
buffer), compare_ref, compare_len)) {
snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
"FAILED: %s", __LINE__,
}
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) {
}
if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) {
- uint8_t *auth_res;
-
- if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
- auth_res = pktmbuf_mtod_offset(iobuf,
- tdata->iv.len + tdata->ciphertext.len);
- else
- auth_res = pktmbuf_mtod_offset(iobuf,
+ uint8_t *auth_res = pktmbuf_mtod_offset(iobuf,
tdata->ciphertext.len);
if (memcmp(auth_res, tdata->digest.data, digest_len)) {
tdata->ciphertext.len);
if (memcmp(auth_res, tdata->digest.data, digest_len)) {