crypto/dpaa2_sec: support AES-GCM and CTR

[dpdk.git] / test / test / test_cryptodev_blockcipher.c

diff --git a/test/test/test_cryptodev_blockcipher.c b/test/test/test_cryptodev_blockcipher.c
index da87368..fc27dd6 100644 (file)
--- a/test/test/test_cryptodev_blockcipher.c
+++ b/test/test/test_cryptodev_blockcipher.c
@@ -35,6 +35,7 @@
 #include <rte_mbuf.h>
 #include <rte_malloc.h>
 #include <rte_memcpy.h>
+#include <rte_pause.h>
 
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
@@ -100,6 +101,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                        tdata->auth_key.len);
 
        switch (cryptodev_type) {
+       case RTE_CRYPTODEV_DPAA2_SEC_PMD:
        case RTE_CRYPTODEV_QAT_SYM_PMD:
        case RTE_CRYPTODEV_OPENSSL_PMD:
        case RTE_CRYPTODEV_ARMV8_PMD: /* Fall through */
@@ -118,8 +120,6 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
        }
 
        /* preparing 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;
 
@@ -145,10 +145,6 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                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);
@@ -293,25 +289,19 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                                RTE_CRYPTO_CIPHER_OP_DECRYPT;
                cipher_xform->cipher.key.data = cipher_key;
                cipher_xform->cipher.key.length = tdata->cipher_key.len;
+               cipher_xform->cipher.iv.offset = IV_OFFSET;
+               cipher_xform->cipher.iv.length = tdata->iv.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.iv.data = rte_pktmbuf_mtod(sym_op->m_src,
-                       uint8_t *);
-               sym_op->cipher.iv.length = tdata->iv.len;
-               sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(
-                       sym_op->m_src);
+               rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
+                               tdata->iv.data,
+                               tdata->iv.len);
        }
 
        if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
-               uint32_t auth_data_offset = 0;
                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;
@@ -334,9 +324,8 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                                        digest_offset);
                }
 
-               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;
        }
 
        /* create session for sessioned op */
@@ -421,7 +410,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                        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__,
@@ -432,13 +421,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
        }
 
        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)) {
@@ -492,7 +475,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                                                sym_op->auth.data.offset;
                        changed_len = sym_op->auth.data.length;
                        if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN)
-                               changed_len += sym_op->auth.digest.length;
+                               changed_len += digest_len;
                } else {
                        /* cipher-only */
                        head_unchanged_len = rte_pktmbuf_headroom(mbuf) +
@@ -534,7 +517,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                }
 
                if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN)
-                       changed_len += sym_op->auth.digest.length;
+                       changed_len += digest_len;
 
                if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) {
                        /* white-box test: PMDs use some of the
@@ -613,6 +596,11 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
                sizeof(aes_cipheronly_test_cases[0]);
                tcs = aes_cipheronly_test_cases;
                break;
+       case BLKCIPHER_AES_DOCSIS_TYPE:
+               n_test_cases = sizeof(aes_docsis_test_cases) /
+               sizeof(aes_docsis_test_cases[0]);
+               tcs = aes_docsis_test_cases;
+               break;
        case BLKCIPHER_3DES_CHAIN_TYPE:
                n_test_cases = sizeof(triple_des_chain_test_cases) /
                sizeof(triple_des_chain_test_cases[0]);
@@ -628,6 +616,11 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
                sizeof(des_cipheronly_test_cases[0]);
                tcs = des_cipheronly_test_cases;
                break;
+       case BLKCIPHER_DES_DOCSIS_TYPE:
+               n_test_cases = sizeof(des_docsis_test_cases) /
+               sizeof(des_docsis_test_cases[0]);
+               tcs = des_docsis_test_cases;
+               break;
        case BLKCIPHER_AUTHONLY_TYPE:
                n_test_cases = sizeof(hash_test_cases) /
                sizeof(hash_test_cases[0]);
@@ -653,6 +646,9 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
        case RTE_CRYPTODEV_SCHEDULER_PMD:
                target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER;
                break;
+       case RTE_CRYPTODEV_DPAA2_SEC_PMD:
+               target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC;
+               break;
        default:
                TEST_ASSERT(0, "Unrecognized cryptodev type");
                break;