app/test: refactor SNOW 3G and KASUMI tests
authorPablo de Lara <pablo.de.lara.guarch@intel.com>
Mon, 20 Jun 2016 14:45:02 +0000 (15:45 +0100)
committerThomas Monjalon <thomas.monjalon@6wind.com>
Mon, 20 Jun 2016 20:38:58 +0000 (22:38 +0200)
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@intel.com>
Acked-by: Deepak Kumar Jain <deepak.k.jain@intel.com>
app/test/test_cryptodev.c

index 7a8fda0..1a67ffb 100644 (file)
@@ -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)