1 files changed, 183 insertions, 4 deletions

diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c
index ccd0ac8fa9a0..b9e5120559d4 100644
--- a/security/integrity/ima/ima_crypto.c
+++ b/security/integrity/ima/ima_crypto.c
@@ -16,6 +16,8 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
+#include <linux/moduleparam.h>
+#include <linux/ratelimit.h>
 #include <linux/file.h>
 #include <linux/crypto.h>
 #include <linux/scatterlist.h>
@@ -25,7 +27,18 @@
 #include <crypto/hash_info.h>
 #include "ima.h"
 
+struct ahash_completion {
+        struct completion completion;
+        int err;
+};
+
+/* minimum file size for ahash use */
+static unsigned long ima_ahash_minsize;
+module_param_named(ahash_minsize, ima_ahash_minsize, ulong, 0644);
+MODULE_PARM_DESC(ahash_minsize, "Minimum file size for ahash use");
+
 static struct crypto_shash *ima_shash_tfm;
+static struct crypto_ahash *ima_ahash_tfm;
 
 /**
  * ima_kernel_read - read file content
@@ -93,9 +106,146 @@ static void ima_free_tfm(struct crypto_shash *tfm)
                 crypto_free_shash(tfm);
 }
 
-/*
- * Calculate the MD5/SHA1 file digest
- */
+static struct crypto_ahash *ima_alloc_atfm(enum hash_algo algo)
+{
+        struct crypto_ahash *tfm = ima_ahash_tfm;
+        int rc;
+
+        if ((algo != ima_hash_algo && algo < HASH_ALGO__LAST) || !tfm) {
+                tfm = crypto_alloc_ahash(hash_algo_name[algo], 0, 0);
+                if (!IS_ERR(tfm)) {
+                        if (algo == ima_hash_algo)
+                                ima_ahash_tfm = tfm;
+                } else {
+                        rc = PTR_ERR(tfm);
+                        pr_err("Can not allocate %s (reason: %d)\n",
+                               hash_algo_name[algo], rc);
+                }
+        }
+        return tfm;
+}
+
+static void ima_free_atfm(struct crypto_ahash *tfm)
+{
+        if (tfm != ima_ahash_tfm)
+                crypto_free_ahash(tfm);
+}
+
+static void ahash_complete(struct crypto_async_request *req, int err)
+{
+        struct ahash_completion *res = req->data;
+
+        if (err == -EINPROGRESS)
+                return;
+        res->err = err;
+        complete(&res->completion);
+}
+
+static int ahash_wait(int err, struct ahash_completion *res)
+{
+        switch (err) {
+        case 0:
+                break;
+        case -EINPROGRESS:
+        case -EBUSY:
+                wait_for_completion(&res->completion);
+                reinit_completion(&res->completion);
+                err = res->err;
+                /* fall through */
+        default:
+                pr_crit_ratelimited("ahash calculation failed: err: %d\n", err);
+        }
+
+        return err;
+}
+
+static int ima_calc_file_hash_atfm(struct file *file,
+                                   struct ima_digest_data *hash,
+                                   struct crypto_ahash *tfm)
+{
+        loff_t i_size, offset;
+        char *rbuf;
+        int rc, read = 0, rbuf_len;
+        struct ahash_request *req;
+        struct scatterlist sg[1];
+        struct ahash_completion res;
+
+        hash->length = crypto_ahash_digestsize(tfm);
+
+        req = ahash_request_alloc(tfm, GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        init_completion(&res.completion);
+        ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
+                                   CRYPTO_TFM_REQ_MAY_SLEEP,
+                                   ahash_complete, &res);
+
+        rc = ahash_wait(crypto_ahash_init(req), &res);
+        if (rc)
+                goto out1;
+
+        i_size = i_size_read(file_inode(file));
+
+        if (i_size == 0)
+                goto out2;
+
+        rbuf = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!rbuf) {
+                rc = -ENOMEM;
+                goto out1;
+        }
+
+        if (!(file->f_mode & FMODE_READ)) {
+                file->f_mode |= FMODE_READ;
+                read = 1;
+        }
+
+        for (offset = 0; offset < i_size; offset += rbuf_len) {
+                rbuf_len = ima_kernel_read(file, offset, rbuf, PAGE_SIZE);
+                if (rbuf_len < 0) {
+                        rc = rbuf_len;
+                        break;
+                }
+                if (rbuf_len == 0)
+                        break;
+
+                sg_init_one(&sg[0], rbuf, rbuf_len);
+                ahash_request_set_crypt(req, sg, NULL, rbuf_len);
+
+                rc = ahash_wait(crypto_ahash_update(req), &res);
+                if (rc)
+                        break;
+        }
+        if (read)
+                file->f_mode &= ~FMODE_READ;
+        kfree(rbuf);
+out2:
+        if (!rc) {
+                ahash_request_set_crypt(req, NULL, hash->digest, 0);
+                rc = ahash_wait(crypto_ahash_final(req), &res);
+        }
+out1:
+        ahash_request_free(req);
+        return rc;
+}
+
+static int ima_calc_file_ahash(struct file *file, struct ima_digest_data *hash)
+{
+        struct crypto_ahash *tfm;
+        int rc;
+
+        tfm = ima_alloc_atfm(hash->algo);
+        if (IS_ERR(tfm))
+                return PTR_ERR(tfm);
+
+        rc = ima_calc_file_hash_atfm(file, hash, tfm);
+
+        ima_free_atfm(tfm);
+
+        return rc;
+}
+
 static int ima_calc_file_hash_tfm(struct file *file,
                                   struct ima_digest_data *hash,
                                   struct crypto_shash *tfm)
@@ -156,7 +306,7 @@ out:
         return rc;
 }
 
-int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
+static int ima_calc_file_shash(struct file *file, struct ima_digest_data *hash)
 {
         struct crypto_shash *tfm;
         int rc;
@@ -173,6 +323,35 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
 }
 
 /*
+ * ima_calc_file_hash - calculate file hash
+ *
+ * Asynchronous hash (ahash) allows using HW acceleration for calculating
+ * a hash. ahash performance varies for different data sizes on different
+ * crypto accelerators. shash performance might be better for smaller files.
+ * The 'ima.ahash_minsize' module parameter allows specifying the best
+ * minimum file size for using ahash on the system.
+ *
+ * If the ima.ahash_minsize parameter is not specified, this function uses
+ * shash for the hash calculation.  If ahash fails, it falls back to using
+ * shash.
+ */
+int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
+{
+        loff_t i_size;
+        int rc;
+
+        i_size = i_size_read(file_inode(file));
+
+        if (ima_ahash_minsize && i_size >= ima_ahash_minsize) {
+                rc = ima_calc_file_ahash(file, hash);
+                if (!rc)
+                        return 0;
+        }
+
+        return ima_calc_file_shash(file, hash);
+}
+
+/*
  * Calculate the hash of template data
  */
 static int ima_calc_field_array_hash_tfm(struct ima_field_data *field_data,