aboutsummaryrefslogtreecommitdiffstats
path: root/common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch
diff options
context:
space:
mode:
Diffstat (limited to 'common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch')
-rw-r--r--common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch608
1 files changed, 608 insertions, 0 deletions
diff --git a/common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch b/common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch
new file mode 100644
index 00000000..da30fb84
--- /dev/null
+++ b/common/dpdk/recipes-extended/dpdk/dpdk/dpdk-dev-v4-15-20-crypto-ccp-support-sha2-family-authentication-algo.patch
@@ -0,0 +1,608 @@
+From patchwork Fri Mar 9 08:35:15 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [dpdk-dev, v4,
+ 15/20] crypto/ccp: support sha2 family authentication algo
+From: Ravi Kumar <ravi1.kumar@amd.com>
+X-Patchwork-Id: 35814
+X-Patchwork-Delegate: pablo.de.lara.guarch@intel.com
+Message-Id: <1520584520-130522-15-git-send-email-Ravi1.kumar@amd.com>
+List-Id: dev.dpdk.org
+To: dev@dpdk.org
+Cc: pablo.de.lara.guarch@intel.com
+Date: Fri, 9 Mar 2018 03:35:15 -0500
+
+Signed-off-by: Ravi Kumar <Ravi1.kumar@amd.com>
+---
+ drivers/crypto/ccp/ccp_crypto.c | 270 +++++++++++++++++++++++++++++++++++++++
+ drivers/crypto/ccp/ccp_crypto.h | 48 +++++++
+ drivers/crypto/ccp/ccp_pmd_ops.c | 168 ++++++++++++++++++++++++
+ 3 files changed, 486 insertions(+)
+
+diff --git a/drivers/crypto/ccp/ccp_crypto.c b/drivers/crypto/ccp/ccp_crypto.c
+index c575dc1..410e8bf 100644
+--- a/drivers/crypto/ccp/ccp_crypto.c
++++ b/drivers/crypto/ccp/ccp_crypto.c
+@@ -61,6 +61,34 @@ static uint32_t ccp_sha1_init[SHA_COMMON_DIGEST_SIZE / sizeof(uint32_t)] = {
+ 0x0U, 0x0U,
+ };
+
++uint32_t ccp_sha224_init[SHA256_DIGEST_SIZE / sizeof(uint32_t)] = {
++ SHA224_H7, SHA224_H6,
++ SHA224_H5, SHA224_H4,
++ SHA224_H3, SHA224_H2,
++ SHA224_H1, SHA224_H0,
++};
++
++uint32_t ccp_sha256_init[SHA256_DIGEST_SIZE / sizeof(uint32_t)] = {
++ SHA256_H7, SHA256_H6,
++ SHA256_H5, SHA256_H4,
++ SHA256_H3, SHA256_H2,
++ SHA256_H1, SHA256_H0,
++};
++
++uint64_t ccp_sha384_init[SHA512_DIGEST_SIZE / sizeof(uint64_t)] = {
++ SHA384_H7, SHA384_H6,
++ SHA384_H5, SHA384_H4,
++ SHA384_H3, SHA384_H2,
++ SHA384_H1, SHA384_H0,
++};
++
++uint64_t ccp_sha512_init[SHA512_DIGEST_SIZE / sizeof(uint64_t)] = {
++ SHA512_H7, SHA512_H6,
++ SHA512_H5, SHA512_H4,
++ SHA512_H3, SHA512_H2,
++ SHA512_H1, SHA512_H0,
++};
++
+ static enum ccp_cmd_order
+ ccp_get_cmd_id(const struct rte_crypto_sym_xform *xform)
+ {
+@@ -97,6 +125,54 @@ static int partial_hash_sha1(uint8_t *data_in, uint8_t *data_out)
+ return 0;
+ }
+
++static int partial_hash_sha224(uint8_t *data_in, uint8_t *data_out)
++{
++ SHA256_CTX ctx;
++
++ if (!SHA224_Init(&ctx))
++ return -EFAULT;
++ SHA256_Transform(&ctx, data_in);
++ rte_memcpy(data_out, &ctx,
++ SHA256_DIGEST_LENGTH);
++ return 0;
++}
++
++static int partial_hash_sha256(uint8_t *data_in, uint8_t *data_out)
++{
++ SHA256_CTX ctx;
++
++ if (!SHA256_Init(&ctx))
++ return -EFAULT;
++ SHA256_Transform(&ctx, data_in);
++ rte_memcpy(data_out, &ctx,
++ SHA256_DIGEST_LENGTH);
++ return 0;
++}
++
++static int partial_hash_sha384(uint8_t *data_in, uint8_t *data_out)
++{
++ SHA512_CTX ctx;
++
++ if (!SHA384_Init(&ctx))
++ return -EFAULT;
++ SHA512_Transform(&ctx, data_in);
++ rte_memcpy(data_out, &ctx,
++ SHA512_DIGEST_LENGTH);
++ return 0;
++}
++
++static int partial_hash_sha512(uint8_t *data_in, uint8_t *data_out)
++{
++ SHA512_CTX ctx;
++
++ if (!SHA512_Init(&ctx))
++ return -EFAULT;
++ SHA512_Transform(&ctx, data_in);
++ rte_memcpy(data_out, &ctx,
++ SHA512_DIGEST_LENGTH);
++ return 0;
++}
++
+ static int generate_partial_hash(struct ccp_session *sess)
+ {
+
+@@ -104,11 +180,13 @@ static int generate_partial_hash(struct ccp_session *sess)
+ uint8_t opad[sess->auth.block_size];
+ uint8_t *ipad_t, *opad_t;
+ uint32_t *hash_value_be32, hash_temp32[8];
++ uint64_t *hash_value_be64, hash_temp64[8];
+ int i, count;
+
+ opad_t = ipad_t = (uint8_t *)sess->auth.key;
+
+ hash_value_be32 = (uint32_t *)((uint8_t *)sess->auth.pre_compute);
++ hash_value_be64 = (uint64_t *)((uint8_t *)sess->auth.pre_compute);
+
+ /* considering key size is always equal to block size of algorithm */
+ for (i = 0; i < sess->auth.block_size; i++) {
+@@ -132,6 +210,66 @@ static int generate_partial_hash(struct ccp_session *sess)
+ for (i = 0; i < count; i++, hash_value_be32++)
+ *hash_value_be32 = hash_temp32[count - 1 - i];
+ return 0;
++ case CCP_AUTH_ALGO_SHA224_HMAC:
++ count = SHA256_DIGEST_SIZE >> 2;
++
++ if (partial_hash_sha224(ipad, (uint8_t *)hash_temp32))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be32++)
++ *hash_value_be32 = hash_temp32[count - 1 - i];
++
++ hash_value_be32 = (uint32_t *)((uint8_t *)sess->auth.pre_compute
++ + sess->auth.ctx_len);
++ if (partial_hash_sha224(opad, (uint8_t *)hash_temp32))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be32++)
++ *hash_value_be32 = hash_temp32[count - 1 - i];
++ return 0;
++ case CCP_AUTH_ALGO_SHA256_HMAC:
++ count = SHA256_DIGEST_SIZE >> 2;
++
++ if (partial_hash_sha256(ipad, (uint8_t *)hash_temp32))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be32++)
++ *hash_value_be32 = hash_temp32[count - 1 - i];
++
++ hash_value_be32 = (uint32_t *)((uint8_t *)sess->auth.pre_compute
++ + sess->auth.ctx_len);
++ if (partial_hash_sha256(opad, (uint8_t *)hash_temp32))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be32++)
++ *hash_value_be32 = hash_temp32[count - 1 - i];
++ return 0;
++ case CCP_AUTH_ALGO_SHA384_HMAC:
++ count = SHA512_DIGEST_SIZE >> 3;
++
++ if (partial_hash_sha384(ipad, (uint8_t *)hash_temp64))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be64++)
++ *hash_value_be64 = hash_temp64[count - 1 - i];
++
++ hash_value_be64 = (uint64_t *)((uint8_t *)sess->auth.pre_compute
++ + sess->auth.ctx_len);
++ if (partial_hash_sha384(opad, (uint8_t *)hash_temp64))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be64++)
++ *hash_value_be64 = hash_temp64[count - 1 - i];
++ return 0;
++ case CCP_AUTH_ALGO_SHA512_HMAC:
++ count = SHA512_DIGEST_SIZE >> 3;
++
++ if (partial_hash_sha512(ipad, (uint8_t *)hash_temp64))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be64++)
++ *hash_value_be64 = hash_temp64[count - 1 - i];
++
++ hash_value_be64 = (uint64_t *)((uint8_t *)sess->auth.pre_compute
++ + sess->auth.ctx_len);
++ if (partial_hash_sha512(opad, (uint8_t *)hash_temp64))
++ return -1;
++ for (i = 0; i < count; i++, hash_value_be64++)
++ *hash_value_be64 = hash_temp64[count - 1 - i];
++ return 0;
+ default:
+ CCP_LOG_ERR("Invalid auth algo");
+ return -1;
+@@ -347,6 +485,107 @@ ccp_configure_session_auth(struct ccp_session *sess,
+ if (generate_partial_hash(sess))
+ return -1;
+ break;
++ case RTE_CRYPTO_AUTH_SHA224:
++ sess->auth.algo = CCP_AUTH_ALGO_SHA224;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_224;
++ sess->auth.ctx = (void *)ccp_sha224_init;
++ sess->auth.ctx_len = CCP_SB_BYTES;
++ sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE;
++ break;
++ case RTE_CRYPTO_AUTH_SHA224_HMAC:
++ if (auth_xform->key.length > SHA224_BLOCK_SIZE)
++ return -1;
++ sess->auth.algo = CCP_AUTH_ALGO_SHA224_HMAC;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_224;
++ sess->auth.ctx_len = CCP_SB_BYTES;
++ sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE;
++ sess->auth.block_size = SHA224_BLOCK_SIZE;
++ sess->auth.key_length = auth_xform->key.length;
++ memset(sess->auth.key, 0, sess->auth.block_size);
++ memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1);
++ rte_memcpy(sess->auth.key, auth_xform->key.data,
++ auth_xform->key.length);
++ if (generate_partial_hash(sess))
++ return -1;
++ break;
++ case RTE_CRYPTO_AUTH_SHA256:
++ sess->auth.algo = CCP_AUTH_ALGO_SHA256;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_256;
++ sess->auth.ctx = (void *)ccp_sha256_init;
++ sess->auth.ctx_len = CCP_SB_BYTES;
++ sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE;
++ break;
++ case RTE_CRYPTO_AUTH_SHA256_HMAC:
++ if (auth_xform->key.length > SHA256_BLOCK_SIZE)
++ return -1;
++ sess->auth.algo = CCP_AUTH_ALGO_SHA256_HMAC;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_256;
++ sess->auth.ctx_len = CCP_SB_BYTES;
++ sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE;
++ sess->auth.block_size = SHA256_BLOCK_SIZE;
++ sess->auth.key_length = auth_xform->key.length;
++ memset(sess->auth.key, 0, sess->auth.block_size);
++ memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1);
++ rte_memcpy(sess->auth.key, auth_xform->key.data,
++ auth_xform->key.length);
++ if (generate_partial_hash(sess))
++ return -1;
++ break;
++ case RTE_CRYPTO_AUTH_SHA384:
++ sess->auth.algo = CCP_AUTH_ALGO_SHA384;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_384;
++ sess->auth.ctx = (void *)ccp_sha384_init;
++ sess->auth.ctx_len = CCP_SB_BYTES << 1;
++ sess->auth.offset = (CCP_SB_BYTES << 1) - SHA384_DIGEST_SIZE;
++ break;
++ case RTE_CRYPTO_AUTH_SHA384_HMAC:
++ if (auth_xform->key.length > SHA384_BLOCK_SIZE)
++ return -1;
++ sess->auth.algo = CCP_AUTH_ALGO_SHA384_HMAC;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_384;
++ sess->auth.ctx_len = CCP_SB_BYTES << 1;
++ sess->auth.offset = (CCP_SB_BYTES << 1) - SHA384_DIGEST_SIZE;
++ sess->auth.block_size = SHA384_BLOCK_SIZE;
++ sess->auth.key_length = auth_xform->key.length;
++ memset(sess->auth.key, 0, sess->auth.block_size);
++ memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1);
++ rte_memcpy(sess->auth.key, auth_xform->key.data,
++ auth_xform->key.length);
++ if (generate_partial_hash(sess))
++ return -1;
++ break;
++ case RTE_CRYPTO_AUTH_SHA512:
++ sess->auth.algo = CCP_AUTH_ALGO_SHA512;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_512;
++ sess->auth.ctx = (void *)ccp_sha512_init;
++ sess->auth.ctx_len = CCP_SB_BYTES << 1;
++ sess->auth.offset = (CCP_SB_BYTES << 1) - SHA512_DIGEST_SIZE;
++ break;
++ case RTE_CRYPTO_AUTH_SHA512_HMAC:
++ if (auth_xform->key.length > SHA512_BLOCK_SIZE)
++ return -1;
++ sess->auth.algo = CCP_AUTH_ALGO_SHA512_HMAC;
++ sess->auth.engine = CCP_ENGINE_SHA;
++ sess->auth.ut.sha_type = CCP_SHA_TYPE_512;
++ sess->auth.ctx_len = CCP_SB_BYTES << 1;
++ sess->auth.offset = (CCP_SB_BYTES << 1) - SHA512_DIGEST_SIZE;
++ sess->auth.block_size = SHA512_BLOCK_SIZE;
++ sess->auth.key_length = auth_xform->key.length;
++ memset(sess->auth.key, 0, sess->auth.block_size);
++ memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1);
++ rte_memcpy(sess->auth.key, auth_xform->key.data,
++ auth_xform->key.length);
++ if (generate_partial_hash(sess))
++ return -1;
++ break;
++
+ case RTE_CRYPTO_AUTH_AES_CMAC:
+ sess->auth.algo = CCP_AUTH_ALGO_AES_CMAC;
+ sess->auth.engine = CCP_ENGINE_AES;
+@@ -541,12 +780,32 @@ ccp_auth_slot(struct ccp_session *session)
+
+ switch (session->auth.algo) {
+ case CCP_AUTH_ALGO_SHA1:
++ case CCP_AUTH_ALGO_SHA224:
++ case CCP_AUTH_ALGO_SHA256:
++ case CCP_AUTH_ALGO_SHA384:
++ case CCP_AUTH_ALGO_SHA512:
+ count = 3;
+ /**< op + lsb passthrough cpy to/from*/
+ break;
+ case CCP_AUTH_ALGO_SHA1_HMAC:
++ case CCP_AUTH_ALGO_SHA224_HMAC:
++ case CCP_AUTH_ALGO_SHA256_HMAC:
+ count = 6;
+ break;
++ case CCP_AUTH_ALGO_SHA384_HMAC:
++ case CCP_AUTH_ALGO_SHA512_HMAC:
++ count = 7;
++ /**
++ * 1. Load PHash1 = H(k ^ ipad); to LSB
++ * 2. generate IHash = H(hash on meassage with PHash1
++ * as init values);
++ * 3. Retrieve IHash 2 slots for 384/512
++ * 4. Load Phash2 = H(k ^ opad); to LSB
++ * 5. generate FHash = H(hash on Ihash with Phash2
++ * as init value);
++ * 6. Retrieve HMAC output from LSB to host memory
++ */
++ break;
+ case CCP_AUTH_ALGO_AES_CMAC:
+ count = 4;
+ /**
+@@ -1503,13 +1762,24 @@ ccp_crypto_auth(struct rte_crypto_op *op,
+
+ switch (session->auth.algo) {
+ case CCP_AUTH_ALGO_SHA1:
++ case CCP_AUTH_ALGO_SHA224:
++ case CCP_AUTH_ALGO_SHA256:
++ case CCP_AUTH_ALGO_SHA384:
++ case CCP_AUTH_ALGO_SHA512:
+ result = ccp_perform_sha(op, cmd_q);
+ b_info->desccnt += 3;
+ break;
+ case CCP_AUTH_ALGO_SHA1_HMAC:
++ case CCP_AUTH_ALGO_SHA224_HMAC:
++ case CCP_AUTH_ALGO_SHA256_HMAC:
+ result = ccp_perform_hmac(op, cmd_q);
+ b_info->desccnt += 6;
+ break;
++ case CCP_AUTH_ALGO_SHA384_HMAC:
++ case CCP_AUTH_ALGO_SHA512_HMAC:
++ result = ccp_perform_hmac(op, cmd_q);
++ b_info->desccnt += 7;
++ break;
+ case CCP_AUTH_ALGO_AES_CMAC:
+ result = ccp_perform_aes_cmac(op, cmd_q);
+ b_info->desccnt += 4;
+diff --git a/drivers/crypto/ccp/ccp_crypto.h b/drivers/crypto/ccp/ccp_crypto.h
+index 42179de..ca1c1a8 100644
+--- a/drivers/crypto/ccp/ccp_crypto.h
++++ b/drivers/crypto/ccp/ccp_crypto.h
+@@ -78,6 +78,18 @@
+ #define SHA1_DIGEST_SIZE 20
+ #define SHA1_BLOCK_SIZE 64
+
++#define SHA224_DIGEST_SIZE 28
++#define SHA224_BLOCK_SIZE 64
++
++#define SHA256_DIGEST_SIZE 32
++#define SHA256_BLOCK_SIZE 64
++
++#define SHA384_DIGEST_SIZE 48
++#define SHA384_BLOCK_SIZE 128
++
++#define SHA512_DIGEST_SIZE 64
++#define SHA512_BLOCK_SIZE 128
++
+ /* SHA LSB intialiazation values */
+
+ #define SHA1_H0 0x67452301UL
+@@ -86,6 +98,42 @@
+ #define SHA1_H3 0x10325476UL
+ #define SHA1_H4 0xc3d2e1f0UL
+
++#define SHA224_H0 0xc1059ed8UL
++#define SHA224_H1 0x367cd507UL
++#define SHA224_H2 0x3070dd17UL
++#define SHA224_H3 0xf70e5939UL
++#define SHA224_H4 0xffc00b31UL
++#define SHA224_H5 0x68581511UL
++#define SHA224_H6 0x64f98fa7UL
++#define SHA224_H7 0xbefa4fa4UL
++
++#define SHA256_H0 0x6a09e667UL
++#define SHA256_H1 0xbb67ae85UL
++#define SHA256_H2 0x3c6ef372UL
++#define SHA256_H3 0xa54ff53aUL
++#define SHA256_H4 0x510e527fUL
++#define SHA256_H5 0x9b05688cUL
++#define SHA256_H6 0x1f83d9abUL
++#define SHA256_H7 0x5be0cd19UL
++
++#define SHA384_H0 0xcbbb9d5dc1059ed8ULL
++#define SHA384_H1 0x629a292a367cd507ULL
++#define SHA384_H2 0x9159015a3070dd17ULL
++#define SHA384_H3 0x152fecd8f70e5939ULL
++#define SHA384_H4 0x67332667ffc00b31ULL
++#define SHA384_H5 0x8eb44a8768581511ULL
++#define SHA384_H6 0xdb0c2e0d64f98fa7ULL
++#define SHA384_H7 0x47b5481dbefa4fa4ULL
++
++#define SHA512_H0 0x6a09e667f3bcc908ULL
++#define SHA512_H1 0xbb67ae8584caa73bULL
++#define SHA512_H2 0x3c6ef372fe94f82bULL
++#define SHA512_H3 0xa54ff53a5f1d36f1ULL
++#define SHA512_H4 0x510e527fade682d1ULL
++#define SHA512_H5 0x9b05688c2b3e6c1fULL
++#define SHA512_H6 0x1f83d9abfb41bd6bULL
++#define SHA512_H7 0x5be0cd19137e2179ULL
++
+ /**
+ * CCP supported AES modes
+ */
+diff --git a/drivers/crypto/ccp/ccp_pmd_ops.c b/drivers/crypto/ccp/ccp_pmd_ops.c
+index 6adef1c..ab6199f 100644
+--- a/drivers/crypto/ccp/ccp_pmd_ops.c
++++ b/drivers/crypto/ccp/ccp_pmd_ops.c
+@@ -81,6 +81,174 @@ static const struct rte_cryptodev_capabilities ccp_pmd_capabilities[] = {
+ }, }
+ }, }
+ },
++ { /* SHA224 */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA224,
++ .block_size = 64,
++ .key_size = {
++ .min = 0,
++ .max = 0,
++ .increment = 0
++ },
++ .digest_size = {
++ .min = 28,
++ .max = 28,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA224 HMAC */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
++ .block_size = 64,
++ .key_size = {
++ .min = 1,
++ .max = 64,
++ .increment = 1
++ },
++ .digest_size = {
++ .min = 28,
++ .max = 28,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA256 */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA256,
++ .block_size = 64,
++ .key_size = {
++ .min = 0,
++ .max = 0,
++ .increment = 0
++ },
++ .digest_size = {
++ .min = 32,
++ .max = 32,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA256 HMAC */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
++ .block_size = 64,
++ .key_size = {
++ .min = 1,
++ .max = 64,
++ .increment = 1
++ },
++ .digest_size = {
++ .min = 32,
++ .max = 32,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA384 */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA384,
++ .block_size = 128,
++ .key_size = {
++ .min = 0,
++ .max = 0,
++ .increment = 0
++ },
++ .digest_size = {
++ .min = 48,
++ .max = 48,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA384 HMAC */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
++ .block_size = 128,
++ .key_size = {
++ .min = 1,
++ .max = 128,
++ .increment = 1
++ },
++ .digest_size = {
++ .min = 48,
++ .max = 48,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA512 */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA512,
++ .block_size = 128,
++ .key_size = {
++ .min = 0,
++ .max = 0,
++ .increment = 0
++ },
++ .digest_size = {
++ .min = 64,
++ .max = 64,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
++ { /* SHA512 HMAC */
++ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
++ {.sym = {
++ .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
++ {.auth = {
++ .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
++ .block_size = 128,
++ .key_size = {
++ .min = 1,
++ .max = 128,
++ .increment = 1
++ },
++ .digest_size = {
++ .min = 64,
++ .max = 64,
++ .increment = 0
++ },
++ .aad_size = { 0 }
++ }, }
++ }, }
++ },
+ { /*AES-CMAC */
+ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
+ {.sym = {
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-05-01 23:47:42 +0000