From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM03-BY2-obe.outbound.protection.outlook.com (mail-by2nam03on0072.outbound.protection.outlook.com [104.47.42.72]) by dpdk.org (Postfix) with ESMTP id B21B45F0D for ; Tue, 27 Mar 2018 14:55:23 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=hGugfeuWN80iMj8fIsbD/BDyVh+MTdD7gZ+Pe8Bzlb8=; b=XuDmaTmbe4I0A6PPd+5F+60ZukxJN228Umc06zpwobN5BjKZ9sAKYpbdVxIJdtbEeDHJJVbEqGzcnjhySjkDOHhf0iPpBVtmz9KrRVipcZDdn/aju8WQyIjPhey6XxOOEVI/T1O3VifDZeiZA2/coX4WeYkim3JJ1VUVKg/D31A= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Shally.Verma@cavium.com; Received: from hyd1sverma-dt.caveonetworks.com (115.113.156.2) by MWHPR0701MB3644.namprd07.prod.outlook.com (2603:10b6:301:7d::37) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.609.10; Tue, 27 Mar 2018 12:55:18 +0000 From: Shally Verma To: pablo.de.lara.guarch@intel.com Cc: declan.doherty@intel.com, fiona.trahe@intel.com, pathreya@caviumnetworks.com, ssahu@caviumnetworks.com, agupta@caviumnetworks.com, dev@dpdk.org, Sunila Sahu , Ashish Gupta Date: Tue, 27 Mar 2018 18:24:41 +0530 Message-Id: <1522155281-16329-4-git-send-email-shally.verma@caviumnetworks.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1522155281-16329-1-git-send-email-shally.verma@caviumnetworks.com> References: <1522155281-16329-1-git-send-email-shally.verma@caviumnetworks.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [115.113.156.2] X-ClientProxiedBy: MA1PR01CA0089.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00::29) To MWHPR0701MB3644.namprd07.prod.outlook.com (2603:10b6:301:7d::37) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 680d897c-b43e-4d32-4c08-08d593e1ffac X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(5600026)(4604075)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:MWHPR0701MB3644; X-Microsoft-Exchange-Diagnostics: 1; MWHPR0701MB3644; 3:Qy7KyhbxqTgoxtgh0FPGlNRAZqtnhaIUEG1WEzrcxh0kgoOct6bf7Y2mCHMfzQPsQQSREocnyh0tCGf7E0VqoQF+VzyD7VMiL7bG/l0agoW4sVIv+qlKf2+s0VB2tmnDedhuny7zqD5umRNBQ4IQ6zNIii+asbtPfnh6jMHf0vRJe6CV61zbYF4GVakXv1/KBqAU8pbVL+IADaYi02wJ01grao7Bgbi35Oo7ooGZ9Tw3awM5hxmCDgkGsz3gE3KL; 25:GtosZxMFCGY5M2nN9ZAO5Y7G/Z98NVRFKY0x/WdE5CGrwTdx59FknzXbiQ6ps9nwqrwp/U+iaGsqrzQ0FH8Czkhl1ci0NHCfkL4fP8LJNxLYkSbUrttKR01zdZ8QWql1k6nsEf3K+YqA2CQ7SrQJNuQAtXLpaLv1/TMFL8l9pEoKoHwkRPZBRGlJvXnBZ0HyAuATVY4eBHkFkTCYaDr4I2VqyeaY0mmpHjfn4LkKz/jDw0kurrETaA69FnjweAaMsEt7+KxB70HMLwk1gdevRZPppCVJioQxdVaDOrFvElGTqY3Rp899OMxdxwvV0Z3J+8sWrCdi7KoJPYNoGBo7OA==; 31:3IHbbA1IPNtW8heX8JiBkEwzgOmtmDZZe54EnvjvgZN8m3qsq2nZ4ngCfkG7RQpCVSUIMVrSiWLIvkamyZfdvPB2Q7lz8VaUlafh9qMBZNhwH0V3x4RFPYhfTTMUe3XUwEQG4uStBrdOI2ncKqhUORqZZLIkUyzldn2mg6KfCfingPZ5+aDpP73juB/3DRCqe/8y0I7G2N2ZzLfh1K/jVlMs8k5hmOtEftvfbhfYIvo= X-MS-TrafficTypeDiagnostic: MWHPR0701MB3644: X-Microsoft-Exchange-Diagnostics: 1; MWHPR0701MB3644; 20:Vg4S9iMyvm3p0548Nkz///24cdiVhVt6qzu2Xrc6EJReeq1SZ/Th73QV3zGX/1tL9Fcr9Y8OuzFaq1KZ4uNa55uUVYQL126aZHzqCnFoVXn+iWqr8DQwU4ITZS43B8AmiUbxUSLZAFwF1RPNf74cVrh7qhOT2TdwChcgPNT/vidlj9ISiWA5FNeOFdLXXPRH4UAahTSR5Nc8AF+UDqOU3Fk0znwTolcEGArGhCokh1kb/eja+/NLTbrzQx96IVkiDthvQNM+ze3ebh36Q6GDKoqhGsE26HGxzDATA4LEk4xNxQbEe+xoqnjQVB1LaWk+RzOFOv4V2mIiyl29adT2a/l9wLEhKy1rk/AM6f/DXmqKtkgmNALinnhTXsxbLiI7wFuzWrNsLuOa9nN/f+BuXvjNhFgYnMv1ZrOwOOfAvzPtAhR4xy7MQ8Qe1ZYUJN4bU0D0rtSYU3qQQ2ne+XtDGznaZssG+qs+q/c+kyOxuQqwMgZCeW0GqIg+qOFWm76K+pWYc2qx8EV25fq6KNDR7bkWUR3fHG5DN7/uIp7BKvTvu2jRlipdnEN8NuHTxO5H/dZPcatzFAOpGMHTGicS0J0zMpdtQjoGBKtAFZGOoxw=; 4:SCGMaOYrkwnO5iRr+w+NWwndbCA9892M7BbiYS27txZrbhRTDk9ne/jtKQj3BlzxVcX8Hw65BBgmU9t3TigUNMs3KqrM9upzHQL4Z5/eV7d/3uNq5WtvUaS+ernOCnhOX6Ko3RSGFPSv63UKP1w5nuFvneE9cRkRyDsP7IFeVpPNA7jBTe9gQWIkcbTruxDyPEUgmfL4iOnXz0yFRgpuVP2eVRKMHdowKa5Kst+9/riZZen2sfCMapN3FL4ZfBjH7I7l6xaXH4hae6zEyoSzSA== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(3002001)(10201501046)(3231221)(944501327)(52105095)(93006095)(6041310)(20161123562045)(20161123558120)(20161123564045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(6072148)(201708071742011); SRVR:MWHPR0701MB3644; BCL:0; PCL:0; RULEID:; SRVR:MWHPR0701MB3644; X-Forefront-PRVS: 0624A2429E X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(346002)(366004)(39850400004)(396003)(376002)(39380400002)(189003)(199004)(55236004)(36756003)(81166006)(16586007)(68736007)(5890100001)(81156014)(50466002)(6666003)(106356001)(6916009)(53416004)(8676002)(5660300001)(478600001)(105586002)(2906002)(72206003)(50226002)(4326008)(3846002)(6116002)(69596002)(107886003)(575784001)(48376002)(8936002)(2361001)(316002)(2351001)(97736004)(54906003)(6512007)(26005)(305945005)(42882007)(2616005)(446003)(16526019)(186003)(11346002)(6486002)(59450400001)(47776003)(7736002)(956004)(25786009)(53936002)(386003)(6506007)(51416003)(486005)(52116002)(76176011)(476003)(486005)(66066001)(473944003); DIR:OUT; SFP:1101; SCL:1; SRVR:MWHPR0701MB3644; H:hyd1sverma-dt.caveonetworks.com; FPR:; SPF:None; PTR:InfoNoRecords; MX:1; A:1; LANG:en; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; MWHPR0701MB3644; 23:+pKUZz4srWsIMEth/KE6RiBCg/2pj18qFnbTDkb?= =?us-ascii?Q?rltyCM/Fg1RKOMw/g1IsLt/jPfI5bkX8r+JmHi7Nm9I5E2Fpryuw6RiiNSw1?= =?us-ascii?Q?dBVFufabm4jpJk53VHOk5JBj/OpEdj3CLefY/lSArunbEqcBcYBzzeeLmdsL?= =?us-ascii?Q?Q7aoXpGru0TyGUHXSWzcki4vpIs9Zz9xQz+vVG/Vf6JGi0z5fZvubgJrThpD?= =?us-ascii?Q?j1Sby5qA248wBK23GzhMhIafohMM8cSgfW0WDJsklWferX96OLKF8KUyALqO?= =?us-ascii?Q?FQbY5xpavpS/RLu39SZrd5cLOZ34DTKGLoJ4KSojO/wKnDdjWqZPFMIebu5X?= =?us-ascii?Q?dcboPZrVgMLUxQZGLK+PuadNKzruA7nYy/iwlXbHoMg2H8946x3VuMGPQrAm?= =?us-ascii?Q?Bo5PYqFNiPYOVKmlXqvk8+bMYTpNbFD4FMbA8Drc0oZ4YTUOgltn+RBgpYdU?= =?us-ascii?Q?lHBnsY+wIvdsrFTHdGzMTNRql7Hbz1P7JrJQIa4BZTNr2aW9bwzk/N0pDEr5?= =?us-ascii?Q?w39OmsxRd1k1Edg4yJJGV//vMXBwWo/v1F02TkpB8OeiKwChMFFRPDLNUybr?= =?us-ascii?Q?6aZBnimBAZMgPyZylRuNaq8JKX1fVtwYmV1MCrkecdSJnB6rS2YL7V1dyV9p?= =?us-ascii?Q?SH6W1B0I+8ss9mZKIbTHqxVkC/YiK9E3Z5OfqUhBtJYLqGtrSXZ0LjifgSQp?= =?us-ascii?Q?Y+dCFVAh1ZbtshTZA+khZPu5rYebnYTHI8aZhdyShXr1KGEmvgk+TYcgreMw?= =?us-ascii?Q?sYsaKIUR18ciYfpno3a8x0704mx5pIFAjAc+vwMi4sIuC/7iahHSC08sdB97?= =?us-ascii?Q?C+61fuSai42eo9b+e8unF/aTKPsnbRpE1+JE9tzhrs52y2K6DJTc+b/CXas9?= =?us-ascii?Q?oryxalJDp5E6YXyk0i+bp2b5yltZ442vLj4NgJeo4yKWpDVBjhcaG+Tfd3ss?= =?us-ascii?Q?MB2Aj4qsXyb40foTFdVKNWd7hb1hLOj5VfhZw1gQgvtwEYvx96whLpyq/F+s?= =?us-ascii?Q?YvqmcmspcaMSlI7hybyNjfxFTw6E1b2z8JZ0LQAgSh5yiqh1/t2SEdtYrXGs?= =?us-ascii?Q?jEbf17BN+4OrgIdddxs0EE5RrLeA31WjuCN+a07AhCxv6fQJaKePGZQwqK7O?= =?us-ascii?Q?Un8zvw+DdER3H3phEHQnDwzuAV9OPGD40P8dlX8TmeUB7JCdeWZG6haie/in?= =?us-ascii?Q?/n2TnxdlNuWt2UPoo++NC/uAdNsViJuroGeEFlIfa8J3HKiGyaMWq9J4lVJ6?= =?us-ascii?Q?hQ7DQ9ooyfZ8vMGvjw5EoUmReoYrSKlWntEHfr16B6JOO1lSyhKcB2dptugq?= =?us-ascii?Q?kYc3QHOlnemd/NqdS/1hcnlfoeufl4SvLbN9xhK1hoBYCXK+BNqxPLwwzxjt?= =?us-ascii?Q?Gp0TJe13Mtjwun8ZK9HjUdyyIojukGxNwLyCaCb4tRV0Aj3QVt7ahJftyrpZ?= =?us-ascii?Q?9gUmTUbjOGxFk2IDRerYAlv5gw/5A/KryaBMAYlUxINnuYGL0fK1F?= X-Microsoft-Antispam-Message-Info: OMDTBZvzSZ6697Tbi5fDdghDwV5boqb76W5ZJz2VrGj9JLF2vyhTYfgVEc7paZtJ9tZWBpNi5LR1yX+FqwXfSKCtpmTW8p0dpBp3TOgQySbKumPqqtzOblr67OYn6ppyWY73PJoBLUzn5LfhagfkMjTRvgJiIcoPAXv9dm4FJj8wBr4afEvHajGRlkIY/t/i X-Microsoft-Exchange-Diagnostics: 1; MWHPR0701MB3644; 6:49N+FwDRoURsOZ8K8lmgbS9Sl9YPx+unK5zJdLJkuMiJ2xvOTOKxTNXZpPLixN1UuariAf8d1gNQPE9GGJiKJ9xMD4mTJXCr2+hH8AqbMm+W7JDMhOZkJCvbnYGGkeF4xx/Fo/eLRRFD0ZdblhAI1cFVCuPSi/jscWW3RPdICqDwYzYpzlRyTAmCo5hzHky1WFyejZU0weQorywBUI4whVcUzZ06l8VL8qDThW7cYXjJXhc/AOVpfv4C9pWI24PNBqvbbJu5xiTUKgu6GtsYFZ5pL9gsur0YkB98AUmlTF0zMDEl3rdp57tqWPABetxCEG27BCmnkbye/t1/UO4lSweUlf7n71xD5PHbTWO51Serb/KOnD5ZYxVz706DgcdgMpxo44P4y0ZFrj3Q1aVTCW5dLQMz6E/qphe+uZlhUv48GffaHtgUl9mFIEQn4yICNQaAX3Xgm2oCWuNc9XK8wg==; 5:rIth6HFK5lcymxoUBlmWEg0ExWfi1Tiyea+B4sj0QBkF6zY7Zp/YQ0oFBT+DJyxT5eaJL+Et1E23zabQ3ZI5IJ1vomuZGgnn/kd2QRXAlCD0010yEy6LtmJ9jSv9af5oKfFtpDHLq5gANDbDY4Ufgdt8fNm3itHAhtOSY5McaPA=; 24:RE1T50SP7e1UqqP4g/qqPP4cr+rFg4c6MmRvzUa1sISmb3eixkX70dHy2+hl/VtAADB6paj6506idUcJlhEKJ9XbvkppLmnE5w3yRMF3kHw= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; MWHPR0701MB3644; 7:Lk6T/R1AXk90F03qhplfdIpuZ5fgHd2IDr8bqNBdIlcr/oIq02jUYxyh3vvLJmGrwuElqoSIAPzP/2EKWvFCj75KaK2KJZocK9cEfqlppUbWgZDwbeL44PUmDawK2YF5oIc9aCfFstiIcRd3lZDg+4tuiA/Wv5Sq2lYHSyLrKSmN7oWsT2lqZcdqFSwJdj2cp/0WPjnFyKVkuWglSQzzweDO1dU24cjemRB5uMwo5SyyCJCZPHv3ksjczVq7ypu8 X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 27 Mar 2018 12:55:18.2636 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 680d897c-b43e-4d32-4c08-08d593e1ffac X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR0701MB3644 Subject: [dpdk-dev] [PATCH v1 3/3] lib/cryptodev: add asymmetric algos in cryptodev 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: , X-List-Received-Date: Tue, 27 Mar 2018 12:55:25 -0000 Add rte_crypto_asym.h with supported algo enumerations and associated xforms and op structures. API currently supports: RSA, Modular Exponentiation, Modular Inverse, DSA, Deffie-hellman And op_types: Encryption, Decryption, Sign, Verify, Deffie-hellman private key exchange, Deffie-hellman public key exchange, Deffie-hellman shared secret compute, Application can setup deffie-hellman xform to do public key generation or private key generation or shared secret compute. It can also setup a xform chain with public and private key generate xform to generate both public and private key pair. Signed-off-by: Shally Verma Signed-off-by: Sunila Sahu Signed-off-by: Ashish Gupta --- TODO: Add elliptic curve support. --- --- lib/librte_cryptodev/Makefile | 2 +- lib/librte_cryptodev/rte_crypto_asym.h | 519 +++++++++++++++++++++++++++++++++ 2 files changed, 520 insertions(+), 1 deletion(-) diff --git a/lib/librte_cryptodev/Makefile b/lib/librte_cryptodev/Makefile index 6815e6ff3..93f9d2d45 100644 --- a/lib/librte_cryptodev/Makefile +++ b/lib/librte_cryptodev/Makefile @@ -24,7 +24,7 @@ SYMLINK-y-include += rte_crypto.h SYMLINK-y-include += rte_crypto_sym.h SYMLINK-y-include += rte_cryptodev.h SYMLINK-y-include += rte_cryptodev_pmd.h - +SYMLINK-y-include += rte_crypto_asym.h # versioning export map EXPORT_MAP := rte_cryptodev_version.map diff --git a/lib/librte_cryptodev/rte_crypto_asym.h b/lib/librte_cryptodev/rte_crypto_asym.h new file mode 100644 index 000000000..d0e2f1d40 --- /dev/null +++ b/lib/librte_cryptodev/rte_crypto_asym.h @@ -0,0 +1,519 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2017-2018 Cavium Networks + */ + +#ifndef _RTE_CRYPTO_ASYM_H_ +#define _RTE_CRYPTO_ASYM_H_ + +/** + * @file rte_crypto_asym.h + * + * RTE Definitions for Asymmetric Cryptography + * + * Defines asymmetric algorithms and modes, as well as supported + * asymmetric crypto operations. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include + +typedef struct rte_crypto_param_t { + uint8_t *data; + /**< pointer to buffer holding data */ + rte_iova_t iova; + /**< IO address of data buffer */ + size_t length; + /**< length of data in bytes */ +} rte_crypto_param; + +/** asym xform type name strings */ +extern const char * +rte_crypto_asym_xform_strings[]; + +/** asym operations type name strings */ +extern const char * +rte_crypto_asym_op_strings[]; + +/** + * Asymmetric crypto transformation types. + * Each xform type maps to one asymmetric algorithm + * performing specific operation + * + */ +enum rte_crypto_asym_xform_type { + RTE_CRYPTO_ASYM_XFORM_UNSPECIFIED = 0, + /**< Invalid xform. */ + RTE_CRYPTO_ASYM_XFORM_NONE, + /**< Xform type None. + * May be supported by PMD to support + * passthrough op for debugging purpose. + * if xform_type none , op_type is disregarded. + */ + RTE_CRYPTO_ASYM_XFORM_RSA, + /**< RSA. Performs Encrypt, Decrypt, Sign and Verify. + * Refer to rte_crypto_asym_op_type + */ + RTE_CRYPTO_ASYM_XFORM_DH, + /**< Deffie-Hellman. + * Performs Key Generate and Shared Secret Compute. + * Refer to rte_crypto_asym_op_type + */ + RTE_CRYPTO_ASYM_XFORM_DSA, + /**< Digital Signature Algorithm + * Performs Signature Generation and Verification. + * Refer to rte_crypto_asym_op_type + */ + RTE_CRYPTO_ASYM_XFORM_MODINV, + /**< Modular Inverse + * Perform Modulus inverse b^(-1) mod n + */ + RTE_CRYPTO_ASYM_XFORM_MODEX, + /**< Modular Exponentiation + * Perform Modular Exponentiation b^e mod n + */ + RTE_CRYPTO_ASYM_XFORM_TYPE_LIST_END + /**< End of list */ +}; + +/** + * Asymmetric crypto operation type variants + */ +enum rte_crypto_asym_op_type { + RTE_CRYPTO_ASYM_OP_ENCRYPT, + /**< Asymmetric Encrypt operation */ + RTE_CRYPTO_ASYM_OP_DECRYPT, + /**< Asymmetric Decrypt operation */ + RTE_CRYPTO_ASYM_OP_SIGN, + /**< Signature Generation operation */ + RTE_CRYPTO_ASYM_OP_VERIFY, + /**< Signature Verification operation */ + RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE, + /**< DH Private Key generation operation */ + RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE, + /**< DH Public Key generation operation */ + RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE, + /**< DH Shared Secret compute operation */ + RTE_CRYPTO_ASYM_OP_LIST_END +}; + +/** + * Padding types for RSA signature. + */ +enum rte_crypto_rsa_padding_type { + RTE_CRYPTO_RSA_PADDING_NONE = 0, + /**< RSA no padding scheme */ + RTE_CRYPTO_RSA_PKCS1_V1_5_BT0, + /**< RSA PKCS#1 V1.5 Block Type 0 padding scheme + * as descibed in rfc2313 + */ + RTE_CRYPTO_RSA_PKCS1_V1_5_BT1, + /**< RSA PKCS#1 V1.5 Block Type 01 padding scheme + * as descibed in rfc2313 + */ + RTE_CRYPTO_RSA_PKCS1_V1_5_BT2, + /**< RSA PKCS#1 V1.5 Block Type 02 padding scheme + * as descibed in rfc2313 + */ + RTE_CRYPTO_RSA_PADDING_OAEP, + /**< RSA PKCS#1 OAEP padding scheme */ + RTE_CRYPTO_RSA_PADDING_PSS, + /**< RSA PKCS#1 PSS padding scheme */ + RTE_CRYPTO_RSA_PADDING_TYPE_LIST_END +}; + +/** + * RSA private key type enumeration + * + * enumerates private key format required to perform RSA crypto + * transform. + * + */ +enum rte_crypto_rsa_priv_key_type { + RTE_RSA_KEY_TYPE_EXP, + /**< RSA private key is an exponent */ + RTE_RSA_KET_TYPE_QT, + /**< RSA private key is in quintuple format + * See rte_crypto_rsa_priv_key_qt + */ +}; + +/** + * Structure describing RSA private key in quintuple format. + * See PKCS V1.5 RSA Cryptography Standard. + */ +struct rte_crypto_rsa_priv_key_qt { + rte_crypto_param p; + /**< p - Private key component P + * Private key component of RSA parameter required for CRT method + * of private key operations in Octet-string network byte order + * format. + */ + + rte_crypto_param q; + /**< q - Private key component Q + * Private key component of RSA parameter required for CRT method + * of private key operations in Octet-string network byte order + * format. + */ + + rte_crypto_param dP; + /**< dP - Private CRT component + * Private CRT component of RSA parameter required for CRT method + * RSA private key operations in Octet-string network byte order + * format. + * dP = d mod ( p - 1 ) + */ + + rte_crypto_param dQ; + /**< dQ - Private CRT component + * Private CRT component of RSA parameter required for CRT method + * RSA private key operations in Octet-string network byte order + * format. + * dQ = d mod ( q - 1 ) + */ + + rte_crypto_param qInv; + /**< qInv - Private CRT component + * Private CRT component of RSA parameter required for CRT method + * RSA private key operations in Octet-string network byte order + * format. + * qInv = inv q mod p + */ +}; + +/** + * Asymmetric RSA transform data + * + * Structure describing RSA xform params + * + */ +struct rte_crypto_rsa_xform { + rte_crypto_param n; + /**< n - Prime modulus + * Prime modulus data of RSA operation in Octet-string network + * byte order format. + */ + + rte_crypto_param e; + /**< e - Public key exponent + * Public key exponent used for RSA public key operations in Octet- + * string network byte order format. + */ + + enum rte_crypto_rsa_priv_key_type key_type; + + union { + rte_crypto_param d; + /**< d - Private key exponent + * Private key exponent used for RSA + * private key operations in + * Octet-string network byte order format. + */ + + struct rte_crypto_rsa_priv_key_qt qt; + /**< qt - Private key in quintuple format */ + }; +}; + +/** + * Asymmetric Modular exponentiation transform data + * + * Structure describing modular exponentation xform param + * + */ +struct rte_crypto_modex_xform { + rte_crypto_param modulus; + /**< modulus + * Prime modulus of the modexp transform operation in octet-string + * network byte order format. + */ + + rte_crypto_param exponent; + /**< exponent + * Private exponent of the modexp transform operation in + * octet-string network byte order format. + */ +}; + +/** + * Asymmetric modular inverse transform operation + * + * Structure describing modulus inverse xform params + * + */ +struct rte_crypto_modinv_xform { + rte_crypto_param modulus; + /**< + * Pointer to the prime modulus data for modular + * inverse operation in octet-string network byte + * order format. + */ +}; + +/** + * Asymmetric DH transform data + * + * Structure describing deffie-hellman xform params + * + */ +struct rte_crypto_dh_xform { + enum rte_crypto_asym_op_type type; + /**< Setup xform for key generate or shared secret compute */ + + rte_crypto_param p; + /**< p : Prime modulus data + * DH prime modulous data in octet-string network byte order format. + * + */ + + rte_crypto_param g; + /**< g : Generator + * DH group generator data in octet-string network byte order + * format. + * + */ +}; + +/** + * Asymmetric Digital Signature transform operation + * + * Structure describing DSA xform params + * + */ +struct rte_crypto_dsa_xform { + rte_crypto_param p; + /**< p - Prime modulus + * Prime modulus data for DSA operation in Octet-string network byte + * order format. + */ + rte_crypto_param q; + /**< q : Order of the subgroup. + * Order of the subgroup data in Octet-string network byte order + * format. + * (p-1) % q = 0 + */ + rte_crypto_param g; + /**< g: Generator of the subgroup + * Generator data in Octet-string network byte order format. + */ + rte_crypto_param x; + /**< x: Private key of the signer in octet-string network + * byte order format. + * Used when app has pre-defined private key. + * Valid only when xform chain is DSA ONLY. + * if xform chain is DH private key generate + DSA, then DSA sign + * compute will use internally generated key. + */ +}; + +/** + * Operations params for modular operations: + * exponentiation and invert + * + */ +struct rte_crypto_mod_op_param { + rte_crypto_param base; + /**< + * Pointer to base of modular exponentiation/inversion data in + * Octet-string network byte order format. + */ +}; + +/** + * Asymmetric crypto transform data + * + * Structure describing asym xforms. + */ +struct rte_crypto_asym_xform { + struct rte_crypto_asym_xform *next; + /**< Pointer to next xform to set up xform chain.*/ + enum rte_crypto_asym_xform_type xform_type; + /**< Asymmetric crypto transform */ + + __extension__ + union { + struct rte_crypto_rsa_xform rsa; + /**< RSA xform parameters */ + + struct rte_crypto_modex_xform modex; + /**< Modular Exponentiation xform parameters */ + + struct rte_crypto_modinv_xform modinv; + /**< Modulus Inverse xform parameters */ + + struct rte_crypto_dh_xform dh; + /**< DH xform parameters */ + + struct rte_crypto_dsa_xform dsa; + /**< DSA xform parameters */ + }; +}; + +struct rte_cryptodev_asym_session; + +/** + * RSA operation params + * + */ +struct rte_crypto_rsa_op_param { + enum rte_crypto_asym_op_type op_type; + /**< Type of RSA operation for transform */; + + rte_crypto_param message; + /**< + * Pointer to data + * - to be encrypted for RSA public encrypt. + * - to be decrypted for RSA private decrypt. + * - to be signed for RSA sign generation. + * - to be authenticated for RSA sign verification. + */ + + rte_crypto_param sign; + /**< + * Pointer to RSA signature data. If operation is RSA + * sign @ref RTE_CRYPTO_RSA_OP_SIGN, buffer will be + * over-written with generated signature. + * + * Length of the signature data will be equal to the + * RSA prime modulus length. + */ + + enum rte_crypto_rsa_padding_type pad; + /**< RSA padding scheme to be used for transform */ + + enum rte_crypto_auth_algorithm md; + /**< Hash algorithm to be used for data hash if padding + * scheme is either OAEP or PSS. Valid hash algorithms + * are: + * MD5, SHA1, SHA224, SHA256, SHA384, SHA512 + */ + + enum rte_crypto_auth_algorithm mgf1md; + /**< + * Hash algorithm to be used for mask generation if + * padding scheme is either OAEP or PSS. If padding + * scheme is unspecified data hash algorithm is used + * for mask generation. Valid hash algorithms are: + * MD5, SHA1, SHA224, SHA256, SHA384, SHA512 + */ +}; + +/** + * Deffie-Hellman Operations params. + * @note: + */ +struct rte_crypto_dh_op_param { + rte_crypto_param pub_key; + /**< + * Output generated public key when xform type is + * DH PUB_KEY_GENERATION. + * Input peer public key when xform type is DH + * SHARED_SECRET_COMPUTATION + * pub_key is in octet-string network byte order format. + * + */ + + rte_crypto_param priv_key; + /**< + * Output generated private key if xform type is + * DH PRIVATE_KEY_GENERATION + * Input when xform type is DH SHARED_SECRET_COMPUTATION. + * priv_key is in octet-string network byte order format. + * + */ + + rte_crypto_param shared_secret; + /**< + * Output with calculated shared secret + * when dh xform set up with op type = SHARED_SECRET_COMPUTATION. + * shared_secret is an octet-string network byte order format. + * + */ +}; + +/** + * DSA Operations params + * + */ +struct rte_crypto_dsa_op_param { + enum rte_crypto_asym_op_type op_type; + /**< Signature Generation or Verification */ + rte_crypto_param message; + /**< input message to be signed or verified */ + rte_crypto_param r; + /**< dsa sign component 'r' value + * + * output if op_type = sign generate, + * input if op_type = sign verify + */ + rte_crypto_param s; + /**< dsa sign component 's' value + * + * output if op_type = sign generate, + * input if op_type = sign verify + */ + rte_crypto_param y; + /**< y : Public key of the signer. + * Public key data of the signer in Octet-string network byte order + * format. + * y = g^x mod p + */ +}; + +/** + * Asymmetric Cryptographic Operation. + * + * Structure describing asymmetric crypto operation params. + * + */ +struct rte_crypto_asym_op { + struct rte_cryptodev_asym_session *session; + /**< Handle for the initialised session context */ + + __extension__ + union { + struct rte_crypto_rsa_op_param rsa; + struct rte_crypto_mod_op_param modex; + struct rte_crypto_mod_op_param modinv; + struct rte_crypto_dh_op_param dh; + struct rte_crypto_dsa_op_param dsa; + }; +} __rte_cache_aligned; + +/** + * Reset the fields of an asymmetric operation to their default values. + * + * @param op The crypto operation to be reset. + */ +static inline void +__rte_crypto_asym_op_reset(struct rte_crypto_asym_op *op) +{ + memset(op, 0, sizeof(*op)); +} + +/** + * Attach a session to an asymmetric crypto operation + * + * @param asym_op crypto operation + * @param sess cryptodev session + */ +static inline int +__rte_crypto_op_attach_asym_session(struct rte_crypto_asym_op *asym_op, + struct rte_cryptodev_asym_session *sess) +{ + asym_op->session = sess; + return 0; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_CRYPTO_ASYM_H_ */ -- 2.14.3