crypto/openssl: support DES-CBC

[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 ac032ee..0c822a4 100644 (file)
--- a/drivers/crypto/openssl/rte_openssl_pmd.c
+++ b/drivers/crypto/openssl/rte_openssl_pmd.c
@@ -327,6 +327,22 @@ openssl_set_session_cipher_parameters(struct openssl_session *sess,
 
                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;
 
@@ -339,6 +355,33 @@ openssl_set_session_cipher_parameters(struct openssl_session *sess,
                                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;
@@ -353,6 +396,23 @@ openssl_set_session_cipher_parameters(struct openssl_session *sess,
 
                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;
@@ -717,12 +777,11 @@ process_openssl_decryption_update(struct rte_mbuf *mbuf_src, int offset,
 /** Process standard openssl cipher encryption */
 static int
 process_openssl_cipher_encrypt(struct rte_mbuf *mbuf_src, uint8_t *dst,
-               int offset, uint8_t *iv, uint8_t *key, int srclen,
-               EVP_CIPHER_CTX *ctx, const EVP_CIPHER *algo)
+               int offset, uint8_t *iv, int srclen, EVP_CIPHER_CTX *ctx)
 {
        int totlen;
 
-       if (EVP_EncryptInit_ex(ctx, algo, NULL, key, iv) <= 0)
+       if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
                goto process_cipher_encrypt_err;
 
        EVP_CIPHER_CTX_set_padding(ctx, 0);
@@ -767,12 +826,11 @@ process_cipher_encrypt_err:
 /** Process standard openssl cipher decryption */
 static int
 process_openssl_cipher_decrypt(struct rte_mbuf *mbuf_src, uint8_t *dst,
-               int offset, uint8_t *iv, uint8_t *key, int srclen,
-               EVP_CIPHER_CTX *ctx, const EVP_CIPHER *algo)
+               int offset, uint8_t *iv, int srclen, EVP_CIPHER_CTX *ctx)
 {
        int totlen;
 
-       if (EVP_DecryptInit_ex(ctx, algo, NULL, key, iv) <= 0)
+       if (EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0)
                goto process_cipher_decrypt_err;
 
        EVP_CIPHER_CTX_set_padding(ctx, 0);
@@ -1145,15 +1203,11 @@ process_openssl_cipher_op
                if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
                        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);
+                                       srclen, sess->cipher.ctx);
                else
                        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);
+                                       srclen, sess->cipher.ctx);
        else
                status = process_openssl_cipher_des3ctr(mbuf_src, dst,
                                op->sym->cipher.data.offset, iv,
@@ -1197,8 +1251,7 @@ process_openssl_docsis_bpi_op(struct rte_crypto_op *op,
                        /* 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);
+                                       srclen, sess->cipher.ctx);
                        if (last_block_len) {
                                /* Point at last block */
                                dst += srclen;
@@ -1248,9 +1301,7 @@ process_openssl_docsis_bpi_op(struct rte_crypto_op *op,
                        /* 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);
+                                       srclen, sess->cipher.ctx);
                }
        }
 
@@ -1260,9 +1311,9 @@ process_openssl_docsis_bpi_op(struct rte_crypto_op *op,
 
 /** Process auth operation */
 static void
-process_openssl_auth_op
-               (struct rte_crypto_op *op, struct openssl_session *sess,
-               struct rte_mbuf *mbuf_src, struct rte_mbuf *mbuf_dst)
+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;
@@ -1270,8 +1321,7 @@ process_openssl_auth_op
        srclen = op->sym->auth.data.length;
 
        if (sess->auth.operation == RTE_CRYPTO_AUTH_OP_VERIFY)
-               dst = (uint8_t *)rte_pktmbuf_append(mbuf_src,
-                               sess->auth.digest_length);
+               dst = qp->temp_digest;
        else {
                dst = op->sym->auth.digest.data;
                if (dst == NULL)
@@ -1301,8 +1351,6 @@ process_openssl_auth_op
                                sess->auth.digest_length) != 0) {
                        op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
                }
-               /* Trim area used for digest from mbuf. */
-               rte_pktmbuf_trim(mbuf_src, sess->auth.digest_length);
        }
 
        if (status != 0)
@@ -1311,7 +1359,7 @@ process_openssl_auth_op
 
 /** Process crypto operation for mbuf */
 static int
-process_op(const struct openssl_qp *qp, struct rte_crypto_op *op,
+process_op(struct openssl_qp *qp, struct rte_crypto_op *op,
                struct openssl_session *sess)
 {
        struct rte_mbuf *msrc, *mdst;
@@ -1327,14 +1375,14 @@ process_op(const struct openssl_qp *qp, struct rte_crypto_op *op,
                process_openssl_cipher_op(op, sess, msrc, mdst);
                break;
        case OPENSSL_CHAIN_ONLY_AUTH:
-               process_openssl_auth_op(op, sess, msrc, mdst);
+               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(op, sess, mdst, mdst);
+               process_openssl_auth_op(qp, op, sess, mdst, mdst);
                break;
        case OPENSSL_CHAIN_AUTH_CIPHER:
-               process_openssl_auth_op(op, sess, msrc, mdst);
+               process_openssl_auth_op(qp, op, sess, msrc, mdst);
                process_openssl_cipher_op(op, sess, msrc, mdst);
                break;
        case OPENSSL_CHAIN_COMBINED:
@@ -1524,10 +1572,13 @@ static struct rte_vdev_driver cryptodev_openssl_pmd_drv = {
        .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(cryptodev_openssl_pmd_drv, cryptodev_driver_id);
+RTE_PMD_REGISTER_CRYPTO_DRIVER(openssl_crypto_drv, cryptodev_openssl_pmd_drv,
+               cryptodev_driver_id);