crypto/openssl: support DES DOCSIS BPI

[dpdk.git] / drivers / crypto / openssl / rte_openssl_pmd.c

diff --git a/drivers/crypto/openssl/rte_openssl_pmd.c b/drivers/crypto/openssl/rte_openssl_pmd.c
index 09173b2..5046eac 100644 (file)
--- a/drivers/crypto/openssl/rte_openssl_pmd.c
+++ b/drivers/crypto/openssl/rte_openssl_pmd.c
@@ -42,6 +42,8 @@
 
 #include "rte_openssl_pmd_private.h"
 
+#define DES_BLOCK_SIZE 8
+
 static int cryptodev_openssl_remove(const char *name);
 
 /*----------------------------------------------------------------------------*/
@@ -289,7 +291,21 @@ openssl_set_session_cipher_parameters(struct openssl_session *sess,
                                sess->cipher.key.data) != 0)
                        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);
+               break;
        default:
                sess->cipher.algo = RTE_CRYPTO_CIPHER_NULL;
                return -EINVAL;
@@ -407,6 +423,9 @@ 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);
@@ -577,6 +596,29 @@ process_cipher_encrypt_err:
        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,
@@ -969,6 +1011,98 @@ process_openssl_cipher_op
                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 = op->sym->cipher.iv.data;
+
+       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,
+                                       sess->cipher.key.data, srclen,
+                                       sess->cipher.ctx, sess->cipher.evp_algo);
+                       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 = op->sym->cipher.iv.data;
+                               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,
+                                       sess->cipher.key.data, srclen,
+                                       sess->cipher.ctx,
+                                       sess->cipher.evp_algo);
+               }
+       }
+
+       if (status != 0)
+               op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+}
+
 /** Process auth operation */
 static void
 process_openssl_auth_op
@@ -1052,6 +1186,9 @@ process_op(const struct openssl_qp *qp, struct rte_crypto_op *op,
        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;