crypto: akcipher - Add sync interface without SG lists

The only user of akcipher does not use SG lists.  Therefore forcing
users to use SG lists only results unnecessary overhead.  Add a new
interface that supports arbitrary kernel pointers.

For the time being the copy will be performed unconditionally.  But
this will go away once the underlying interface is updated.

Note also that only encryption and decryption is addressed by this
patch as sign/verify will go into a new interface (sig).

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/akcipher.c b/crypto/akcipher.c
index 7960ceb..2d10b58 100644 (file)
--- a/crypto/akcipher.c
+++ b/crypto/akcipher.c
@@ -10,6 +10,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/scatterlist.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/string.h>
@@ -17,6 +18,19 @@
 
 #include "internal.h"
 
+struct crypto_akcipher_sync_data {
+       struct crypto_akcipher *tfm;
+       const void *src;
+       void *dst;
+       unsigned int slen;
+       unsigned int dlen;
+
+       struct akcipher_request *req;
+       struct crypto_wait cwait;
+       struct scatterlist sg;
+       u8 *buf;
+};
+
 static int __maybe_unused crypto_akcipher_report(
        struct sk_buff *skb, struct crypto_alg *alg)
 {
@@ -186,5 +200,86 @@ int akcipher_register_instance(struct crypto_template *tmpl,
 }
 EXPORT_SYMBOL_GPL(akcipher_register_instance);
 
+static int crypto_akcipher_sync_prep(struct crypto_akcipher_sync_data *data)
+{
+       unsigned int reqsize = crypto_akcipher_reqsize(data->tfm);
+       unsigned int mlen = max(data->slen, data->dlen);
+       struct akcipher_request *req;
+       struct scatterlist *sg;
+       unsigned int len;
+       u8 *buf;
+
+       len = sizeof(*req) + reqsize + mlen;
+       if (len < mlen)
+               return -EOVERFLOW;
+
+       req = kzalloc(len, GFP_KERNEL);
+       if (!req)
+               return -ENOMEM;
+
+       data->req = req;
+
+       buf = (u8 *)(req + 1) + reqsize;
+       data->buf = buf;
+       memcpy(buf, data->src, data->slen);
+
+       sg = &data->sg;
+       sg_init_one(sg, buf, mlen);
+       akcipher_request_set_crypt(req, sg, sg, data->slen, data->dlen);
+
+       crypto_init_wait(&data->cwait);
+       akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
+                                     crypto_req_done, &data->cwait);
+
+       return 0;
+}
+
+static int crypto_akcipher_sync_post(struct crypto_akcipher_sync_data *data,
+                                    int err)
+{
+       err = crypto_wait_req(err, &data->cwait);
+       memcpy(data->dst, data->buf, data->dlen);
+       data->dlen = data->req->dst_len;
+       kfree_sensitive(data->req);
+       return err;
+}
+
+int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,
+                                const void *src, unsigned int slen,
+                                void *dst, unsigned int dlen)
+{
+       struct crypto_akcipher_sync_data data = {
+               .tfm = tfm,
+               .src = src,
+               .dst = dst,
+               .slen = slen,
+               .dlen = dlen,
+       };
+
+       return crypto_akcipher_sync_prep(&data) ?:
+              crypto_akcipher_sync_post(&data,
+                                        crypto_akcipher_encrypt(data.req));
+}
+EXPORT_SYMBOL_GPL(crypto_akcipher_sync_encrypt);
+
+int crypto_akcipher_sync_decrypt(struct crypto_akcipher *tfm,
+                                const void *src, unsigned int slen,
+                                void *dst, unsigned int dlen)
+{
+       struct crypto_akcipher_sync_data data = {
+               .tfm = tfm,
+               .src = src,
+               .dst = dst,
+               .slen = slen,
+               .dlen = dlen,
+       };
+
+       return crypto_akcipher_sync_prep(&data) ?:
+              crypto_akcipher_sync_post(&data,
+                                        crypto_akcipher_decrypt(data.req)) ?:
+              data.dlen;
+}
+EXPORT_SYMBOL_GPL(crypto_akcipher_sync_decrypt);
+
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Generic public key cipher type");

diff --git a/include/crypto/akcipher.h b/include/crypto/akcipher.h
index f35fd65..670508f 100644 (file)
--- a/include/crypto/akcipher.h
+++ b/include/crypto/akcipher.h
@@ -374,6 +374,42 @@ static inline int crypto_akcipher_decrypt(struct akcipher_request *req)
 }
 
 /**
+ * crypto_akcipher_sync_encrypt() - Invoke public key encrypt operation
+ *
+ * Function invokes the specific public key encrypt operation for a given
+ * public key algorithm
+ *
+ * @tfm:       AKCIPHER tfm handle allocated with crypto_alloc_akcipher()
+ * @src:       source buffer
+ * @slen:      source length
+ * @dst:       destinatino obuffer
+ * @dlen:      destination length
+ *
+ * Return: zero on success; error code in case of error
+ */
+int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,
+                                const void *src, unsigned int slen,
+                                void *dst, unsigned int dlen);
+
+/**
+ * crypto_akcipher_sync_decrypt() - Invoke public key decrypt operation
+ *
+ * Function invokes the specific public key decrypt operation for a given
+ * public key algorithm
+ *
+ * @tfm:       AKCIPHER tfm handle allocated with crypto_alloc_akcipher()
+ * @src:       source buffer
+ * @slen:      source length
+ * @dst:       destinatino obuffer
+ * @dlen:      destination length
+ *
+ * Return: Output length on success; error code in case of error
+ */
+int crypto_akcipher_sync_decrypt(struct crypto_akcipher *tfm,
+                                const void *src, unsigned int slen,
+                                void *dst, unsigned int dlen);
+
+/**
  * crypto_akcipher_sign() - Invoke public key sign operation
  *
  * Function invokes the specific public key sign operation for a given