[dpdk-dev] [PATCH v3 11/11] test: refactor snow3g/kasumi tests
Pablo de Lara
pablo.de.lara.guarch at intel.com
Mon Jun 20 11:27:53 CEST 2016
SNOW3G and KASUMI unit tests are very similar and
they were using duplicated code, so this commit
refactor and remove some of the duplicated functions.
Signed-off-by: Pablo de Lara <pablo.de.lara.guarch at intel.com>
Acked-by: Jain, Deepak K <deepak.k.jain at intel.com>
---
app/test/test_cryptodev.c | 440 ++++++++++++++++------------------------------
1 file changed, 150 insertions(+), 290 deletions(-)
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 7a8fda0..1a67ffb 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -1091,10 +1091,11 @@ test_AES_qat_all(void)
/* ***** Snow3G Tests ***** */
static int
-create_snow3g_hash_session(uint8_t dev_id,
+create_snow3g_kasumi_hash_session(uint8_t dev_id,
const uint8_t *key, const uint8_t key_len,
const uint8_t aad_len, const uint8_t auth_len,
- enum rte_crypto_auth_operation op)
+ enum rte_crypto_auth_operation op,
+ enum rte_crypto_auth_algorithm algo)
{
uint8_t hash_key[key_len];
@@ -1109,7 +1110,7 @@ create_snow3g_hash_session(uint8_t dev_id,
ut_params->auth_xform.next = NULL;
ut_params->auth_xform.auth.op = op;
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+ ut_params->auth_xform.auth.algo = algo;
ut_params->auth_xform.auth.key.length = key_len;
ut_params->auth_xform.auth.key.data = hash_key;
ut_params->auth_xform.auth.digest_length = auth_len;
@@ -1121,36 +1122,9 @@ create_snow3g_hash_session(uint8_t dev_id,
}
static int
-create_kasumi_hash_session(uint8_t dev_id,
- const uint8_t *key, const uint8_t key_len,
- const uint8_t aad_len, const uint8_t auth_len,
- enum rte_crypto_auth_operation op)
-{
- uint8_t hash_key[key_len];
-
- struct crypto_unittest_params *ut_params = &unittest_params;
-
- memcpy(hash_key, key, key_len);
- TEST_HEXDUMP(stdout, "key:", key, key_len);
- /* Setup Authentication Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
-
- ut_params->auth_xform.auth.op = op;
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_KASUMI_F9;
- ut_params->auth_xform.auth.key.length = key_len;
- ut_params->auth_xform.auth.key.data = hash_key;
- ut_params->auth_xform.auth.digest_length = auth_len;
- ut_params->auth_xform.auth.add_auth_data_length = aad_len;
- ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
- &ut_params->auth_xform);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
- return 0;
-}
-
-static int
-create_kasumi_cipher_session(uint8_t dev_id,
+create_snow3g_kasumi_cipher_session(uint8_t dev_id,
enum rte_crypto_cipher_operation op,
+ enum rte_crypto_cipher_algorithm algo,
const uint8_t *key, const uint8_t key_len)
{
uint8_t cipher_key[key_len];
@@ -1163,7 +1137,7 @@ create_kasumi_cipher_session(uint8_t dev_id,
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
ut_params->cipher_xform.next = NULL;
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_KASUMI_F8;
+ ut_params->cipher_xform.cipher.algo = algo;
ut_params->cipher_xform.cipher.op = op;
ut_params->cipher_xform.cipher.key.data = cipher_key;
ut_params->cipher_xform.cipher.key.length = key_len;
@@ -1179,9 +1153,10 @@ create_kasumi_cipher_session(uint8_t dev_id,
}
static int
-create_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
+create_snow3g_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
const unsigned cipher_len,
- const unsigned cipher_offset)
+ const unsigned cipher_offset,
+ enum rte_crypto_cipher_algorithm algo)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
@@ -1202,7 +1177,11 @@ create_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
sym_op->m_src = ut_params->ibuf;
/* iv */
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
+ 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);
@@ -1219,9 +1198,10 @@ create_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
}
static int
-create_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
+create_snow3g_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
const unsigned cipher_len,
- const unsigned cipher_offset)
+ const unsigned cipher_offset,
+ enum rte_crypto_cipher_algorithm algo)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
@@ -1243,7 +1223,10 @@ create_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
sym_op->m_dst = ut_params->obuf;
/* iv */
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
+ 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);
@@ -1260,122 +1243,14 @@ create_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
}
static int
-create_snow3g_cipher_session(uint8_t dev_id,
- enum rte_crypto_cipher_operation op,
- const uint8_t *key, const uint8_t key_len)
-{
- uint8_t cipher_key[key_len];
-
- struct crypto_unittest_params *ut_params = &unittest_params;
-
- memcpy(cipher_key, key, key_len);
-
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = NULL;
-
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
- ut_params->cipher_xform.cipher.op = op;
- ut_params->cipher_xform.cipher.key.data = cipher_key;
- ut_params->cipher_xform.cipher.key.length = key_len;
-
- TEST_HEXDUMP(stdout, "key:", key, key_len);
-
- /* Create Crypto session */
- ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
- &ut_params->
- cipher_xform);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
- return 0;
-}
-
-static int
-create_snow3g_cipher_operation(const uint8_t *iv, const unsigned iv_len,
- const unsigned cipher_len,
- const unsigned cipher_offset)
-{
- 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,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
-
- /* iv */
- 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;
-
- rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
- sym_op->cipher.data.length = cipher_len;
- sym_op->cipher.data.offset = cipher_offset;
- return 0;
-}
-
-static int
-create_snow3g_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
- const unsigned cipher_len,
- const unsigned cipher_offset)
-{
- 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,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
- sym_op->m_dst = ut_params->obuf;
-
- /* iv */
- 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;
-
- rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
- sym_op->cipher.data.length = cipher_len;
- sym_op->cipher.data.offset = cipher_offset;
- return 0;
-}
-
-static int
-create_snow3g_cipher_auth_session(uint8_t dev_id,
+create_snow3g_kasumi_cipher_auth_session(uint8_t dev_id,
enum rte_crypto_cipher_operation cipher_op,
enum rte_crypto_auth_operation auth_op,
+ enum rte_crypto_auth_algorithm auth_algo,
+ enum rte_crypto_cipher_algorithm cipher_algo,
const uint8_t *key, const uint8_t key_len,
const uint8_t aad_len, const uint8_t auth_len)
+
{
uint8_t cipher_auth_key[key_len];
@@ -1388,7 +1263,7 @@ create_snow3g_cipher_auth_session(uint8_t dev_id,
ut_params->auth_xform.next = NULL;
ut_params->auth_xform.auth.op = auth_op;
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+ ut_params->auth_xform.auth.algo = auth_algo;
ut_params->auth_xform.auth.key.length = key_len;
/* Hash key = cipher key */
ut_params->auth_xform.auth.key.data = cipher_auth_key;
@@ -1399,7 +1274,7 @@ create_snow3g_cipher_auth_session(uint8_t dev_id,
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
ut_params->cipher_xform.next = &ut_params->auth_xform;
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+ ut_params->cipher_xform.cipher.algo = cipher_algo;
ut_params->cipher_xform.cipher.op = cipher_op;
ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
ut_params->cipher_xform.cipher.key.length = key_len;
@@ -1415,12 +1290,14 @@ create_snow3g_cipher_auth_session(uint8_t dev_id,
}
static int
-create_snow3g_auth_cipher_session(uint8_t dev_id,
+create_snow3g_kasumi_auth_cipher_session(uint8_t dev_id,
enum rte_crypto_cipher_operation cipher_op,
enum rte_crypto_auth_operation auth_op,
+ enum rte_crypto_auth_algorithm auth_algo,
+ enum rte_crypto_cipher_algorithm cipher_algo,
const uint8_t *key, const uint8_t key_len,
const uint8_t aad_len, const uint8_t auth_len)
- {
+{
uint8_t auth_cipher_key[key_len];
struct crypto_unittest_params *ut_params = &unittest_params;
@@ -1431,7 +1308,7 @@ create_snow3g_auth_cipher_session(uint8_t dev_id,
ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
ut_params->auth_xform.auth.op = auth_op;
ut_params->auth_xform.next = &ut_params->cipher_xform;
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+ ut_params->auth_xform.auth.algo = auth_algo;
ut_params->auth_xform.auth.key.length = key_len;
ut_params->auth_xform.auth.key.data = auth_cipher_key;
ut_params->auth_xform.auth.digest_length = auth_len;
@@ -1440,7 +1317,7 @@ create_snow3g_auth_cipher_session(uint8_t dev_id,
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
ut_params->cipher_xform.next = NULL;
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+ ut_params->cipher_xform.cipher.algo = cipher_algo;
ut_params->cipher_xform.cipher.op = cipher_op;
ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
ut_params->cipher_xform.cipher.key.length = key_len;
@@ -1457,11 +1334,12 @@ create_snow3g_auth_cipher_session(uint8_t dev_id,
}
static int
-create_snow3g_hash_operation(const uint8_t *auth_tag,
+create_snow3g_kasumi_hash_operation(const uint8_t *auth_tag,
const unsigned auth_tag_len,
const uint8_t *aad, const unsigned aad_len,
unsigned data_pad_len,
enum rte_crypto_auth_operation op,
+ enum rte_crypto_auth_algorithm algo,
const unsigned auth_len, const unsigned auth_offset)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -1490,85 +1368,12 @@ create_snow3g_hash_operation(const uint8_t *auth_tag,
* The cryptodev API calls out -
* - the array must be big enough to hold the AAD, plus any
* space to round this up to the nearest multiple of the
- * block size (16 bytes).
+ * block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
*/
- aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
- sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
- ut_params->ibuf, aad_buffer_len);
- TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
- "no room to prepend aad");
- sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
- ut_params->ibuf);
- sym_op->auth.aad.length = aad_len;
-
- memset(sym_op->auth.aad.data, 0, aad_buffer_len);
- rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
-
- TEST_HEXDUMP(stdout, "aad:",
- sym_op->auth.aad.data, aad_len);
-
- /* digest */
- sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
- ut_params->ibuf, auth_tag_len);
-
- 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_mtophys_offset(
- ut_params->ibuf, data_pad_len + aad_len);
- sym_op->auth.digest.length = auth_tag_len;
- if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
- memset(sym_op->auth.digest.data, 0, auth_tag_len);
+ if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
else
- rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
-
- TEST_HEXDUMP(stdout, "digest:",
- sym_op->auth.digest.data,
- sym_op->auth.digest.length);
-
- sym_op->auth.data.length = auth_len;
- sym_op->auth.data.offset = auth_offset;
-
- return 0;
-}
-
-static int
-create_kasumi_hash_operation(const uint8_t *auth_tag,
- const unsigned auth_tag_len,
- const uint8_t *aad, const unsigned aad_len,
- unsigned data_pad_len,
- enum rte_crypto_auth_operation op,
- const unsigned auth_len, const unsigned auth_offset)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- struct crypto_unittest_params *ut_params = &unittest_params;
-
- unsigned aad_buffer_len;
-
- /* 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(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
-
- /* aad */
- /*
- * Always allocate the aad up to the block size.
- * The cryptodev API calls out -
- * - the array must be big enough to hold the AAD, plus any
- * space to round this up to the nearest multiple of the
- * block size (16 bytes).
- */
- aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
ut_params->ibuf, aad_buffer_len);
TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
@@ -1607,12 +1412,15 @@ create_kasumi_hash_operation(const uint8_t *auth_tag,
return 0;
}
+
static int
-create_snow3g_cipher_hash_operation(const uint8_t *auth_tag,
+create_snow3g_kasumi_cipher_hash_operation(const uint8_t *auth_tag,
const unsigned auth_tag_len,
const uint8_t *aad, const uint8_t aad_len,
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)
@@ -1638,7 +1446,10 @@ create_snow3g_cipher_hash_operation(const uint8_t *auth_tag,
/* iv */
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
+ 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);
@@ -1659,9 +1470,12 @@ create_snow3g_cipher_hash_operation(const uint8_t *auth_tag,
* The cryptodev API calls out -
* - the array must be big enough to hold the AAD, plus any
* space to round this up to the nearest multiple of the
- * block size (16 bytes).
+ * block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
*/
- aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
+ if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
+ else
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
sym_op->auth.aad.data =
(uint8_t *)rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
@@ -1703,12 +1517,14 @@ create_snow3g_cipher_hash_operation(const uint8_t *auth_tag,
}
static int
-create_snow3g_auth_cipher_operation(const unsigned auth_tag_len,
+create_snow3g_kasumi_auth_cipher_operation(const unsigned auth_tag_len,
const uint8_t *iv, const uint8_t iv_len,
const uint8_t *aad, const uint8_t aad_len,
unsigned data_pad_len,
const unsigned cipher_len, const unsigned cipher_offset,
- const unsigned auth_len, const unsigned auth_offset)
+ const unsigned auth_len, const unsigned auth_offset,
+ enum rte_crypto_auth_algorithm auth_algo,
+ enum rte_crypto_cipher_algorithm cipher_algo)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
@@ -1748,7 +1564,10 @@ create_snow3g_auth_cipher_operation(const unsigned auth_tag_len,
sym_op->auth.digest.length);
/* iv */
- iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
+ 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);
@@ -1766,9 +1585,12 @@ create_snow3g_auth_cipher_operation(const unsigned auth_tag_len,
* The cryptodev API calls out -
* - the array must be big enough to hold the AAD, plus any
* space to round this up to the nearest multiple of the
- * block size (16 bytes).
+ * block size (8 bytes for KASUMI 16 bytes).
*/
- aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
+ if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
+ else
+ aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
ut_params->ibuf, aad_buffer_len);
@@ -1805,10 +1627,11 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
uint8_t *plaintext;
/* Create SNOW3G session */
- retval = create_snow3g_hash_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len,
- RTE_CRYPTO_AUTH_OP_GENERATE);
+ RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2);
if (retval < 0)
return retval;
@@ -1826,10 +1649,11 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
plaintext_pad_len);
memcpy(plaintext, tdata->plaintext.data, plaintext_len);
- /* Create SNOW3G opertaion */
- retval = create_snow3g_hash_operation(NULL, tdata->digest.len,
+ /* Create SNOW3G operation */
+ retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
tdata->validAuthOffsetLenInBits.len);
if (retval < 0)
@@ -1864,10 +1688,11 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
uint8_t *plaintext;
/* Create SNOW3G session */
- retval = create_snow3g_hash_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len,
- RTE_CRYPTO_AUTH_OP_VERIFY);
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2);
if (retval < 0)
return retval;
/* alloc mbuf and set payload */
@@ -1885,11 +1710,12 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
memcpy(plaintext, tdata->plaintext.data, plaintext_len);
/* Create SNOW3G operation */
- retval = create_snow3g_hash_operation(tdata->digest.data,
+ retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
tdata->digest.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
tdata->validAuthOffsetLenInBits.len);
if (retval < 0)
@@ -1923,10 +1749,11 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
uint8_t *plaintext;
/* Create KASUMI session */
- retval = create_kasumi_hash_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len,
- RTE_CRYPTO_AUTH_OP_GENERATE);
+ RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_KASUMI_F9);
if (retval < 0)
return retval;
@@ -1945,9 +1772,10 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
memcpy(plaintext, tdata->plaintext.data, plaintext_len);
/* Create KASUMI operation */
- retval = create_kasumi_hash_operation(NULL, tdata->digest.len,
+ retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
tdata->validAuthOffsetLenInBits.len);
if (retval < 0)
@@ -1982,10 +1810,11 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
uint8_t *plaintext;
/* Create KASUMI session */
- retval = create_kasumi_hash_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len,
- RTE_CRYPTO_AUTH_OP_VERIFY);
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_AUTH_KASUMI_F9);
if (retval < 0)
return retval;
/* alloc mbuf and set payload */
@@ -2003,11 +1832,12 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
memcpy(plaintext, tdata->plaintext.data, plaintext_len);
/* Create KASUMI operation */
- retval = create_kasumi_hash_operation(tdata->digest.data,
+ retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
tdata->digest.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
tdata->validAuthOffsetLenInBits.len);
if (retval < 0)
@@ -2174,8 +2004,9 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
unsigned plaintext_len;
/* Create KASUMI session */
- retval = create_kasumi_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2197,9 +2028,10 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
/* Create KASUMI operation */
- retval = create_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
@@ -2237,8 +2069,9 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
unsigned plaintext_len;
/* Create KASUMI session */
- retval = create_kasumi_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2262,9 +2095,11 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
/* Create KASUMI operation */
- retval = create_kasumi_cipher_operation_oop(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
+ tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
@@ -2302,8 +2137,9 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
unsigned ciphertext_len;
/* Create KASUMI session */
- retval = create_kasumi_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2327,9 +2163,11 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
/* Create KASUMI operation */
- retval = create_kasumi_cipher_operation_oop(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
+ tdata->iv.len,
tdata->ciphertext.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
@@ -2367,8 +2205,9 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
unsigned ciphertext_len;
/* Create KASUMI session */
- retval = create_kasumi_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2390,9 +2229,11 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
/* Create KASUMI operation */
- retval = create_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data,
+ tdata->iv.len,
tdata->ciphertext.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
@@ -2430,8 +2271,9 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
unsigned plaintext_len;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2453,9 +2295,10 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
@@ -2494,8 +2337,9 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
unsigned plaintext_len;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2524,10 +2368,11 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_operation_oop(tdata->iv.data,
+ retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
@@ -2586,8 +2431,9 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
uint8_t *expected_ciphertext_shifted;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2623,11 +2469,12 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
#endif
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_operation_oop(tdata->iv.data,
+ retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
tdata->validCipherOffsetLenInBits.len +
- extra_offset);
+ extra_offset,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
@@ -2678,8 +2525,9 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
unsigned ciphertext_len;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2701,9 +2549,10 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len,
+ retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
@@ -2739,8 +2588,9 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
unsigned ciphertext_len;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len);
if (retval < 0)
return retval;
@@ -2772,10 +2622,11 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_operation_oop(tdata->iv.data,
+ retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len);
+ tdata->validCipherOffsetLenInBits.len,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
@@ -2812,9 +2663,11 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata)
unsigned plaintext_len;
/* Create SNOW3G session */
- retval = create_snow3g_cipher_auth_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_cipher_auth_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len);
if (retval < 0)
@@ -2836,15 +2689,18 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_cipher_hash_operation(tdata->digest.data,
+ retval = create_snow3g_kasumi_cipher_hash_operation(tdata->digest.data,
tdata->digest.len, tdata->aad.data,
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->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ tdata->validAuthOffsetLenInBits.len
+ );
if (retval < 0)
return retval;
@@ -2891,9 +2747,11 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata)
unsigned plaintext_len;
/* Create SNOW3G session */
- retval = create_snow3g_auth_cipher_session(ts_params->valid_devs[0],
+ retval = create_snow3g_kasumi_auth_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
RTE_CRYPTO_AUTH_OP_GENERATE,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->key.data, tdata->key.len,
tdata->aad.len, tdata->digest.len);
if (retval < 0)
@@ -2916,7 +2774,7 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata)
TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
/* Create SNOW3G operation */
- retval = create_snow3g_auth_cipher_operation(
+ retval = create_snow3g_kasumi_auth_cipher_operation(
tdata->digest.len,
tdata->iv.data, tdata->iv.len,
tdata->aad.data, tdata->aad.len,
@@ -2924,7 +2782,9 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata)
tdata->validCipherLenInBits.len,
tdata->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len
+ tdata->validAuthOffsetLenInBits.len,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2
);
if (retval < 0)
--
2.5.0
More information about the dev
mailing list