From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9AB49A04B6; Mon, 12 Oct 2020 13:20:06 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 7A0AA1D6CB; Mon, 12 Oct 2020 13:20:05 +0200 (CEST) Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id 78FA31D6C5 for ; Mon, 12 Oct 2020 13:20:04 +0200 (CEST) IronPort-SDR: lDNw4EGz5AdFVD5/mk0M2nm3YDjW33LIDrRdFp2IWkREYyAFEskZzURvR34N57FfJc78O8rMAH y6jHecNfub1w== X-IronPort-AV: E=McAfee;i="6000,8403,9771"; a="165780933" X-IronPort-AV: E=Sophos;i="5.77,366,1596524400"; d="scan'208";a="165780933" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by orsmga103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Oct 2020 04:19:58 -0700 IronPort-SDR: 40A1k5aWKPopD5ixx9xXLqS1PvdP7kh81Hc3TbXKJlm8pb/w43jVUxGngjOTD85ZFPCNb8eMe7 MsmoKth3LcZQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.77,366,1596524400"; d="scan'208";a="520661604" Received: from silpixa00399593.ir.intel.com (HELO silpixa00399593.ger.corp.intel.com) ([10.237.223.27]) by fmsmga005.fm.intel.com with ESMTP; 12 Oct 2020 04:19:56 -0700 From: Pablo de Lara To: declan.doherty@intel.com Cc: dev@dpdk.org, Pablo de Lara Date: Mon, 12 Oct 2020 11:19:13 +0000 Message-Id: <20201012111913.705225-2-pablo.de.lara.guarch@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201012111913.705225-1-pablo.de.lara.guarch@intel.com> References: <20201009114029.190540-1-pablo.de.lara.guarch@intel.com> <20201012111913.705225-1-pablo.de.lara.guarch@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [PATCH v5 2/2] test/crypto: add GMAC SGL tests X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add Scatter-Gather List tests for AES-GMAC. Signed-off-by: Pablo de Lara --- Changes: - v5: Modified GMAC test cases, so mbuf size remains the same size (2KB), reducing the vector length to make it compatible with QAT PMD. - v4: Rebased on top of crypto subtree - v3: Fixed checkpatch issues - v2: Modified segment size to make reduce maximum number of segments needed --- app/test/test_cryptodev.c | 216 ++++++++++++++++++++ app/test/test_cryptodev_aead_test_vectors.h | 30 +++ 2 files changed, 246 insertions(+) diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index ac2a36bc2..6da199dfb 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -9993,6 +9993,53 @@ create_gmac_operation(enum rte_crypto_auth_operation op, return 0; } +static int +create_gmac_operation_sgl(enum rte_crypto_auth_operation op, + const struct gmac_test_data *tdata, + void *digest_mem, uint64_t digest_phys) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_crypto_sym_op *sym_op; + + /* 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 symmetric crypto operation struct"); + + sym_op = ut_params->op->sym; + + sym_op->auth.digest.data = digest_mem; + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + + sym_op->auth.digest.phys_addr = digest_phys; + + if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, + tdata->gmac_tag.len); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + tdata->gmac_tag.len); + } + + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + + debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = tdata->plaintext.len; + + return 0; +} + static int create_gmac_session(uint8_t dev_id, const struct gmac_test_data *tdata, enum rte_crypto_auth_operation auth_op) @@ -10249,6 +10296,166 @@ test_AES_GMAC_authentication_verify_test_case_4(void) return test_AES_GMAC_authentication_verify(&gmac_test_case_4); } +static int +test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata, + uint32_t fragsz) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + uint64_t feature_flags; + unsigned int trn_data = 0; + void *digest_mem = NULL; + uint32_t segs = 1; + unsigned int to_trn = 0; + struct rte_mbuf *buf = NULL; + uint8_t *auth_tag, *plaintext; + int retval; + + TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, + "No GMAC length in the source data"); + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Check for any input SGL support */ + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + feature_flags = dev_info.feature_flags; + + if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) && + (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) && + (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))) + return -ENOTSUP; + + if (fragsz > tdata->plaintext.len) + fragsz = tdata->plaintext.len; + + uint16_t plaintext_len = fragsz; + + retval = create_gmac_session(ts_params->valid_devs[0], + tdata, RTE_CRYPTO_AUTH_OP_GENERATE); + + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + + memcpy(plaintext, tdata->plaintext.data, plaintext_len); + + trn_data += plaintext_len; + + buf = ut_params->ibuf; + + /* + * Loop until no more fragments + */ + + while (trn_data < tdata->plaintext.len) { + ++segs; + to_trn = (tdata->plaintext.len - trn_data < fragsz) ? + (tdata->plaintext.len - trn_data) : fragsz; + + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; + + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(buf, + to_trn); + + memcpy(plaintext, tdata->plaintext.data + trn_data, + to_trn); + trn_data += to_trn; + if (trn_data == tdata->plaintext.len) + digest_mem = (uint8_t *)rte_pktmbuf_append(buf, + tdata->gmac_tag.len); + } + ut_params->ibuf->nb_segs = segs; + + /* + * Place digest at the end of the last buffer + */ + uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn; + + if (!digest_mem) { + digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + + tdata->gmac_tag.len); + digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, + tdata->plaintext.len); + } + + retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE, + tdata, digest_mem, digest_phys); + + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; + + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + auth_tag = digest_mem; + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->gmac_tag.data, + tdata->gmac_tag.len, + "GMAC Generated auth tag not as expected"); + + return 0; +} + +/* Segment size not multiple of block size (16B) */ +static int +test_AES_GMAC_authentication_SGL_40B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40); +} + +static int +test_AES_GMAC_authentication_SGL_80B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80); +} + +static int +test_AES_GMAC_authentication_SGL_2048B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048); +} + +/* Segment size not multiple of block size (16B) */ +static int +test_AES_GMAC_authentication_SGL_2047B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047); +} + struct test_crypto_vector { enum rte_crypto_cipher_algorithm crypto_algo; unsigned int cipher_offset; @@ -12162,6 +12369,15 @@ static struct unit_test_suite cryptodev_testsuite = { test_AES_GMAC_authentication_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_40B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_80B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_2048B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_2047B), + /** Chacha20-Poly1305 */ TEST_CASE_ST(ut_setup, ut_teardown, test_chacha20_poly1305_encrypt_test_case_rfc8439), diff --git a/app/test/test_cryptodev_aead_test_vectors.h b/app/test/test_cryptodev_aead_test_vectors.h index 140f25362..736c44358 100644 --- a/app/test/test_cryptodev_aead_test_vectors.h +++ b/app/test/test_cryptodev_aead_test_vectors.h @@ -2613,6 +2613,36 @@ static const struct gmac_test_data gmac_test_case_4 = { } }; +/* Test vector used to test GMAC SGL with 16 segments + plaintext length = ~32KB / segment size = ~2 KB */ +static const struct gmac_test_data gmac_test_case_5 = { + .key = { + .data = { + 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, + 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08 + }, + .len = 16 + }, + .iv = { + .data = { + 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, + 0xde, 0xca, 0xf8, 0x88 + }, + .len = 12 + }, + .plaintext = { + .data = gmac_plaintext, + .len = GMAC_LARGE_PLAINTEXT_LENGTH/2 + }, + .gmac_tag = { + .data = { + 0xb1, 0xba, 0xe7, 0x28, 0xd3, 0x95, 0x80, 0xd7, + 0x2e, 0xf5, 0xd0, 0x20, 0x80, 0x95, 0x16, 0x97 + }, + .len = 16 + } +}; + static const struct aead_test_data gcm_test_case_SGL_1 = { .algo = RTE_CRYPTO_AEAD_AES_GCM, .key = { -- 2.25.1