d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
6115b677bc
numam-dpdk/drivers/crypto/openssl/rte_openssl_pmd.c
Declan Doherty f2f020d210 cryptodev: break dependency on virtual device bus 
Removes any dependency of librte_cryptodev on the virtual device
infrastructure code and removes the functions which were virtual
device specific.

Updates all virtual PMDs to remove dependencies on rte_cryptodev_vdev.h
and replaces those calls with the new bus independent functions.

Due to these changes, the cryptodev ABI version gets bumped.

Signed-off-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Tested-by: Tomasz Duszynski <tdu@semihalf.com>
2017-10-25 18:11:01 +02:00

1766 lines
44 KiB
C
Raw Blame History

/*-
* BSD LICENSE
*
* Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <rte_common.h>
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include "rte_openssl_pmd_private.h"
#define DES_BLOCK_SIZE 8
static uint8_t cryptodev_driver_id;
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
static HMAC_CTX *HMAC_CTX_new(void)
{
HMAC_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));
if (ctx != NULL)
HMAC_CTX_init(ctx);
return ctx;
}
static void HMAC_CTX_free(HMAC_CTX *ctx)
{
if (ctx != NULL) {
HMAC_CTX_cleanup(ctx);
OPENSSL_free(ctx);
}
}
#endif
static int cryptodev_openssl_remove(struct rte_vdev_device *vdev);
/*----------------------------------------------------------------------------*/
/**
* Increment counter by 1
* Counter is 64 bit array, big-endian
*/
static void
ctr_inc(uint8_t *ctr)
{
uint64_t *ctr64 = (uint64_t *)ctr;
*ctr64 = __builtin_bswap64(*ctr64);
(*ctr64)++;
*ctr64 = __builtin_bswap64(*ctr64);
}
/*
*------------------------------------------------------------------------------
* Session Prepare
*------------------------------------------------------------------------------
*/
/** Get xform chain order */
static enum openssl_chain_order
openssl_get_chain_order(const struct rte_crypto_sym_xform *xform)
{
enum openssl_chain_order res = OPENSSL_CHAIN_NOT_SUPPORTED;
if (xform != NULL) {
if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH) {
if (xform->next == NULL)
res = OPENSSL_CHAIN_ONLY_AUTH;
else if (xform->next->type ==
RTE_CRYPTO_SYM_XFORM_CIPHER)
res = OPENSSL_CHAIN_AUTH_CIPHER;
}
if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER) {
if (xform->next == NULL)
res = OPENSSL_CHAIN_ONLY_CIPHER;
else if (xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH)
res = OPENSSL_CHAIN_CIPHER_AUTH;
}
if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD)
res = OPENSSL_CHAIN_COMBINED;
}
return res;
}
/** Get session cipher key from input cipher key */
static void
get_cipher_key(uint8_t *input_key, int keylen, uint8_t *session_key)
{
memcpy(session_key, input_key, keylen);
}
/** Get key ede 24 bytes standard from input key */
static int
get_cipher_key_ede(uint8_t *key, int keylen, uint8_t *key_ede)
{
int res = 0;
/* Initialize keys - 24 bytes: [key1-key2-key3] */
switch (keylen) {
case 24:
memcpy(key_ede, key, 24);
break;
case 16:
/* K3 = K1 */
memcpy(key_ede, key, 16);
memcpy(key_ede + 16, key, 8);
break;
case 8:
/* K1 = K2 = K3 (DES compatibility) */
memcpy(key_ede, key, 8);
memcpy(key_ede + 8, key, 8);
memcpy(key_ede + 16, key, 8);
break;
default:
OPENSSL_LOG_ERR("Unsupported key size");
res = -EINVAL;
}
return res;
}
/** Get adequate openssl function for input cipher algorithm */
static uint8_t
get_cipher_algo(enum rte_crypto_cipher_algorithm sess_algo, size_t keylen,
const EVP_CIPHER **algo)
{
int res = 0;
if (algo != NULL) {
switch (sess_algo) {
case RTE_CRYPTO_CIPHER_3DES_CBC:
switch (keylen) {
case 16:
*algo = EVP_des_ede_cbc();
break;
case 24:
*algo = EVP_des_ede3_cbc();
break;
default:
res = -EINVAL;
}
break;
case RTE_CRYPTO_CIPHER_3DES_CTR:
break;
case RTE_CRYPTO_CIPHER_AES_CBC:
switch (keylen) {
case 16:
*algo = EVP_aes_128_cbc();
break;
case 24:
*algo = EVP_aes_192_cbc();
break;
case 32:
*algo = EVP_aes_256_cbc();
break;
default:
res = -EINVAL;
}
break;
case RTE_CRYPTO_CIPHER_AES_CTR:
switch (keylen) {
case 16:
*algo = EVP_aes_128_ctr();
break;
case 24:
*algo = EVP_aes_192_ctr();
break;
case 32:
*algo = EVP_aes_256_ctr();
break;
default:
res = -EINVAL;
}
break;
default:
res = -EINVAL;
break;
}
} else {
res = -EINVAL;
}
return res;
}
/** Get adequate openssl function for input auth algorithm */
static uint8_t
get_auth_algo(enum rte_crypto_auth_algorithm sessalgo,
const EVP_MD **algo)
{
int res = 0;
if (algo != NULL) {
switch (sessalgo) {
case RTE_CRYPTO_AUTH_MD5:
case RTE_CRYPTO_AUTH_MD5_HMAC:
*algo = EVP_md5();
break;
case RTE_CRYPTO_AUTH_SHA1:
case RTE_CRYPTO_AUTH_SHA1_HMAC:
*algo = EVP_sha1();
break;
case RTE_CRYPTO_AUTH_SHA224:
case RTE_CRYPTO_AUTH_SHA224_HMAC:
*algo = EVP_sha224();
break;
case RTE_CRYPTO_AUTH_SHA256:
case RTE_CRYPTO_AUTH_SHA256_HMAC:
*algo = EVP_sha256();
break;
case RTE_CRYPTO_AUTH_SHA384:
case RTE_CRYPTO_AUTH_SHA384_HMAC:
*algo = EVP_sha384();
break;
case RTE_CRYPTO_AUTH_SHA512:
case RTE_CRYPTO_AUTH_SHA512_HMAC:
*algo = EVP_sha512();
break;
default:
res = -EINVAL;
break;
}
} else {
res = -EINVAL;
}
return res;
}
/** Get adequate openssl function for input cipher algorithm */
static uint8_t
get_aead_algo(enum rte_crypto_aead_algorithm sess_algo, size_t keylen,
const EVP_CIPHER **algo)
{
int res = 0;
if (algo != NULL) {
switch (sess_algo) {
case RTE_CRYPTO_AEAD_AES_GCM:
switch (keylen) {
case 16:
*algo = EVP_aes_128_gcm();
break;
case 24:
*algo = EVP_aes_192_gcm();
break;
case 32:
*algo = EVP_aes_256_gcm();
break;
default:
res = -EINVAL;
}
break;
case RTE_CRYPTO_AEAD_AES_CCM:
switch (keylen) {
case 16:
*algo = EVP_aes_128_ccm();
break;
case 24:
*algo = EVP_aes_192_ccm();
break;
case 32:
*algo = EVP_aes_256_ccm();
break;
default:
res = -EINVAL;
}
break;
default:
res = -EINVAL;
break;
}
} else {
res = -EINVAL;
}
return res;
}
/* Set session AEAD encryption parameters */
static int
openssl_set_sess_aead_enc_param(struct openssl_session *sess,
enum rte_crypto_aead_algorithm algo,
uint8_t tag_len, uint8_t *key)
{
int iv_type = 0;
unsigned int do_ccm;
sess->cipher.direction = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
sess->auth.operation = RTE_CRYPTO_AUTH_OP_GENERATE;
/* Select AEAD algo */
switch (algo) {
case RTE_CRYPTO_AEAD_AES_GCM:
iv_type = EVP_CTRL_GCM_SET_IVLEN;
if (tag_len != 16)
return -EINVAL;
do_ccm = 0;
break;
case RTE_CRYPTO_AEAD_AES_CCM:
iv_type = EVP_CTRL_CCM_SET_IVLEN;
/* Digest size can be 4, 6, 8, 10, 12, 14 or 16 bytes */
if (tag_len < 4 || tag_len > 16 || (tag_len & 1) == 1)
return -EINVAL;
do_ccm = 1;
break;
default:
return -ENOTSUP;
}
sess->cipher.mode = OPENSSL_CIPHER_LIB;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
if (get_aead_algo(algo, sess->cipher.key.length,
&sess->cipher.evp_algo) != 0)
return -EINVAL;
get_cipher_key(key, sess->cipher.key.length, sess->cipher.key.data);
sess->chain_order = OPENSSL_CHAIN_COMBINED;
if (EVP_EncryptInit_ex(sess->cipher.ctx, sess->cipher.evp_algo,
NULL, NULL, NULL) <= 0)
return -EINVAL;
if (EVP_CIPHER_CTX_ctrl(sess->cipher.ctx, iv_type, sess->iv.length,
NULL) <= 0)
return -EINVAL;
if (do_ccm)
EVP_CIPHER_CTX_ctrl(sess->cipher.ctx, EVP_CTRL_CCM_SET_TAG,
tag_len, NULL);
if (EVP_EncryptInit_ex(sess->cipher.ctx, NULL, NULL, key, NULL) <= 0)
return -EINVAL;
return 0;
}
/* Set session AEAD decryption parameters */
static int
openssl_set_sess_aead_dec_param(struct openssl_session *sess,
enum rte_crypto_aead_algorithm algo,
uint8_t tag_len, uint8_t *key)
{
int iv_type = 0;
unsigned int do_ccm = 0;
sess->cipher.direction = RTE_CRYPTO_CIPHER_OP_DECRYPT;
sess->auth.operation = RTE_CRYPTO_AUTH_OP_VERIFY;
/* Select AEAD algo */
switch (algo) {
case RTE_CRYPTO_AEAD_AES_GCM:
iv_type = EVP_CTRL_GCM_SET_IVLEN;
if (tag_len != 16)
return -EINVAL;
break;
case RTE_CRYPTO_AEAD_AES_CCM:
iv_type = EVP_CTRL_CCM_SET_IVLEN;
/* Digest size can be 4, 6, 8, 10, 12, 14 or 16 bytes */
if (tag_len < 4 || tag_len > 16 || (tag_len & 1) == 1)
return -EINVAL;
do_ccm = 1;
break;
default:
return -ENOTSUP;
}
sess->cipher.mode = OPENSSL_CIPHER_LIB;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
if (get_aead_algo(algo, sess->cipher.key.length,
&sess->cipher.evp_algo) != 0)
return -EINVAL;
get_cipher_key(key, sess->cipher.key.length, sess->cipher.key.data);
sess->chain_order = OPENSSL_CHAIN_COMBINED;
if (EVP_DecryptInit_ex(sess->cipher.ctx, sess->cipher.evp_algo,
NULL, NULL, NULL) <= 0)
return -EINVAL;
if (EVP_CIPHER_CTX_ctrl(sess->cipher.ctx, iv_type,
sess->iv.length, NULL) <= 0)
return -EINVAL;
if (do_ccm)
EVP_CIPHER_CTX_ctrl(sess->cipher.ctx, EVP_CTRL_CCM_SET_TAG,
tag_len, NULL);
if (EVP_DecryptInit_ex(sess->cipher.ctx, NULL, NULL, key, NULL) <= 0)
return -EINVAL;
return 0;
}
/** Set session cipher parameters */
static int
openssl_set_session_cipher_parameters(struct openssl_session *sess,
const struct rte_crypto_sym_xform *xform)
{
/* Select cipher direction */
sess->cipher.direction = xform->cipher.op;
/* Select cipher key */
sess->cipher.key.length = xform->cipher.key.length;
/* Set IV parameters */
sess->iv.offset = xform->cipher.iv.offset;
sess->iv.length = xform->cipher.iv.length;
/* Select cipher algo */
switch (xform->cipher.algo) {
case RTE_CRYPTO_CIPHER_3DES_CBC:
case RTE_CRYPTO_CIPHER_AES_CBC:
case RTE_CRYPTO_CIPHER_AES_CTR:
sess->cipher.mode = OPENSSL_CIPHER_LIB;
sess->cipher.algo = xform->cipher.algo;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
if (get_cipher_algo(sess->cipher.algo, sess->cipher.key.length,
&sess->cipher.evp_algo) != 0)
return -EINVAL;
get_cipher_key(xform->cipher.key.data, sess->cipher.key.length,
sess->cipher.key.data);
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
if (EVP_EncryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
} else if (sess->cipher.direction ==
RTE_CRYPTO_CIPHER_OP_DECRYPT) {
if (EVP_DecryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
}
break;
case RTE_CRYPTO_CIPHER_3DES_CTR:
sess->cipher.mode = OPENSSL_CIPHER_DES3CTR;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
if (get_cipher_key_ede(xform->cipher.key.data,
sess->cipher.key.length,
sess->cipher.key.data) != 0)
return -EINVAL;
break;
case RTE_CRYPTO_CIPHER_DES_CBC:
sess->cipher.algo = xform->cipher.algo;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
sess->cipher.evp_algo = EVP_des_cbc();
get_cipher_key(xform->cipher.key.data, sess->cipher.key.length,
sess->cipher.key.data);
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
if (EVP_EncryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
} else if (sess->cipher.direction ==
RTE_CRYPTO_CIPHER_OP_DECRYPT) {
if (EVP_DecryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
}
break;
case RTE_CRYPTO_CIPHER_DES_DOCSISBPI:
sess->cipher.algo = xform->cipher.algo;
sess->chain_order = OPENSSL_CHAIN_CIPHER_BPI;
sess->cipher.ctx = EVP_CIPHER_CTX_new();
sess->cipher.evp_algo = EVP_des_cbc();
sess->cipher.bpi_ctx = EVP_CIPHER_CTX_new();
/* IV will be ECB encrypted whether direction is encrypt or decrypt */
if (EVP_EncryptInit_ex(sess->cipher.bpi_ctx, EVP_des_ecb(),
NULL, xform->cipher.key.data, 0) != 1)
return -EINVAL;
get_cipher_key(xform->cipher.key.data, sess->cipher.key.length,
sess->cipher.key.data);
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
if (EVP_EncryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
} else if (sess->cipher.direction ==
RTE_CRYPTO_CIPHER_OP_DECRYPT) {
if (EVP_DecryptInit_ex(sess->cipher.ctx,
sess->cipher.evp_algo,
NULL, xform->cipher.key.data,
NULL) != 1) {
return -EINVAL;
}
}
break;
default:
sess->cipher.algo = RTE_CRYPTO_CIPHER_NULL;
return -ENOTSUP;
}
return 0;
}
/* Set session auth parameters */
static int
openssl_set_session_auth_parameters(struct openssl_session *sess,
const struct rte_crypto_sym_xform *xform)
{
/* Select auth generate/verify */
sess->auth.operation = xform->auth.op;
sess->auth.algo = xform->auth.algo;
sess->auth.digest_length = xform->auth.digest_length;
/* Select auth algo */
switch (xform->auth.algo) {
case RTE_CRYPTO_AUTH_AES_GMAC:
/*
* OpenSSL requires GMAC to be a GCM operation
* with no cipher data length
*/
sess->cipher.key.length = xform->auth.key.length;
/* Set IV parameters */
sess->iv.offset = xform->auth.iv.offset;
sess->iv.length = xform->auth.iv.length;
if (sess->auth.operation == RTE_CRYPTO_AUTH_OP_GENERATE)
return openssl_set_sess_aead_enc_param(sess,
RTE_CRYPTO_AEAD_AES_GCM,
xform->auth.digest_length,
xform->auth.key.data);
else
return openssl_set_sess_aead_dec_param(sess,
RTE_CRYPTO_AEAD_AES_GCM,
xform->auth.digest_length,
xform->auth.key.data);
break;
case RTE_CRYPTO_AUTH_MD5:
case RTE_CRYPTO_AUTH_SHA1:
case RTE_CRYPTO_AUTH_SHA224:
case RTE_CRYPTO_AUTH_SHA256:
case RTE_CRYPTO_AUTH_SHA384:
case RTE_CRYPTO_AUTH_SHA512:
sess->auth.mode = OPENSSL_AUTH_AS_AUTH;
if (get_auth_algo(xform->auth.algo,
&sess->auth.auth.evp_algo) != 0)
return -EINVAL;
sess->auth.auth.ctx = EVP_MD_CTX_create();
break;
case RTE_CRYPTO_AUTH_MD5_HMAC:
case RTE_CRYPTO_AUTH_SHA1_HMAC:
case RTE_CRYPTO_AUTH_SHA224_HMAC:
case RTE_CRYPTO_AUTH_SHA256_HMAC:
case RTE_CRYPTO_AUTH_SHA384_HMAC:
case RTE_CRYPTO_AUTH_SHA512_HMAC:
sess->auth.mode = OPENSSL_AUTH_AS_HMAC;
sess->auth.hmac.ctx = HMAC_CTX_new();
if (get_auth_algo(xform->auth.algo,
&sess->auth.hmac.evp_algo) != 0)
return -EINVAL;
if (HMAC_Init_ex(sess->auth.hmac.ctx,
xform->auth.key.data,
xform->auth.key.length,
sess->auth.hmac.evp_algo, NULL) != 1)
return -EINVAL;
break;
default:
return -ENOTSUP;
}
return 0;
}
/* Set session AEAD parameters */
static int
openssl_set_session_aead_parameters(struct openssl_session *sess,
const struct rte_crypto_sym_xform *xform)
{
/* Select cipher key */
sess->cipher.key.length = xform->aead.key.length;
/* Set IV parameters */
if (xform->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
/*
* For AES-CCM, the actual IV is placed
* one byte after the start of the IV field,
* according to the API.
*/
sess->iv.offset = xform->aead.iv.offset + 1;
else
sess->iv.offset = xform->aead.iv.offset;
sess->iv.length = xform->aead.iv.length;
sess->auth.aad_length = xform->aead.aad_length;
sess->auth.digest_length = xform->aead.digest_length;
sess->aead_algo = xform->aead.algo;
/* Select cipher direction */
if (xform->aead.op == RTE_CRYPTO_AEAD_OP_ENCRYPT)
return openssl_set_sess_aead_enc_param(sess, xform->aead.algo,
xform->aead.digest_length, xform->aead.key.data);
else
return openssl_set_sess_aead_dec_param(sess, xform->aead.algo,
xform->aead.digest_length, xform->aead.key.data);
}
/** Parse crypto xform chain and set private session parameters */
int
openssl_set_session_parameters(struct openssl_session *sess,
const struct rte_crypto_sym_xform *xform)
{
const struct rte_crypto_sym_xform *cipher_xform = NULL;
const struct rte_crypto_sym_xform *auth_xform = NULL;
const struct rte_crypto_sym_xform *aead_xform = NULL;
int ret;
sess->chain_order = openssl_get_chain_order(xform);
switch (sess->chain_order) {
case OPENSSL_CHAIN_ONLY_CIPHER:
cipher_xform = xform;
break;
case OPENSSL_CHAIN_ONLY_AUTH:
auth_xform = xform;
break;
case OPENSSL_CHAIN_CIPHER_AUTH:
cipher_xform = xform;
auth_xform = xform->next;
break;
case OPENSSL_CHAIN_AUTH_CIPHER:
auth_xform = xform;
cipher_xform = xform->next;
break;
case OPENSSL_CHAIN_COMBINED:
aead_xform = xform;
break;
default:
return -EINVAL;
}
/* Default IV length = 0 */
sess->iv.length = 0;
/* cipher_xform must be check before auth_xform */
if (cipher_xform) {
ret = openssl_set_session_cipher_parameters(
sess, cipher_xform);
if (ret != 0) {
OPENSSL_LOG_ERR(
"Invalid/unsupported cipher parameters");
return ret;
}
}
if (auth_xform) {
ret = openssl_set_session_auth_parameters(sess, auth_xform);
if (ret != 0) {
OPENSSL_LOG_ERR(
"Invalid/unsupported auth parameters");
return ret;
}
}
if (aead_xform) {
ret = openssl_set_session_aead_parameters(sess, aead_xform);
if (ret != 0) {
OPENSSL_LOG_ERR(
"Invalid/unsupported AEAD parameters");
return ret;
}
}
return 0;
}
/** Reset private session parameters */
void
openssl_reset_session(struct openssl_session *sess)
{
EVP_CIPHER_CTX_free(sess->cipher.ctx);
if (sess->chain_order == OPENSSL_CHAIN_CIPHER_BPI)
EVP_CIPHER_CTX_free(sess->cipher.bpi_ctx);
switch (sess->auth.mode) {
case OPENSSL_AUTH_AS_AUTH:
EVP_MD_CTX_destroy(sess->auth.auth.ctx);
break;
case OPENSSL_AUTH_AS_HMAC:
EVP_PKEY_free(sess->auth.hmac.pkey);
HMAC_CTX_free(sess->auth.hmac.ctx);
break;
default:
break;
}
}
/** Provide session for operation */
static struct openssl_session *
get_session(struct openssl_qp *qp, struct rte_crypto_op *op)
{
struct openssl_session *sess = NULL;
if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
/* get existing session */
if (likely(op->sym->session != NULL))
sess = (struct openssl_session *)
get_session_private_data(
op->sym->session,
cryptodev_driver_id);
} else {
/* provide internal session */
void *_sess = NULL;
void *_sess_private_data = NULL;
if (rte_mempool_get(qp->sess_mp, (void **)&_sess))
return NULL;
if (rte_mempool_get(qp->sess_mp, (void **)&_sess_private_data))
return NULL;
sess = (struct openssl_session *)_sess_private_data;
if (unlikely(openssl_set_session_parameters(sess,
op->sym->xform) != 0)) {
rte_mempool_put(qp->sess_mp, _sess);
rte_mempool_put(qp->sess_mp, _sess_private_data);
sess = NULL;
}
op->sym->session = (struct rte_cryptodev_sym_session *)_sess;
set_session_private_data(op->sym->session, cryptodev_driver_id,
_sess_private_data);
}
if (sess == NULL)
op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
return sess;
}
/*
*------------------------------------------------------------------------------
* Process Operations
*------------------------------------------------------------------------------
*/
static inline int
process_openssl_encryption_update(struct rte_mbuf *mbuf_src, int offset,
uint8_t **dst, int srclen, EVP_CIPHER_CTX *ctx)
{
struct rte_mbuf *m;
int dstlen;
int l, n = srclen;
uint8_t *src;
for (m = mbuf_src; m != NULL && offset > rte_pktmbuf_data_len(m);
m = m->next)
offset -= rte_pktmbuf_data_len(m);
if (m == 0)
return -1;
src = rte_pktmbuf_mtod_offset(m, uint8_t *, offset);
l = rte_pktmbuf_data_len(m) - offset;
if (srclen <= l) {
if (EVP_EncryptUpdate(ctx, *dst, &dstlen, src, srclen) <= 0)
return -1;
*dst += l;
return 0;
}
if (EVP_EncryptUpdate(ctx, *dst, &dstlen, src, l) <= 0)
return -1;
*dst += dstlen;
n -= l;
for (m = m->next; (m != NULL) && (n > 0); m = m->next) {
src = rte_pktmbuf_mtod(m, uint8_t *);
l = rte_pktmbuf_data_len(m) < n ? rte_pktmbuf_data_len(m) : n;
if (EVP_EncryptUpdate(ctx, *dst, &dstlen, src, l) <= 0)
return -1;
*dst += dstlen;
n -= l;
}
return 0;
}
static inline int
process_openssl_decryption_update(struct rte_mbuf *mbuf_src, int offset,
uint8_t **dst, int srclen, EVP_CIPHER_CTX *ctx)
{
struct rte_mbuf *m;
int dstlen;
int l, n = srclen;
uint8_t *src;
for (m = mbuf_src; m != NULL && offset > rte_pktmbuf_data_len(m);
m = m->next)
offset -= rte_pktmbuf_data_len(m);
if (m == 0)
return -1;
src = rte_pktmbuf_mtod_offset(m, uint8_t *, offset);
l = rte_pktmbuf_data_len(m) - offset;
if (srclen <= l) {
if (EVP_DecryptUpdate(ctx, *dst, &dstlen, src, srclen) <= 0)
return -1;
*dst += l;
return 0;
}
if (EVP_DecryptUpdate(ctx, *dst, &dstlen, src, l) <= 0)
return -1;
*dst += dstlen;
n -= l;
for (m = m->next; (m != NULL) && (n > 0); m = m->next) {
src = rte_pktmbuf_mtod(m, uint8_t *);
l = rte_pktmbuf_data_len(m) < n ? rte_pktmbuf_data_len(m) : n;
if (EVP_DecryptUpdate(ctx, *dst, &dstlen, src, l) <= 0)
return -1;
*dst += dstlen;
n -= l;
}
return 0;
}
/** Process standard openssl cipher encryption */
static int
process_openssl_cipher_encrypt(struct rte_mbuf *mbuf_src, uint8_t *dst,
int offset, uint8_t *iv, int srclen, EVP_CIPHER_CTX *ctx)
{
int totlen;
if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_cipher_encrypt_err;
EVP_CIPHER_CTX_set_padding(ctx, 0);
if (process_openssl_encryption_update(mbuf_src, offset, &dst,
srclen, ctx))
goto process_cipher_encrypt_err;
if (EVP_EncryptFinal_ex(ctx, dst, &totlen) <= 0)
goto process_cipher_encrypt_err;
return 0;
process_cipher_encrypt_err:
OPENSSL_LOG_ERR("Process openssl cipher encrypt failed");
return -EINVAL;
}
/** Process standard openssl cipher encryption */
static int
process_openssl_cipher_bpi_encrypt(uint8_t *src, uint8_t *dst,
uint8_t *iv, int srclen,
EVP_CIPHER_CTX *ctx)
{
uint8_t i;
uint8_t encrypted_iv[DES_BLOCK_SIZE];
int encrypted_ivlen;
if (EVP_EncryptUpdate(ctx, encrypted_iv, &encrypted_ivlen,
iv, DES_BLOCK_SIZE) <= 0)
goto process_cipher_encrypt_err;
for (i = 0; i < srclen; i++)
*(dst + i) = *(src + i) ^ (encrypted_iv[i]);
return 0;
process_cipher_encrypt_err:
OPENSSL_LOG_ERR("Process openssl cipher bpi encrypt failed");
return -EINVAL;
}
/** Process standard openssl cipher decryption */
static int
process_openssl_cipher_decrypt(struct rte_mbuf *mbuf_src, uint8_t *dst,
int offset, uint8_t *iv, int srclen, EVP_CIPHER_CTX *ctx)
{
int totlen;
if (EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_cipher_decrypt_err;
EVP_CIPHER_CTX_set_padding(ctx, 0);
if (process_openssl_decryption_update(mbuf_src, offset, &dst,
srclen, ctx))
goto process_cipher_decrypt_err;
if (EVP_DecryptFinal_ex(ctx, dst, &totlen) <= 0)
goto process_cipher_decrypt_err;
return 0;
process_cipher_decrypt_err:
OPENSSL_LOG_ERR("Process openssl cipher decrypt failed");
return -EINVAL;
}
/** Process cipher des 3 ctr encryption, decryption algorithm */
static int
process_openssl_cipher_des3ctr(struct rte_mbuf *mbuf_src, uint8_t *dst,
int offset, uint8_t *iv, uint8_t *key, int srclen,
EVP_CIPHER_CTX *ctx)
{
uint8_t ebuf[8], ctr[8];
int unused, n;
struct rte_mbuf *m;
uint8_t *src;
int l;
for (m = mbuf_src; m != NULL && offset > rte_pktmbuf_data_len(m);
m = m->next)
offset -= rte_pktmbuf_data_len(m);
if (m == 0)
goto process_cipher_des3ctr_err;
src = rte_pktmbuf_mtod_offset(m, uint8_t *, offset);
l = rte_pktmbuf_data_len(m) - offset;
/* We use 3DES encryption also for decryption.
* IV is not important for 3DES ecb
*/
if (EVP_EncryptInit_ex(ctx, EVP_des_ede3_ecb(), NULL, key, NULL) <= 0)
goto process_cipher_des3ctr_err;
memcpy(ctr, iv, 8);
for (n = 0; n < srclen; n++) {
if (n % 8 == 0) {
if (EVP_EncryptUpdate(ctx,
(unsigned char *)&ebuf, &unused,
(const unsigned char *)&ctr, 8) <= 0)
goto process_cipher_des3ctr_err;
ctr_inc(ctr);
}
dst[n] = *(src++) ^ ebuf[n % 8];
l--;
if (!l) {
m = m->next;
if (m) {
src = rte_pktmbuf_mtod(m, uint8_t *);
l = rte_pktmbuf_data_len(m);
}
}
}
return 0;
process_cipher_des3ctr_err:
OPENSSL_LOG_ERR("Process openssl cipher des 3 ede ctr failed");
return -EINVAL;
}
/** Process AES-GCM encrypt algorithm */
static int
process_openssl_auth_encryption_gcm(struct rte_mbuf *mbuf_src, int offset,
int srclen, uint8_t *aad, int aadlen, uint8_t *iv,
uint8_t *dst, uint8_t *tag, EVP_CIPHER_CTX *ctx)
{
int len = 0, unused = 0;
uint8_t empty[] = {};
if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_auth_encryption_gcm_err;
if (aadlen > 0)
if (EVP_EncryptUpdate(ctx, NULL, &len, aad, aadlen) <= 0)
goto process_auth_encryption_gcm_err;
if (srclen > 0)
if (process_openssl_encryption_update(mbuf_src, offset, &dst,
srclen, ctx))
goto process_auth_encryption_gcm_err;
/* Workaround open ssl bug in version less then 1.0.1f */
if (EVP_EncryptUpdate(ctx, empty, &unused, empty, 0) <= 0)
goto process_auth_encryption_gcm_err;
if (EVP_EncryptFinal_ex(ctx, dst, &len) <= 0)
goto process_auth_encryption_gcm_err;
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, tag) <= 0)
goto process_auth_encryption_gcm_err;
return 0;
process_auth_encryption_gcm_err:
OPENSSL_LOG_ERR("Process openssl auth encryption gcm failed");
return -EINVAL;
}
/** Process AES-CCM encrypt algorithm */
static int
process_openssl_auth_encryption_ccm(struct rte_mbuf *mbuf_src, int offset,
int srclen, uint8_t *aad, int aadlen, uint8_t *iv,
uint8_t *dst, uint8_t *tag, uint8_t taglen, EVP_CIPHER_CTX *ctx)
{
int len = 0;
if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_auth_encryption_ccm_err;
if (EVP_EncryptUpdate(ctx, NULL, &len, NULL, srclen) <= 0)
goto process_auth_encryption_ccm_err;
if (aadlen > 0)
/*
* For AES-CCM, the actual AAD is placed
* 18 bytes after the start of the AAD field,
* according to the API.
*/
if (EVP_EncryptUpdate(ctx, NULL, &len, aad + 18, aadlen) <= 0)
goto process_auth_encryption_ccm_err;
if (srclen > 0)
if (process_openssl_encryption_update(mbuf_src, offset, &dst,
srclen, ctx))
goto process_auth_encryption_ccm_err;
if (EVP_EncryptFinal_ex(ctx, dst, &len) <= 0)
goto process_auth_encryption_ccm_err;
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_GET_TAG, taglen, tag) <= 0)
goto process_auth_encryption_ccm_err;
return 0;
process_auth_encryption_ccm_err:
OPENSSL_LOG_ERR("Process openssl auth encryption ccm failed");
return -EINVAL;
}
/** Process AES-GCM decrypt algorithm */
static int
process_openssl_auth_decryption_gcm(struct rte_mbuf *mbuf_src, int offset,
int srclen, uint8_t *aad, int aadlen, uint8_t *iv,
uint8_t *dst, uint8_t *tag, EVP_CIPHER_CTX *ctx)
{
int len = 0, unused = 0;
uint8_t empty[] = {};
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, tag) <= 0)
goto process_auth_decryption_gcm_err;
if (EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_auth_decryption_gcm_err;
if (aadlen > 0)
if (EVP_DecryptUpdate(ctx, NULL, &len, aad, aadlen) <= 0)
goto process_auth_decryption_gcm_err;
if (srclen > 0)
if (process_openssl_decryption_update(mbuf_src, offset, &dst,
srclen, ctx))
goto process_auth_decryption_gcm_err;
/* Workaround open ssl bug in version less then 1.0.1f */
if (EVP_DecryptUpdate(ctx, empty, &unused, empty, 0) <= 0)
goto process_auth_decryption_gcm_err;
if (EVP_DecryptFinal_ex(ctx, dst, &len) <= 0)
return -EFAULT;
return 0;
process_auth_decryption_gcm_err:
OPENSSL_LOG_ERR("Process openssl auth decryption gcm failed");
return -EINVAL;
}
/** Process AES-CCM decrypt algorithm */
static int
process_openssl_auth_decryption_ccm(struct rte_mbuf *mbuf_src, int offset,
int srclen, uint8_t *aad, int aadlen, uint8_t *iv,
uint8_t *dst, uint8_t *tag, uint8_t tag_len,
EVP_CIPHER_CTX *ctx)
{
int len = 0;
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG, tag_len, tag) <= 0)
goto process_auth_decryption_ccm_err;
if (EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
goto process_auth_decryption_ccm_err;
if (EVP_DecryptUpdate(ctx, NULL, &len, NULL, srclen) <= 0)
goto process_auth_decryption_ccm_err;
if (aadlen > 0)
/*
* For AES-CCM, the actual AAD is placed
* 18 bytes after the start of the AAD field,
* according to the API.
*/
if (EVP_DecryptUpdate(ctx, NULL, &len, aad + 18, aadlen) <= 0)
goto process_auth_decryption_ccm_err;
if (srclen > 0)
if (process_openssl_decryption_update(mbuf_src, offset, &dst,
srclen, ctx))
return -EFAULT;
return 0;
process_auth_decryption_ccm_err:
OPENSSL_LOG_ERR("Process openssl auth decryption ccm failed");
return -EINVAL;
}
/** Process standard openssl auth algorithms */
static int
process_openssl_auth(struct rte_mbuf *mbuf_src, uint8_t *dst, int offset,
__rte_unused uint8_t *iv, __rte_unused EVP_PKEY * pkey,
int srclen, EVP_MD_CTX *ctx, const EVP_MD *algo)
{
size_t dstlen;
struct rte_mbuf *m;
int l, n = srclen;
uint8_t *src;
for (m = mbuf_src; m != NULL && offset > rte_pktmbuf_data_len(m);
m = m->next)
offset -= rte_pktmbuf_data_len(m);
if (m == 0)
goto process_auth_err;
if (EVP_DigestInit_ex(ctx, algo, NULL) <= 0)
goto process_auth_err;
src = rte_pktmbuf_mtod_offset(m, uint8_t *, offset);
l = rte_pktmbuf_data_len(m) - offset;
if (srclen <= l) {
if (EVP_DigestUpdate(ctx, (char *)src, srclen) <= 0)
goto process_auth_err;
goto process_auth_final;
}
if (EVP_DigestUpdate(ctx, (char *)src, l) <= 0)
goto process_auth_err;
n -= l;
for (m = m->next; (m != NULL) && (n > 0); m = m->next) {
src = rte_pktmbuf_mtod(m, uint8_t *);
l = rte_pktmbuf_data_len(m) < n ? rte_pktmbuf_data_len(m) : n;
if (EVP_DigestUpdate(ctx, (char *)src, l) <= 0)
goto process_auth_err;
n -= l;
}
process_auth_final:
if (EVP_DigestFinal_ex(ctx, dst, (unsigned int *)&dstlen) <= 0)
goto process_auth_err;
return 0;
process_auth_err:
OPENSSL_LOG_ERR("Process openssl auth failed");
return -EINVAL;
}
/** Process standard openssl auth algorithms with hmac */
static int
process_openssl_auth_hmac(struct rte_mbuf *mbuf_src, uint8_t *dst, int offset,
int srclen, HMAC_CTX *ctx)
{
unsigned int dstlen;
struct rte_mbuf *m;
int l, n = srclen;
uint8_t *src;
for (m = mbuf_src; m != NULL && offset > rte_pktmbuf_data_len(m);
m = m->next)
offset -= rte_pktmbuf_data_len(m);
if (m == 0)
goto process_auth_err;
src = rte_pktmbuf_mtod_offset(m, uint8_t *, offset);
l = rte_pktmbuf_data_len(m) - offset;
if (srclen <= l) {
if (HMAC_Update(ctx, (unsigned char *)src, srclen) != 1)
goto process_auth_err;
goto process_auth_final;
}
if (HMAC_Update(ctx, (unsigned char *)src, l) != 1)
goto process_auth_err;
n -= l;
for (m = m->next; (m != NULL) && (n > 0); m = m->next) {
src = rte_pktmbuf_mtod(m, uint8_t *);
l = rte_pktmbuf_data_len(m) < n ? rte_pktmbuf_data_len(m) : n;
if (HMAC_Update(ctx, (unsigned char *)src, l) != 1)
goto process_auth_err;
n -= l;
}
process_auth_final:
if (HMAC_Final(ctx, dst, &dstlen) != 1)
goto process_auth_err;
if (unlikely(HMAC_Init_ex(ctx, NULL, 0, NULL, NULL) != 1))
goto process_auth_err;
return 0;
process_auth_err:
OPENSSL_LOG_ERR("Process openssl auth failed");
return -EINVAL;
}
/*----------------------------------------------------------------------------*/
/** Process auth/cipher combined operation */
static void
process_openssl_combined_op
(struct rte_crypto_op *op, struct openssl_session *sess,
struct rte_mbuf *mbuf_src, struct rte_mbuf *mbuf_dst)
{
/* cipher */
uint8_t *dst = NULL, *iv, *tag, *aad;
int srclen, aadlen, status = -1;
uint32_t offset;
uint8_t taglen;
/*
* Segmented destination buffer is not supported for
* encryption/decryption
*/
if (!rte_pktmbuf_is_contiguous(mbuf_dst)) {
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
return;
}
iv = rte_crypto_op_ctod_offset(op, uint8_t *,
sess->iv.offset);
if (sess->auth.algo == RTE_CRYPTO_AUTH_AES_GMAC) {
srclen = 0;
offset = op->sym->auth.data.offset;
aadlen = op->sym->auth.data.length;
aad = rte_pktmbuf_mtod_offset(mbuf_src, uint8_t *,
op->sym->auth.data.offset);
tag = op->sym->auth.digest.data;
if (tag == NULL)
tag = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
offset + aadlen);
} else {
srclen = op->sym->aead.data.length;
dst = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
op->sym->aead.data.offset);
offset = op->sym->aead.data.offset;
aad = op->sym->aead.aad.data;
aadlen = sess->auth.aad_length;
tag = op->sym->aead.digest.data;
if (tag == NULL)
tag = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
offset + srclen);
}
taglen = sess->auth.digest_length;
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
if (sess->auth.algo == RTE_CRYPTO_AUTH_AES_GMAC ||
sess->aead_algo == RTE_CRYPTO_AEAD_AES_GCM)
status = process_openssl_auth_encryption_gcm(
mbuf_src, offset, srclen,
aad, aadlen, iv,
dst, tag, sess->cipher.ctx);
else
status = process_openssl_auth_encryption_ccm(
mbuf_src, offset, srclen,
aad, aadlen, iv,
dst, tag, taglen, sess->cipher.ctx);
} else {
if (sess->auth.algo == RTE_CRYPTO_AUTH_AES_GMAC ||
sess->aead_algo == RTE_CRYPTO_AEAD_AES_GCM)
status = process_openssl_auth_decryption_gcm(
mbuf_src, offset, srclen,
aad, aadlen, iv,
dst, tag, sess->cipher.ctx);
else
status = process_openssl_auth_decryption_ccm(
mbuf_src, offset, srclen,
aad, aadlen, iv,
dst, tag, taglen, sess->cipher.ctx);
}
if (status != 0) {
if (status == (-EFAULT) &&
sess->auth.operation ==
RTE_CRYPTO_AUTH_OP_VERIFY)
op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
else
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
}
}
/** Process cipher operation */
static void
process_openssl_cipher_op
(struct rte_crypto_op *op, struct openssl_session *sess,
struct rte_mbuf *mbuf_src, struct rte_mbuf *mbuf_dst)
{
uint8_t *dst, *iv;
int srclen, status;
/*
* Segmented destination buffer is not supported for
* encryption/decryption
*/
if (!rte_pktmbuf_is_contiguous(mbuf_dst)) {
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
return;
}
srclen = op->sym->cipher.data.length;
dst = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
op->sym->cipher.data.offset);
iv = rte_crypto_op_ctod_offset(op, uint8_t *,
sess->iv.offset);
if (sess->cipher.mode == OPENSSL_CIPHER_LIB)
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
status = process_openssl_cipher_encrypt(mbuf_src, dst,
op->sym->cipher.data.offset, iv,
srclen, sess->cipher.ctx);
else
status = process_openssl_cipher_decrypt(mbuf_src, dst,
op->sym->cipher.data.offset, iv,
srclen, sess->cipher.ctx);
else
status = process_openssl_cipher_des3ctr(mbuf_src, dst,
op->sym->cipher.data.offset, iv,
sess->cipher.key.data, srclen,
sess->cipher.ctx);
if (status != 0)
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
}
/** Process cipher operation */
static void
process_openssl_docsis_bpi_op(struct rte_crypto_op *op,
struct openssl_session *sess, struct rte_mbuf *mbuf_src,
struct rte_mbuf *mbuf_dst)
{
uint8_t *src, *dst, *iv;
uint8_t block_size, last_block_len;
int srclen, status = 0;
srclen = op->sym->cipher.data.length;
src = rte_pktmbuf_mtod_offset(mbuf_src, uint8_t *,
op->sym->cipher.data.offset);
dst = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
op->sym->cipher.data.offset);
iv = rte_crypto_op_ctod_offset(op, uint8_t *,
sess->iv.offset);
block_size = DES_BLOCK_SIZE;
last_block_len = srclen % block_size;
if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
/* Encrypt only with ECB mode XOR IV */
if (srclen < block_size) {
status = process_openssl_cipher_bpi_encrypt(src, dst,
iv, srclen,
sess->cipher.bpi_ctx);
} else {
srclen -= last_block_len;
/* Encrypt with the block aligned stream with CBC mode */
status = process_openssl_cipher_encrypt(mbuf_src, dst,
op->sym->cipher.data.offset, iv,
srclen, sess->cipher.ctx);
if (last_block_len) {
/* Point at last block */
dst += srclen;
/*
* IV is the last encrypted block from
* the previous operation
*/
iv = dst - block_size;
src += srclen;
srclen = last_block_len;
/* Encrypt the last frame with ECB mode */
status |= process_openssl_cipher_bpi_encrypt(src,
dst, iv,
srclen, sess->cipher.bpi_ctx);
}
}
} else {
/* Decrypt only with ECB mode (encrypt, as it is same operation) */
if (srclen < block_size) {
status = process_openssl_cipher_bpi_encrypt(src, dst,
iv,
srclen,
sess->cipher.bpi_ctx);
} else {
if (last_block_len) {
/* Point at last block */
dst += srclen - last_block_len;
src += srclen - last_block_len;
/*
* IV is the last full block
*/
iv = src - block_size;
/*
* Decrypt the last frame with ECB mode
* (encrypt, as it is the same operation)
*/
status = process_openssl_cipher_bpi_encrypt(src,
dst, iv,
last_block_len, sess->cipher.bpi_ctx);
/* Prepare parameters for CBC mode op */
iv = rte_crypto_op_ctod_offset(op, uint8_t *,
sess->iv.offset);
dst += last_block_len - srclen;
srclen -= last_block_len;
}
/* Decrypt with CBC mode */
status |= process_openssl_cipher_decrypt(mbuf_src, dst,
op->sym->cipher.data.offset, iv,
srclen, sess->cipher.ctx);
}
}
if (status != 0)
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
}
/** Process auth operation */
static void
process_openssl_auth_op(struct openssl_qp *qp, struct rte_crypto_op *op,
struct openssl_session *sess, struct rte_mbuf *mbuf_src,
struct rte_mbuf *mbuf_dst)
{
uint8_t *dst;
int srclen, status;
srclen = op->sym->auth.data.length;
if (sess->auth.operation == RTE_CRYPTO_AUTH_OP_VERIFY)
dst = qp->temp_digest;
else {
dst = op->sym->auth.digest.data;
if (dst == NULL)
dst = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *,
op->sym->auth.data.offset +
op->sym->auth.data.length);
}
switch (sess->auth.mode) {
case OPENSSL_AUTH_AS_AUTH:
status = process_openssl_auth(mbuf_src, dst,
op->sym->auth.data.offset, NULL, NULL, srclen,
sess->auth.auth.ctx, sess->auth.auth.evp_algo);
break;
case OPENSSL_AUTH_AS_HMAC:
status = process_openssl_auth_hmac(mbuf_src, dst,
op->sym->auth.data.offset, srclen,
sess->auth.hmac.ctx);
break;
default:
status = -1;
break;
}
if (sess->auth.operation == RTE_CRYPTO_AUTH_OP_VERIFY) {
if (memcmp(dst, op->sym->auth.digest.data,
sess->auth.digest_length) != 0) {
op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
}
}
if (status != 0)
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
}
/** Process crypto operation for mbuf */
static int
process_op(struct openssl_qp *qp, struct rte_crypto_op *op,
struct openssl_session *sess)
{
struct rte_mbuf *msrc, *mdst;
int retval;
msrc = op->sym->m_src;
mdst = op->sym->m_dst ? op->sym->m_dst : op->sym->m_src;
op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
switch (sess->chain_order) {
case OPENSSL_CHAIN_ONLY_CIPHER:
process_openssl_cipher_op(op, sess, msrc, mdst);
break;
case OPENSSL_CHAIN_ONLY_AUTH:
process_openssl_auth_op(qp, op, sess, msrc, mdst);
break;
case OPENSSL_CHAIN_CIPHER_AUTH:
process_openssl_cipher_op(op, sess, msrc, mdst);
process_openssl_auth_op(qp, op, sess, mdst, mdst);
break;
case OPENSSL_CHAIN_AUTH_CIPHER:
process_openssl_auth_op(qp, op, sess, msrc, mdst);
process_openssl_cipher_op(op, sess, msrc, mdst);
break;
case OPENSSL_CHAIN_COMBINED:
process_openssl_combined_op(op, sess, msrc, mdst);
break;
case OPENSSL_CHAIN_CIPHER_BPI:
process_openssl_docsis_bpi_op(op, sess, msrc, mdst);
break;
default:
op->status = RTE_CRYPTO_OP_STATUS_ERROR;
break;
}
/* Free session if a session-less crypto op */
if (op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
openssl_reset_session(sess);
memset(sess, 0, sizeof(struct openssl_session));
memset(op->sym->session, 0,
rte_cryptodev_get_header_session_size());
rte_mempool_put(qp->sess_mp, sess);
rte_mempool_put(qp->sess_mp, op->sym->session);
op->sym->session = NULL;
}
if (op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
if (op->status != RTE_CRYPTO_OP_STATUS_ERROR)
retval = rte_ring_enqueue(qp->processed_ops, (void *)op);
else
retval = -1;
return retval;
}
/*
*------------------------------------------------------------------------------
* PMD Framework
*------------------------------------------------------------------------------
*/
/** Enqueue burst */
static uint16_t
openssl_pmd_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops,
uint16_t nb_ops)
{
struct openssl_session *sess;
struct openssl_qp *qp = queue_pair;
int i, retval;
for (i = 0; i < nb_ops; i++) {
sess = get_session(qp, ops[i]);
if (unlikely(sess == NULL))
goto enqueue_err;
retval = process_op(qp, ops[i], sess);
if (unlikely(retval < 0))
goto enqueue_err;
}
qp->stats.enqueued_count += i;
return i;
enqueue_err:
qp->stats.enqueue_err_count++;
return i;
}
/** Dequeue burst */
static uint16_t
openssl_pmd_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops,
uint16_t nb_ops)
{
struct openssl_qp *qp = queue_pair;
unsigned int nb_dequeued = 0;
nb_dequeued = rte_ring_dequeue_burst(qp->processed_ops,
(void **)ops, nb_ops, NULL);
qp->stats.dequeued_count += nb_dequeued;
return nb_dequeued;
}
/** Create OPENSSL crypto device */
static int
cryptodev_openssl_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct openssl_private *internals;
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
OPENSSL_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
}
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_openssl_pmd_ops;
/* register rx/tx burst functions for data path */
dev->dequeue_burst = openssl_pmd_dequeue_burst;
dev->enqueue_burst = openssl_pmd_enqueue_burst;
dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
RTE_CRYPTODEV_FF_CPU_AESNI |
RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER;
/* Set vector instructions mode supported */
internals = dev->data->dev_private;
internals->max_nb_qpairs = init_params->max_nb_queue_pairs;
internals->max_nb_sessions = init_params->max_nb_sessions;
return 0;
init_error:
OPENSSL_LOG_ERR("driver %s: cryptodev_openssl_create failed",
init_params->name);
cryptodev_openssl_remove(vdev);
return -EFAULT;
}
/** Initialise OPENSSL crypto device */
static int
cryptodev_openssl_probe(struct rte_vdev_device *vdev)
{
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct openssl_private),
rte_socket_id(),
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_openssl_create(name, vdev, &init_params);
}
/** Uninitialise OPENSSL crypto device */
static int
cryptodev_openssl_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_openssl_pmd_drv = {
.probe = cryptodev_openssl_probe,
.remove = cryptodev_openssl_remove
};
static struct cryptodev_driver openssl_crypto_drv;
RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_OPENSSL_PMD,
cryptodev_openssl_pmd_drv);
RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_OPENSSL_PMD,
"max_nb_queue_pairs=<int> "
"max_nb_sessions=<int> "
"socket_id=<int>");
RTE_PMD_REGISTER_CRYPTO_DRIVER(openssl_crypto_drv, cryptodev_openssl_pmd_drv,
cryptodev_driver_id);
Reference in New Issue View Git Blame Copy Permalink