summaryrefslogtreecommitdiffstats
path: root/src/plugins/crypto_ipsecmb/ipsecmb.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/crypto_ipsecmb/ipsecmb.c')
-rw-r--r--src/plugins/crypto_ipsecmb/ipsecmb.c963
1 files changed, 0 insertions, 963 deletions
diff --git a/src/plugins/crypto_ipsecmb/ipsecmb.c b/src/plugins/crypto_ipsecmb/ipsecmb.c
deleted file mode 100644
index 064c129ba12..00000000000
--- a/src/plugins/crypto_ipsecmb/ipsecmb.c
+++ /dev/null
@@ -1,963 +0,0 @@
-/*
- * ipsecmb.c - Intel IPSec Multi-buffer library Crypto Engine
- *
- * Copyright (c) 2019 Cisco Systemss
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <fcntl.h>
-
-#include <intel-ipsec-mb.h>
-
-#include <vnet/vnet.h>
-#include <vnet/plugin/plugin.h>
-#include <vpp/app/version.h>
-#include <vnet/crypto/crypto.h>
-#include <vppinfra/cpu.h>
-
-#define HMAC_MAX_BLOCK_SIZE IMB_SHA_512_BLOCK_SIZE
-#define EXPANDED_KEY_N_BYTES (16 * 15)
-
-typedef struct
-{
- CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
- IMB_MGR *mgr;
-#if IMB_VERSION_NUM >= IMB_VERSION(1, 3, 0)
- IMB_JOB burst_jobs[IMB_MAX_BURST_SIZE];
-#endif
-} ipsecmb_per_thread_data_t;
-
-typedef struct
-{
- u16 data_size;
- u8 block_size;
- aes_gcm_pre_t aes_gcm_pre;
- keyexp_t keyexp;
- hash_one_block_t hash_one_block;
- hash_fn_t hash_fn;
-} ipsecmb_alg_data_t;
-
-typedef struct ipsecmb_main_t_
-{
- ipsecmb_per_thread_data_t *per_thread_data;
- ipsecmb_alg_data_t alg_data[VNET_CRYPTO_N_ALGS];
- void **key_data;
-} ipsecmb_main_t;
-
-typedef struct
-{
- u8 enc_key_exp[EXPANDED_KEY_N_BYTES];
- u8 dec_key_exp[EXPANDED_KEY_N_BYTES];
-} ipsecmb_aes_key_data_t;
-
-static ipsecmb_main_t ipsecmb_main = { };
-
-/* clang-format off */
-/*
- * (Alg, JOB_HASH_ALG, fn, block-size-bytes, hash-size-bytes, digest-size-bytes)
- */
-#define foreach_ipsecmb_hmac_op \
- _(SHA1, SHA_1, sha1, 64, 20, 20) \
- _(SHA224, SHA_224, sha224, 64, 32, 28) \
- _(SHA256, SHA_256, sha256, 64, 32, 32) \
- _(SHA384, SHA_384, sha384, 128, 64, 48) \
- _(SHA512, SHA_512, sha512, 128, 64, 64)
-
-/*
- * (Alg, key-len-bits, JOB_CIPHER_MODE)
- */
-#define foreach_ipsecmb_cipher_op \
- _ (AES_128_CBC, 128, CBC) \
- _ (AES_192_CBC, 192, CBC) \
- _ (AES_256_CBC, 256, CBC) \
- _ (AES_128_CTR, 128, CNTR) \
- _ (AES_192_CTR, 192, CNTR) \
- _ (AES_256_CTR, 256, CNTR)
-
-/*
- * (Alg, key-len-bytes, iv-len-bytes)
- */
-#define foreach_ipsecmb_gcm_cipher_op \
- _(AES_128_GCM, 128) \
- _(AES_192_GCM, 192) \
- _(AES_256_GCM, 256)
-/* clang-format on */
-static_always_inline vnet_crypto_op_status_t
-ipsecmb_status_job (IMB_STATUS status)
-{
- switch (status)
- {
- case IMB_STATUS_COMPLETED:
- return VNET_CRYPTO_OP_STATUS_COMPLETED;
- case IMB_STATUS_BEING_PROCESSED:
- case IMB_STATUS_COMPLETED_CIPHER:
- case IMB_STATUS_COMPLETED_AUTH:
- return VNET_CRYPTO_OP_STATUS_WORK_IN_PROGRESS;
- case IMB_STATUS_INVALID_ARGS:
- case IMB_STATUS_INTERNAL_ERROR:
- case IMB_STATUS_ERROR:
- return VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR;
- }
- ASSERT (0);
- return VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR;
-}
-
-always_inline void
-ipsecmb_retire_hmac_job (IMB_JOB *job, u32 *n_fail, u32 digest_size)
-{
- vnet_crypto_op_t *op = job->user_data;
- u32 len = op->digest_len ? op->digest_len : digest_size;
-
- if (PREDICT_FALSE (IMB_STATUS_COMPLETED != job->status))
- {
- op->status = ipsecmb_status_job (job->status);
- *n_fail = *n_fail + 1;
- return;
- }
-
- if (op->flags & VNET_CRYPTO_OP_FLAG_HMAC_CHECK)
- {
- if ((memcmp (op->digest, job->auth_tag_output, len)))
- {
- *n_fail = *n_fail + 1;
- op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
- return;
- }
- }
- else if (len == digest_size)
- clib_memcpy_fast (op->digest, job->auth_tag_output, digest_size);
- else
- clib_memcpy_fast (op->digest, job->auth_tag_output, len);
-
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
-}
-
-#if IMB_VERSION_NUM >= IMB_VERSION(1, 3, 0)
-static_always_inline u32
-ipsecmb_ops_hmac_inline (vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops,
- u32 block_size, u32 hash_size, u32 digest_size,
- IMB_HASH_ALG alg)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- IMB_JOB *job;
- u32 i, n_fail = 0, ops_index = 0;
- u8 scratch[n_ops][digest_size];
- const u32 burst_sz =
- (n_ops > IMB_MAX_BURST_SIZE) ? IMB_MAX_BURST_SIZE : n_ops;
-
- while (n_ops)
- {
- const u32 n = (n_ops > burst_sz) ? burst_sz : n_ops;
- /*
- * configure all the jobs first ...
- */
- for (i = 0; i < n; i++, ops_index++)
- {
- vnet_crypto_op_t *op = ops[ops_index];
- const u8 *kd = (u8 *) imbm->key_data[op->key_index];
-
- job = &ptd->burst_jobs[i];
-
- job->src = op->src;
- job->hash_start_src_offset_in_bytes = 0;
- job->msg_len_to_hash_in_bytes = op->len;
- job->auth_tag_output_len_in_bytes = digest_size;
- job->auth_tag_output = scratch[ops_index];
-
- job->u.HMAC._hashed_auth_key_xor_ipad = kd;
- job->u.HMAC._hashed_auth_key_xor_opad = kd + hash_size;
- job->user_data = op;
- }
-
- /*
- * submit all jobs to be processed and retire completed jobs
- */
- IMB_SUBMIT_HASH_BURST_NOCHECK (ptd->mgr, ptd->burst_jobs, n, alg);
-
- for (i = 0; i < n; i++)
- {
- job = &ptd->burst_jobs[i];
- ipsecmb_retire_hmac_job (job, &n_fail, digest_size);
- }
-
- n_ops -= n;
- }
-
- return ops_index - n_fail;
-}
-#else
-static_always_inline u32
-ipsecmb_ops_hmac_inline (vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops,
- u32 block_size, u32 hash_size, u32 digest_size,
- JOB_HASH_ALG alg)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- IMB_JOB *job;
- u32 i, n_fail = 0;
- u8 scratch[n_ops][digest_size];
-
- /*
- * queue all the jobs first ...
- */
- for (i = 0; i < n_ops; i++)
- {
- vnet_crypto_op_t *op = ops[i];
- u8 *kd = (u8 *) imbm->key_data[op->key_index];
-
- job = IMB_GET_NEXT_JOB (ptd->mgr);
-
- job->src = op->src;
- job->hash_start_src_offset_in_bytes = 0;
- job->msg_len_to_hash_in_bytes = op->len;
- job->hash_alg = alg;
- job->auth_tag_output_len_in_bytes = digest_size;
- job->auth_tag_output = scratch[i];
-
- job->cipher_mode = IMB_CIPHER_NULL;
- job->cipher_direction = IMB_DIR_DECRYPT;
- job->chain_order = IMB_ORDER_HASH_CIPHER;
-
- job->u.HMAC._hashed_auth_key_xor_ipad = kd;
- job->u.HMAC._hashed_auth_key_xor_opad = kd + hash_size;
- job->user_data = op;
-
- job = IMB_SUBMIT_JOB (ptd->mgr);
-
- if (job)
- ipsecmb_retire_hmac_job (job, &n_fail, digest_size);
- }
-
- while ((job = IMB_FLUSH_JOB (ptd->mgr)))
- ipsecmb_retire_hmac_job (job, &n_fail, digest_size);
-
- return n_ops - n_fail;
-}
-#endif
-
-/* clang-format off */
-#define _(a, b, c, d, e, f) \
-static_always_inline u32 \
-ipsecmb_ops_hmac_##a (vlib_main_t * vm, \
- vnet_crypto_op_t * ops[], \
- u32 n_ops) \
-{ return ipsecmb_ops_hmac_inline (vm, ops, n_ops, d, e, f, \
- IMB_AUTH_HMAC_##b); } \
-
-foreach_ipsecmb_hmac_op;
-#undef _
-/* clang-format on */
-
-always_inline void
-ipsecmb_retire_cipher_job (IMB_JOB *job, u32 *n_fail)
-{
- vnet_crypto_op_t *op = job->user_data;
-
- if (PREDICT_FALSE (IMB_STATUS_COMPLETED != job->status))
- {
- op->status = ipsecmb_status_job (job->status);
- *n_fail = *n_fail + 1;
- }
- else
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
-}
-
-#if IMB_VERSION_NUM >= IMB_VERSION(1, 3, 0)
-static_always_inline u32
-ipsecmb_ops_aes_cipher_inline (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- u32 n_ops, u32 key_len,
- IMB_CIPHER_DIRECTION direction,
- IMB_CIPHER_MODE cipher_mode)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- IMB_JOB *job;
- u32 i, n_fail = 0, ops_index = 0;
- const u32 burst_sz =
- (n_ops > IMB_MAX_BURST_SIZE) ? IMB_MAX_BURST_SIZE : n_ops;
-
- while (n_ops)
- {
- const u32 n = (n_ops > burst_sz) ? burst_sz : n_ops;
-
- for (i = 0; i < n; i++)
- {
- ipsecmb_aes_key_data_t *kd;
- vnet_crypto_op_t *op = ops[ops_index++];
- kd = (ipsecmb_aes_key_data_t *) imbm->key_data[op->key_index];
-
- job = &ptd->burst_jobs[i];
-
- job->src = op->src;
- job->dst = op->dst;
- job->msg_len_to_cipher_in_bytes = op->len;
- job->cipher_start_src_offset_in_bytes = 0;
-
- job->hash_alg = IMB_AUTH_NULL;
-
- job->enc_keys = kd->enc_key_exp;
- job->dec_keys = kd->dec_key_exp;
- job->iv = op->iv;
- job->iv_len_in_bytes = IMB_AES_BLOCK_SIZE;
-
- job->user_data = op;
- }
-
- IMB_SUBMIT_CIPHER_BURST_NOCHECK (ptd->mgr, ptd->burst_jobs, n,
- cipher_mode, direction, key_len / 8);
- for (i = 0; i < n; i++)
- {
- job = &ptd->burst_jobs[i];
- ipsecmb_retire_cipher_job (job, &n_fail);
- }
-
- n_ops -= n;
- }
-
- return ops_index - n_fail;
-}
-#else
-static_always_inline u32
-ipsecmb_ops_aes_cipher_inline (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- u32 n_ops, u32 key_len,
- JOB_CIPHER_DIRECTION direction,
- JOB_CIPHER_MODE cipher_mode)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- IMB_JOB *job;
- u32 i, n_fail = 0;
-
- for (i = 0; i < n_ops; i++)
- {
- ipsecmb_aes_key_data_t *kd;
- vnet_crypto_op_t *op = ops[i];
- kd = (ipsecmb_aes_key_data_t *) imbm->key_data[op->key_index];
-
- job = IMB_GET_NEXT_JOB (ptd->mgr);
-
- job->src = op->src;
- job->dst = op->dst;
- job->msg_len_to_cipher_in_bytes = op->len;
- job->cipher_start_src_offset_in_bytes = 0;
-
- job->hash_alg = IMB_AUTH_NULL;
- job->cipher_mode = cipher_mode;
- job->cipher_direction = direction;
- job->chain_order =
- (direction == IMB_DIR_ENCRYPT ? IMB_ORDER_CIPHER_HASH :
- IMB_ORDER_HASH_CIPHER);
-
- job->aes_key_len_in_bytes = key_len / 8;
- job->enc_keys = kd->enc_key_exp;
- job->dec_keys = kd->dec_key_exp;
- job->iv = op->iv;
- job->iv_len_in_bytes = IMB_AES_BLOCK_SIZE;
-
- job->user_data = op;
-
- job = IMB_SUBMIT_JOB (ptd->mgr);
-
- if (job)
- ipsecmb_retire_cipher_job (job, &n_fail);
- }
-
- while ((job = IMB_FLUSH_JOB (ptd->mgr)))
- ipsecmb_retire_cipher_job (job, &n_fail);
-
- return n_ops - n_fail;
-}
-#endif
-
-/* clang-format off */
-#define _(a, b, c) \
- static_always_inline u32 ipsecmb_ops_cipher_enc_##a ( \
- vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops) \
- { \
- return ipsecmb_ops_aes_cipher_inline ( \
- vm, ops, n_ops, b, IMB_DIR_ENCRYPT, IMB_CIPHER_##c); \
- } \
- \
- static_always_inline u32 ipsecmb_ops_cipher_dec_##a ( \
- vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops) \
- { \
- return ipsecmb_ops_aes_cipher_inline ( \
- vm, ops, n_ops, b, IMB_DIR_DECRYPT, IMB_CIPHER_##c); \
- }
-
-foreach_ipsecmb_cipher_op;
-#undef _
-
-#define _(a, b) \
-static_always_inline u32 \
-ipsecmb_ops_gcm_cipher_enc_##a##_chained (vlib_main_t * vm, \
- vnet_crypto_op_t * ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops) \
-{ \
- ipsecmb_main_t *imbm = &ipsecmb_main; \
- ipsecmb_per_thread_data_t *ptd = vec_elt_at_index (imbm->per_thread_data, \
- vm->thread_index); \
- IMB_MGR *m = ptd->mgr; \
- vnet_crypto_op_chunk_t *chp; \
- u32 i, j; \
- \
- for (i = 0; i < n_ops; i++) \
- { \
- struct gcm_key_data *kd; \
- struct gcm_context_data ctx; \
- vnet_crypto_op_t *op = ops[i]; \
- \
- kd = (struct gcm_key_data *) imbm->key_data[op->key_index]; \
- ASSERT (op->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS); \
- IMB_AES##b##_GCM_INIT(m, kd, &ctx, op->iv, op->aad, op->aad_len); \
- chp = chunks + op->chunk_index; \
- for (j = 0; j < op->n_chunks; j++) \
- { \
- IMB_AES##b##_GCM_ENC_UPDATE (m, kd, &ctx, chp->dst, chp->src, \
- chp->len); \
- chp += 1; \
- } \
- IMB_AES##b##_GCM_ENC_FINALIZE(m, kd, &ctx, op->tag, op->tag_len); \
- \
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED; \
- } \
- \
- return n_ops; \
-} \
- \
-static_always_inline u32 \
-ipsecmb_ops_gcm_cipher_enc_##a (vlib_main_t * vm, vnet_crypto_op_t * ops[], \
- u32 n_ops) \
-{ \
- ipsecmb_main_t *imbm = &ipsecmb_main; \
- ipsecmb_per_thread_data_t *ptd = vec_elt_at_index (imbm->per_thread_data, \
- vm->thread_index); \
- IMB_MGR *m = ptd->mgr; \
- u32 i; \
- \
- for (i = 0; i < n_ops; i++) \
- { \
- struct gcm_key_data *kd; \
- struct gcm_context_data ctx; \
- vnet_crypto_op_t *op = ops[i]; \
- \
- kd = (struct gcm_key_data *) imbm->key_data[op->key_index]; \
- IMB_AES##b##_GCM_ENC (m, kd, &ctx, op->dst, op->src, op->len, op->iv, \
- op->aad, op->aad_len, op->tag, op->tag_len); \
- \
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED; \
- } \
- \
- return n_ops; \
-} \
- \
-static_always_inline u32 \
-ipsecmb_ops_gcm_cipher_dec_##a##_chained (vlib_main_t * vm, \
- vnet_crypto_op_t * ops[], vnet_crypto_op_chunk_t *chunks, u32 n_ops) \
-{ \
- ipsecmb_main_t *imbm = &ipsecmb_main; \
- ipsecmb_per_thread_data_t *ptd = vec_elt_at_index (imbm->per_thread_data, \
- vm->thread_index); \
- IMB_MGR *m = ptd->mgr; \
- vnet_crypto_op_chunk_t *chp; \
- u32 i, j, n_failed = 0; \
- \
- for (i = 0; i < n_ops; i++) \
- { \
- struct gcm_key_data *kd; \
- struct gcm_context_data ctx; \
- vnet_crypto_op_t *op = ops[i]; \
- u8 scratch[64]; \
- \
- kd = (struct gcm_key_data *) imbm->key_data[op->key_index]; \
- ASSERT (op->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS); \
- IMB_AES##b##_GCM_INIT(m, kd, &ctx, op->iv, op->aad, op->aad_len); \
- chp = chunks + op->chunk_index; \
- for (j = 0; j < op->n_chunks; j++) \
- { \
- IMB_AES##b##_GCM_DEC_UPDATE (m, kd, &ctx, chp->dst, chp->src, \
- chp->len); \
- chp += 1; \
- } \
- IMB_AES##b##_GCM_DEC_FINALIZE(m, kd, &ctx, scratch, op->tag_len); \
- \
- if ((memcmp (op->tag, scratch, op->tag_len))) \
- { \
- op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC; \
- n_failed++; \
- } \
- else \
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED; \
- } \
- \
- return n_ops - n_failed; \
-} \
- \
-static_always_inline u32 \
-ipsecmb_ops_gcm_cipher_dec_##a (vlib_main_t * vm, vnet_crypto_op_t * ops[], \
- u32 n_ops) \
-{ \
- ipsecmb_main_t *imbm = &ipsecmb_main; \
- ipsecmb_per_thread_data_t *ptd = vec_elt_at_index (imbm->per_thread_data, \
- vm->thread_index); \
- IMB_MGR *m = ptd->mgr; \
- u32 i, n_failed = 0; \
- \
- for (i = 0; i < n_ops; i++) \
- { \
- struct gcm_key_data *kd; \
- struct gcm_context_data ctx; \
- vnet_crypto_op_t *op = ops[i]; \
- u8 scratch[64]; \
- \
- kd = (struct gcm_key_data *) imbm->key_data[op->key_index]; \
- IMB_AES##b##_GCM_DEC (m, kd, &ctx, op->dst, op->src, op->len, op->iv, \
- op->aad, op->aad_len, scratch, op->tag_len); \
- \
- if ((memcmp (op->tag, scratch, op->tag_len))) \
- { \
- op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC; \
- n_failed++; \
- } \
- else \
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED; \
- } \
- \
- return n_ops - n_failed; \
-}
-/* clang-format on */
-foreach_ipsecmb_gcm_cipher_op;
-#undef _
-
-#ifdef HAVE_IPSECMB_CHACHA_POLY
-always_inline void
-ipsecmb_retire_aead_job (IMB_JOB *job, u32 *n_fail)
-{
- vnet_crypto_op_t *op = job->user_data;
- u32 len = op->tag_len;
-
- if (PREDICT_FALSE (IMB_STATUS_COMPLETED != job->status))
- {
- op->status = ipsecmb_status_job (job->status);
- *n_fail = *n_fail + 1;
- return;
- }
-
- if (op->flags & VNET_CRYPTO_OP_FLAG_HMAC_CHECK)
- {
- if (memcmp (op->tag, job->auth_tag_output, len))
- {
- *n_fail = *n_fail + 1;
- op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
- return;
- }
- }
-
- clib_memcpy_fast (op->tag, job->auth_tag_output, len);
-
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
-}
-
-static_always_inline u32
-ipsecmb_ops_chacha_poly (vlib_main_t *vm, vnet_crypto_op_t *ops[], u32 n_ops,
- IMB_CIPHER_DIRECTION dir)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- struct IMB_JOB *job;
- IMB_MGR *m = ptd->mgr;
- u32 i, n_fail = 0, last_key_index = ~0;
- u8 scratch[VLIB_FRAME_SIZE][16];
- u8 *key = 0;
-
- for (i = 0; i < n_ops; i++)
- {
- vnet_crypto_op_t *op = ops[i];
-
- job = IMB_GET_NEXT_JOB (m);
- if (last_key_index != op->key_index)
- {
- vnet_crypto_key_t *kd = vnet_crypto_get_key (op->key_index);
-
- key = kd->data;
- last_key_index = op->key_index;
- }
-
- job->cipher_direction = dir;
- job->chain_order = IMB_ORDER_HASH_CIPHER;
- job->cipher_mode = IMB_CIPHER_CHACHA20_POLY1305;
- job->hash_alg = IMB_AUTH_CHACHA20_POLY1305;
- job->enc_keys = job->dec_keys = key;
- job->key_len_in_bytes = 32;
-
- job->u.CHACHA20_POLY1305.aad = op->aad;
- job->u.CHACHA20_POLY1305.aad_len_in_bytes = op->aad_len;
- job->src = op->src;
- job->dst = op->dst;
-
- job->iv = op->iv;
- job->iv_len_in_bytes = 12;
- job->msg_len_to_cipher_in_bytes = job->msg_len_to_hash_in_bytes =
- op->len;
- job->cipher_start_src_offset_in_bytes =
- job->hash_start_src_offset_in_bytes = 0;
-
- job->auth_tag_output = scratch[i];
- job->auth_tag_output_len_in_bytes = 16;
-
- job->user_data = op;
-
- job = IMB_SUBMIT_JOB_NOCHECK (ptd->mgr);
- if (job)
- ipsecmb_retire_aead_job (job, &n_fail);
-
- op++;
- }
-
- while ((job = IMB_FLUSH_JOB (ptd->mgr)))
- ipsecmb_retire_aead_job (job, &n_fail);
-
- return n_ops - n_fail;
-}
-
-static_always_inline u32
-ipsecmb_ops_chacha_poly_enc (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- u32 n_ops)
-{
- return ipsecmb_ops_chacha_poly (vm, ops, n_ops, IMB_DIR_ENCRYPT);
-}
-
-static_always_inline u32
-ipsecmb_ops_chacha_poly_dec (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- u32 n_ops)
-{
- return ipsecmb_ops_chacha_poly (vm, ops, n_ops, IMB_DIR_DECRYPT);
-}
-
-static_always_inline u32
-ipsecmb_ops_chacha_poly_chained (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- vnet_crypto_op_chunk_t *chunks, u32 n_ops,
- IMB_CIPHER_DIRECTION dir)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_per_thread_data_t *ptd =
- vec_elt_at_index (imbm->per_thread_data, vm->thread_index);
- IMB_MGR *m = ptd->mgr;
- u32 i, n_fail = 0, last_key_index = ~0;
- u8 *key = 0;
-
- if (dir == IMB_DIR_ENCRYPT)
- {
- for (i = 0; i < n_ops; i++)
- {
- vnet_crypto_op_t *op = ops[i];
- struct chacha20_poly1305_context_data ctx;
- vnet_crypto_op_chunk_t *chp;
- u32 j;
-
- ASSERT (op->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS);
-
- if (last_key_index != op->key_index)
- {
- vnet_crypto_key_t *kd = vnet_crypto_get_key (op->key_index);
-
- key = kd->data;
- last_key_index = op->key_index;
- }
-
- IMB_CHACHA20_POLY1305_INIT (m, key, &ctx, op->iv, op->aad,
- op->aad_len);
-
- chp = chunks + op->chunk_index;
- for (j = 0; j < op->n_chunks; j++)
- {
- IMB_CHACHA20_POLY1305_ENC_UPDATE (m, key, &ctx, chp->dst,
- chp->src, chp->len);
- chp += 1;
- }
-
- IMB_CHACHA20_POLY1305_ENC_FINALIZE (m, &ctx, op->tag, op->tag_len);
-
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
- }
- }
- else /* dir == IMB_DIR_DECRYPT */
- {
- for (i = 0; i < n_ops; i++)
- {
- vnet_crypto_op_t *op = ops[i];
- struct chacha20_poly1305_context_data ctx;
- vnet_crypto_op_chunk_t *chp;
- u8 scratch[16];
- u32 j;
-
- ASSERT (op->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS);
-
- if (last_key_index != op->key_index)
- {
- vnet_crypto_key_t *kd = vnet_crypto_get_key (op->key_index);
-
- key = kd->data;
- last_key_index = op->key_index;
- }
-
- IMB_CHACHA20_POLY1305_INIT (m, key, &ctx, op->iv, op->aad,
- op->aad_len);
-
- chp = chunks + op->chunk_index;
- for (j = 0; j < op->n_chunks; j++)
- {
- IMB_CHACHA20_POLY1305_DEC_UPDATE (m, key, &ctx, chp->dst,
- chp->src, chp->len);
- chp += 1;
- }
-
- IMB_CHACHA20_POLY1305_DEC_FINALIZE (m, &ctx, scratch, op->tag_len);
-
- if (memcmp (op->tag, scratch, op->tag_len))
- {
- n_fail = n_fail + 1;
- op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
- }
- else
- op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
- }
- }
-
- return n_ops - n_fail;
-}
-
-static_always_inline u32
-ipsec_mb_ops_chacha_poly_enc_chained (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- vnet_crypto_op_chunk_t *chunks,
- u32 n_ops)
-{
- return ipsecmb_ops_chacha_poly_chained (vm, ops, chunks, n_ops,
- IMB_DIR_ENCRYPT);
-}
-
-static_always_inline u32
-ipsec_mb_ops_chacha_poly_dec_chained (vlib_main_t *vm, vnet_crypto_op_t *ops[],
- vnet_crypto_op_chunk_t *chunks,
- u32 n_ops)
-{
- return ipsecmb_ops_chacha_poly_chained (vm, ops, chunks, n_ops,
- IMB_DIR_DECRYPT);
-}
-#endif
-
-static void
-crypto_ipsecmb_key_handler (vlib_main_t * vm, vnet_crypto_key_op_t kop,
- vnet_crypto_key_index_t idx)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- vnet_crypto_key_t *key = vnet_crypto_get_key (idx);
- ipsecmb_alg_data_t *ad = imbm->alg_data + key->alg;
- u32 i;
- void *kd;
-
- /** TODO: add linked alg support **/
- if (key->type == VNET_CRYPTO_KEY_TYPE_LINK)
- return;
-
- if (kop == VNET_CRYPTO_KEY_OP_DEL)
- {
- if (idx >= vec_len (imbm->key_data))
- return;
-
- if (imbm->key_data[idx] == 0)
- return;
-
- clib_mem_free_s (imbm->key_data[idx]);
- imbm->key_data[idx] = 0;
- return;
- }
-
- if (ad->data_size == 0)
- return;
-
- vec_validate_aligned (imbm->key_data, idx, CLIB_CACHE_LINE_BYTES);
-
- if (kop == VNET_CRYPTO_KEY_OP_MODIFY && imbm->key_data[idx])
- {
- clib_mem_free_s (imbm->key_data[idx]);
- }
-
- kd = imbm->key_data[idx] = clib_mem_alloc_aligned (ad->data_size,
- CLIB_CACHE_LINE_BYTES);
-
- /* AES CBC key expansion */
- if (ad->keyexp)
- {
- ad->keyexp (key->data, ((ipsecmb_aes_key_data_t *) kd)->enc_key_exp,
- ((ipsecmb_aes_key_data_t *) kd)->dec_key_exp);
- return;
- }
-
- /* AES GCM */
- if (ad->aes_gcm_pre)
- {
- ad->aes_gcm_pre (key->data, (struct gcm_key_data *) kd);
- return;
- }
-
- /* HMAC */
- if (ad->hash_one_block)
- {
- const int block_qw = HMAC_MAX_BLOCK_SIZE / sizeof (u64);
- u64 pad[block_qw], key_hash[block_qw];
-
- clib_memset_u8 (key_hash, 0, HMAC_MAX_BLOCK_SIZE);
- if (vec_len (key->data) <= ad->block_size)
- clib_memcpy_fast (key_hash, key->data, vec_len (key->data));
- else
- ad->hash_fn (key->data, vec_len (key->data), key_hash);
-
- for (i = 0; i < block_qw; i++)
- pad[i] = key_hash[i] ^ 0x3636363636363636;
- ad->hash_one_block (pad, kd);
-
- for (i = 0; i < block_qw; i++)
- pad[i] = key_hash[i] ^ 0x5c5c5c5c5c5c5c5c;
- ad->hash_one_block (pad, ((u8 *) kd) + (ad->data_size / 2));
-
- return;
- }
-}
-
-static clib_error_t *
-crypto_ipsecmb_init (vlib_main_t * vm)
-{
- ipsecmb_main_t *imbm = &ipsecmb_main;
- ipsecmb_alg_data_t *ad;
- ipsecmb_per_thread_data_t *ptd;
- vlib_thread_main_t *tm = vlib_get_thread_main ();
- IMB_MGR *m = 0;
- u32 eidx;
- u8 *name;
-
- if (!clib_cpu_supports_aes ())
- return 0;
-
- /*
- * A priority that is better than OpenSSL but worse than VPP natvie
- */
- name = format (0, "Intel(R) Multi-Buffer Crypto for IPsec Library %s%c",
- IMB_VERSION_STR, 0);
- eidx = vnet_crypto_register_engine (vm, "ipsecmb", 80, (char *) name);
-
- vec_validate_aligned (imbm->per_thread_data, tm->n_vlib_mains - 1,
- CLIB_CACHE_LINE_BYTES);
-
- vec_foreach (ptd, imbm->per_thread_data)
- {
- ptd->mgr = alloc_mb_mgr (0);
-#if IMB_VERSION_NUM >= IMB_VERSION(1, 3, 0)
- clib_memset_u8 (ptd->burst_jobs, 0,
- sizeof (IMB_JOB) * IMB_MAX_BURST_SIZE);
-#endif
- if (clib_cpu_supports_avx512f ())
- init_mb_mgr_avx512 (ptd->mgr);
- else if (clib_cpu_supports_avx2 () && clib_cpu_supports_bmi2 ())
- init_mb_mgr_avx2 (ptd->mgr);
- else
- init_mb_mgr_sse (ptd->mgr);
-
- if (ptd == imbm->per_thread_data)
- m = ptd->mgr;
- }
-
-#define _(a, b, c, d, e, f) \
- vnet_crypto_register_ops_handler (vm, eidx, VNET_CRYPTO_OP_##a##_HMAC, \
- ipsecmb_ops_hmac_##a); \
- ad = imbm->alg_data + VNET_CRYPTO_ALG_HMAC_##a; \
- ad->block_size = d; \
- ad->data_size = e * 2; \
- ad->hash_one_block = m-> c##_one_block; \
- ad->hash_fn = m-> c; \
-
- foreach_ipsecmb_hmac_op;
-#undef _
-#define _(a, b, c) \
- vnet_crypto_register_ops_handler (vm, eidx, VNET_CRYPTO_OP_##a##_ENC, \
- ipsecmb_ops_cipher_enc_##a); \
- vnet_crypto_register_ops_handler (vm, eidx, VNET_CRYPTO_OP_##a##_DEC, \
- ipsecmb_ops_cipher_dec_##a); \
- ad = imbm->alg_data + VNET_CRYPTO_ALG_##a; \
- ad->data_size = sizeof (ipsecmb_aes_key_data_t); \
- ad->keyexp = m->keyexp_##b;
-
- foreach_ipsecmb_cipher_op;
-#undef _
-#define _(a, b) \
- vnet_crypto_register_ops_handler (vm, eidx, VNET_CRYPTO_OP_##a##_ENC, \
- ipsecmb_ops_gcm_cipher_enc_##a); \
- vnet_crypto_register_ops_handler (vm, eidx, VNET_CRYPTO_OP_##a##_DEC, \
- ipsecmb_ops_gcm_cipher_dec_##a); \
- vnet_crypto_register_chained_ops_handler \
- (vm, eidx, VNET_CRYPTO_OP_##a##_ENC, \
- ipsecmb_ops_gcm_cipher_enc_##a##_chained); \
- vnet_crypto_register_chained_ops_handler \
- (vm, eidx, VNET_CRYPTO_OP_##a##_DEC, \
- ipsecmb_ops_gcm_cipher_dec_##a##_chained); \
- ad = imbm->alg_data + VNET_CRYPTO_ALG_##a; \
- ad->data_size = sizeof (struct gcm_key_data); \
- ad->aes_gcm_pre = m->gcm##b##_pre; \
-
- foreach_ipsecmb_gcm_cipher_op;
-#undef _
-
-#ifdef HAVE_IPSECMB_CHACHA_POLY
- vnet_crypto_register_ops_handler (vm, eidx,
- VNET_CRYPTO_OP_CHACHA20_POLY1305_ENC,
- ipsecmb_ops_chacha_poly_enc);
- vnet_crypto_register_ops_handler (vm, eidx,
- VNET_CRYPTO_OP_CHACHA20_POLY1305_DEC,
- ipsecmb_ops_chacha_poly_dec);
- vnet_crypto_register_chained_ops_handler (
- vm, eidx, VNET_CRYPTO_OP_CHACHA20_POLY1305_ENC,
- ipsec_mb_ops_chacha_poly_enc_chained);
- vnet_crypto_register_chained_ops_handler (
- vm, eidx, VNET_CRYPTO_OP_CHACHA20_POLY1305_DEC,
- ipsec_mb_ops_chacha_poly_dec_chained);
- ad = imbm->alg_data + VNET_CRYPTO_ALG_CHACHA20_POLY1305;
- ad->data_size = 0;
-#endif
-
- vnet_crypto_register_key_handler (vm, eidx, crypto_ipsecmb_key_handler);
- return (NULL);
-}
-
-VLIB_INIT_FUNCTION (crypto_ipsecmb_init) =
-{
- .runs_after = VLIB_INITS ("vnet_crypto_init"),
-};
-
-VLIB_PLUGIN_REGISTER () =
-{
- .version = VPP_BUILD_VER,
- .description = "Intel IPSEC Multi-buffer Crypto Engine",
-};
-
-/*
- * fd.io coding-style-patch-verification: ON
- *
- * Local Variables:
- * eval: (c-set-style "gnu")
- * End:
- */