Merge git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf

[firefly-linux-kernel-4.4.55.git] / include / crypto / akcipher.h

diff --git a/include/crypto/akcipher.h b/include/crypto/akcipher.h
index 69d163e39101bf46d6aae184d18e1938e109044c..45cd5b328040798a540dbda716b80c4d9a55a71d 100644 (file)
--- a/include/crypto/akcipher.h
+++ b/include/crypto/akcipher.h
@@ -18,21 +18,21 @@
  * struct akcipher_request - public key request
  *
  * @base:      Common attributes for async crypto requests
- * @src:       Pointer to memory containing the input parameters
- *             The format of the parameter(s) is expeted to be Octet String
- * @dst:       Pointer to memory whare the result will be stored
- * @src_len:   Size of the input parameter
+ * @src:       Source data
+ * @dst:       Destination data
+ * @src_len:   Size of the input buffer
  * @dst_len:   Size of the output buffer. It needs to be at leaset
  *             as big as the expected result depending on the operation
  *             After operation it will be updated with the acctual size of the
- *             result. In case of error, where the dst_len was insufficient,
+ *             result.
+ *             In case of error where the dst sgl size was insufficient,
  *             it will be updated to the size required for the operation.
  * @__ctx:     Start of private context data
  */
 struct akcipher_request {
        struct crypto_async_request base;
-       void *src;
-       void *dst;
+       struct scatterlist *src;
+       struct scatterlist *dst;
        unsigned int src_len;
        unsigned int dst_len;
        void *__ctx[] CRYPTO_MINALIGN_ATTR;
@@ -67,8 +67,13 @@ struct crypto_akcipher {
  *             algorithm. In case of error, where the dst_len was insufficient,
  *             the req->dst_len will be updated to the size required for the
  *             operation
- * @setkey:    Function invokes the algorithm specific set key function, which
- *             knows how to decode and interpret the BER encoded key
+ * @set_pub_key: Function invokes the algorithm specific set public key
+ *             function, which knows how to decode and interpret
+ *             the BER encoded public key
+ * @set_priv_key: Function invokes the algorithm specific set private key
+ *             function, which knows how to decode and interpret
+ *             the BER encoded private key
+ * @max_size:  Function returns dest buffer size reqired for a given key.
  * @init:      Initialize the cryptographic transformation object.
  *             This function is used to initialize the cryptographic
  *             transformation object. This function is called only once at
@@ -89,8 +94,11 @@ struct akcipher_alg {
        int (*verify)(struct akcipher_request *req);
        int (*encrypt)(struct akcipher_request *req);
        int (*decrypt)(struct akcipher_request *req);
-       int (*setkey)(struct crypto_akcipher *tfm, const void *key,
-                     unsigned int keylen);
+       int (*set_pub_key)(struct crypto_akcipher *tfm, const void *key,
+                          unsigned int keylen);
+       int (*set_priv_key)(struct crypto_akcipher *tfm, const void *key,
+                           unsigned int keylen);
+       int (*max_size)(struct crypto_akcipher *tfm);
        int (*init)(struct crypto_akcipher *tfm);
        void (*exit)(struct crypto_akcipher *tfm);
 
@@ -229,14 +237,14 @@ static inline void akcipher_request_set_callback(struct akcipher_request *req,
  * Sets parameters required by crypto operation
  *
  * @req:       public key request
- * @src:       ptr to input parameter
- * @dst:       ptr of output parameter
- * @src_len:   size of the input buffer
- * @dst_len:   size of the output buffer. It will be updated by the
- *             implementation to reflect the acctual size of the result
+ * @src:       ptr to input scatter list
+ * @dst:       ptr to output scatter list
+ * @src_len:   size of the src input scatter list to be processed
+ * @dst_len:   size of the dst output scatter list
  */
 static inline void akcipher_request_set_crypt(struct akcipher_request *req,
-                                             void *src, void *dst,
+                                             struct scatterlist *src,
+                                             struct scatterlist *dst,
                                              unsigned int src_len,
                                              unsigned int dst_len)
 {
@@ -246,6 +254,22 @@ static inline void akcipher_request_set_crypt(struct akcipher_request *req,
        req->dst_len = dst_len;
 }
 
+/**
+ * crypto_akcipher_maxsize() -- Get len for output buffer
+ *
+ * Function returns the dest buffer size required for a given key
+ *
+ * @tfm:       AKCIPHER tfm handle allocated with crypto_alloc_akcipher()
+ *
+ * Return: minimum len for output buffer or error code in key hasn't been set
+ */
+static inline int crypto_akcipher_maxsize(struct crypto_akcipher *tfm)
+{
+       struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+
+       return alg->max_size(tfm);
+}
+
 /**
  * crypto_akcipher_encrypt() -- Invoke public key encrypt operation
  *
@@ -319,22 +343,44 @@ static inline int crypto_akcipher_verify(struct akcipher_request *req)
 }
 
 /**
- * crypto_akcipher_setkey() -- Invoke public key setkey operation
+ * crypto_akcipher_set_pub_key() -- Invoke set public key operation
+ *
+ * Function invokes the algorithm specific set key function, which knows
+ * how to decode and interpret the encoded key
+ *
+ * @tfm:       tfm handle
+ * @key:       BER encoded public key
+ * @keylen:    length of the key
+ *
+ * Return: zero on success; error code in case of error
+ */
+static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm,
+                                             const void *key,
+                                             unsigned int keylen)
+{
+       struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+
+       return alg->set_pub_key(tfm, key, keylen);
+}
+
+/**
+ * crypto_akcipher_set_priv_key() -- Invoke set private key operation
  *
  * Function invokes the algorithm specific set key function, which knows
  * how to decode and interpret the encoded key
  *
  * @tfm:       tfm handle
- * @key:       BER encoded private or public key
+ * @key:       BER encoded private key
  * @keylen:    length of the key
  *
  * Return: zero on success; error code in case of error
  */
-static inline int crypto_akcipher_setkey(struct crypto_akcipher *tfm, void *key,
-                                        unsigned int keylen)
+static inline int crypto_akcipher_set_priv_key(struct crypto_akcipher *tfm,
+                                              const void *key,
+                                              unsigned int keylen)
 {
        struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
 
-       return alg->setkey(tfm, key, keylen);
+       return alg->set_priv_key(tfm, key, keylen);
 }
 #endif