From patchwork Wed Mar 27 11:17:20 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arkadiusz Kusztal X-Patchwork-Id: 51786 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 58B921B13F; Wed, 27 Mar 2019 12:21:19 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 993111B119 for ; Wed, 27 Mar 2019 12:21:10 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by orsmga101.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 27 Mar 2019 04:21:10 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,276,1549958400"; d="scan'208";a="155639851" Received: from akusztax-mobl.ger.corp.intel.com ([10.104.116.172]) by fmsmga002.fm.intel.com with ESMTP; 27 Mar 2019 04:21:08 -0700 From: Arek Kusztal To: dev@dpdk.org Cc: akhil.goyal@nxp.com, fiona.trahe@intel.com, Arek Kusztal Date: Wed, 27 Mar 2019 12:17:20 +0100 Message-Id: <20190327111720.13732-5-arkadiuszx.kusztal@intel.com> X-Mailer: git-send-email 2.19.1.windows.1 In-Reply-To: <20190327111720.13732-1-arkadiuszx.kusztal@intel.com> References: <20190327111720.13732-1-arkadiuszx.kusztal@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v4 4/4] crypto/qat: add modular inverse to qat asym pmd 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" This commit adds modular multiplicative inverse to Intel QuickAssist Technology driver. For capabilities or limitations please refer to qat.rst or qat_asym_capabilities.h. Signed-off-by: Arek Kusztal --- doc/guides/cryptodevs/qat.rst | 1 + .../qat/qat_adf/qat_pke_functionality_arrays.h | 4 +- drivers/crypto/qat/qat_asym.c | 85 +++++++++++++++++++++- drivers/crypto/qat/qat_asym.h | 3 + drivers/crypto/qat/qat_asym_capabilities.h | 16 ++++ 5 files changed, 106 insertions(+), 3 deletions(-) diff --git a/doc/guides/cryptodevs/qat.rst b/doc/guides/cryptodevs/qat.rst index e09ae8b..3c2467d 100644 --- a/doc/guides/cryptodevs/qat.rst +++ b/doc/guides/cryptodevs/qat.rst @@ -107,6 +107,7 @@ Asymmetric Crypto Service on QAT The QAT Asym PMD has support for: * ``Modular exponentiation`` +* ``Modular multiplicative inverse`` Limitations ~~~~~~~~~~~ diff --git a/drivers/common/qat/qat_adf/qat_pke_functionality_arrays.h b/drivers/common/qat/qat_adf/qat_pke_functionality_arrays.h index ffea27e..8adf209 100644 --- a/drivers/common/qat/qat_adf/qat_pke_functionality_arrays.h +++ b/drivers/common/qat/qat_adf/qat_pke_functionality_arrays.h @@ -21,7 +21,7 @@ static const uint32_t MOD_EXP_SIZE[][2] = { { 4096, MATHS_MODEXP_L4096 } }; -static const uint32_t __rte_unused MOD_INV_IDS_ODD[][2] = { +static const uint32_t MOD_INV_IDS_ODD[][2] = { { 128, MATHS_MODINV_ODD_L128 }, { 192, MATHS_MODINV_ODD_L192 }, { 256, MATHS_MODINV_ODD_L256 }, @@ -35,7 +35,7 @@ static const uint32_t __rte_unused MOD_INV_IDS_ODD[][2] = { { 4096, MATHS_MODINV_ODD_L4096 }, }; -static const uint32_t __rte_unused MOD_INV_IDS_EVEN[][2] = { +static const uint32_t MOD_INV_IDS_EVEN[][2] = { { 128, MATHS_MODINV_EVEN_L128 }, { 192, MATHS_MODINV_EVEN_L192 }, { 256, MATHS_MODINV_EVEN_L256 }, diff --git a/drivers/crypto/qat/qat_asym.c b/drivers/crypto/qat/qat_asym.c index 733aab4..dc4c959 100644 --- a/drivers/crypto/qat/qat_asym.c +++ b/drivers/crypto/qat/qat_asym.c @@ -54,6 +54,9 @@ static void qat_asym_build_req_tmpl(void *sess_private_data, if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) { qat_req->output_param_count = 1; qat_req->input_param_count = 3; + } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) { + qat_req->output_param_count = 1; + qat_req->input_param_count = 2; } } @@ -147,7 +150,8 @@ qat_asym_build_request(void *in_op, if (ctx->alg == QAT_PKE_MODEXP) { err = qat_asym_check_nonzero(ctx->sess_alg_params.mod_exp.n); if (err) { - QAT_LOG(ERR, "Empty modulus, aborting this operation"); + QAT_LOG(ERR, "Empty modulus in modular exponentiation," + " aborting this operation"); goto error; } @@ -189,6 +193,56 @@ qat_asym_build_request(void *in_op, cookie->input_array[2], alg_size_in_bytes); #endif + } else if (ctx->alg == QAT_PKE_MODINV) { + err = qat_asym_check_nonzero(ctx->sess_alg_params.mod_inv.n); + if (err) { + QAT_LOG(ERR, "Empty modulus in modular multiplicative" + " inverse, aborting this operation"); + goto error; + } + + alg_size_in_bytes = max_of(2, asym_op->modinv.base.length, + ctx->sess_alg_params.mod_inv.n.length); + alg_size = alg_size_in_bytes << 3; + + if (ctx->sess_alg_params.mod_inv.n.data[ + ctx->sess_alg_params.mod_inv.n.length - 1] & 0x01) { + if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_ODD, + sizeof(MOD_INV_IDS_ODD)/ + sizeof(*MOD_INV_IDS_ODD), + &alg_size, &func_id)) { + err = QAT_ASYM_ERROR_INVALID_PARAM; + goto error; + } + } else { + if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_EVEN, + sizeof(MOD_INV_IDS_EVEN)/ + sizeof(*MOD_INV_IDS_EVEN), + &alg_size, &func_id)) { + err = QAT_ASYM_ERROR_INVALID_PARAM; + goto error; + } + } + + alg_size_in_bytes = alg_size >> 3; + rte_memcpy(cookie->input_array[0] + alg_size_in_bytes - + asym_op->modinv.base.length + , asym_op->modinv.base.data, + asym_op->modinv.base.length); + rte_memcpy(cookie->input_array[1] + alg_size_in_bytes - + ctx->sess_alg_params.mod_inv.n.length + , ctx->sess_alg_params.mod_inv.n.data, + ctx->sess_alg_params.mod_inv.n.length); + cookie->alg_size = alg_size; + qat_req->pke_hdr.cd_pars.func_id = func_id; +#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG + QAT_DP_HEXDUMP_LOG(DEBUG, "base", + cookie->input_array[0], + alg_size_in_bytes); + QAT_DP_HEXDUMP_LOG(DEBUG, "modulus", + cookie->input_array[1], + alg_size_in_bytes); +#endif } #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG @@ -261,6 +315,26 @@ qat_asym_process_response(void **op, uint8_t *resp, } qat_clear_arrays(cookie, 3, 1, alg_size_in_bytes, alg_size_in_bytes); + } else if (ctx->alg == QAT_PKE_MODINV) { + alg_size = cookie->alg_size; + alg_size_in_bytes = alg_size >> 3; + uint8_t *modinv_result = asym_op->modinv.result.data; + + if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) { + rte_memcpy(modinv_result + (asym_op->modinv.result.length + - ctx->sess_alg_params.mod_inv.n.length), + cookie->output_array[0] + alg_size_in_bytes + - ctx->sess_alg_params.mod_inv.n.length, + ctx->sess_alg_params.mod_inv.n.length); + rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; +#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG + QAT_DP_HEXDUMP_LOG(DEBUG, "modinv_result", + cookie->output_array[0], + alg_size_in_bytes); +#endif + } + qat_clear_arrays(cookie, 2, 1, alg_size_in_bytes, + alg_size_in_bytes); } #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG @@ -297,6 +371,15 @@ qat_asym_session_configure(struct rte_cryptodev *dev, err = -EINVAL; goto error; } + } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) { + session->sess_alg_params.mod_inv.n = xform->modinv.modulus; + session->alg = QAT_PKE_MODINV; + + if (xform->modinv.modulus.length == 0) { + QAT_LOG(ERR, "Invalid mod inv input parameter"); + err = -EINVAL; + goto error; + } } else { QAT_LOG(ERR, "Invalid asymmetric crypto xform"); err = -EINVAL; diff --git a/drivers/crypto/qat/qat_asym.h b/drivers/crypto/qat/qat_asym.h index 228d2f7..ce4839b 100644 --- a/drivers/crypto/qat/qat_asym.h +++ b/drivers/crypto/qat/qat_asym.h @@ -50,6 +50,9 @@ struct qat_asym_session { rte_crypto_param n; rte_crypto_param e; } mod_exp; + struct { + rte_crypto_param n; + } mod_inv; } sess_alg_params; }; diff --git a/drivers/crypto/qat/qat_asym_capabilities.h b/drivers/crypto/qat/qat_asym_capabilities.h index 1d6323f..f43c025 100644 --- a/drivers/crypto/qat/qat_asym_capabilities.h +++ b/drivers/crypto/qat/qat_asym_capabilities.h @@ -21,6 +21,22 @@ } \ }, \ } \ + }, \ + { /* modinv */ \ + .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC, \ + {.asym = { \ + .xform_capa = { \ + .xform_type = RTE_CRYPTO_ASYM_XFORM_MODINV, \ + .op_types = 0, \ + { \ + .modlen = { \ + .min = 1, \ + .max = 512, \ + .increment = 1 \ + }, } \ + } \ + }, \ + } \ } \ #endif /* _QAT_ASYM_CAPABILITIES_H_ */