Merge branch 'next-integrity' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security

Pull security subsystem integrity updates from James Morris:
 "There is a mixture of bug fixes, code cleanup, preparatory code for
  new functionality and new functionality.

  Commit 26ddabfe96bb ("evm: enable EVM when X509 certificate is
  loaded") enabled EVM without loading a symmetric key, but was limited
  to defining the x509 certificate pathname at build. Included in this
  set of patches is the ability of enabling EVM, without loading the EVM
  symmetric key, from userspace. New is the ability to prevent the
  loading of an EVM symmetric key."

* 'next-integrity' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security:
  ima: Remove redundant conditional operator
  ima: Fix bool initialization/comparison
  ima: check signature enforcement against cmdline param instead of CONFIG
  module: export module signature enforcement status
  ima: fix hash algorithm initialization
  EVM: Only complain about a missing HMAC key once
  EVM: Allow userspace to signal an RSA key has been loaded
  EVM: Include security.apparmor in EVM measurements
  ima: call ima_file_free() prior to calling fasync
  integrity: use kernel_read_file_from_path() to read x509 certs
  ima: always measure and audit files in policy
  ima: don't remove the securityfs policy file
  vfs: fix mounting a filesystem with i_version

6 files changed, 75 insertions, 41 deletions

diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
index c2edba8de35e..c7e8db0ea4c0 100644
--- a/security/integrity/ima/ima_api.c
+++ b/security/integrity/ima/ima_api.c
@@ -199,42 +199,59 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
         struct inode *inode = file_inode(file);
         const char *filename = file->f_path.dentry->d_name.name;
         int result = 0;
+        int length;
+        void *tmpbuf;
+        u64 i_version;
         struct {
                 struct ima_digest_data hdr;
                 char digest[IMA_MAX_DIGEST_SIZE];
         } hash;
 
-        if (!(iint->flags & IMA_COLLECTED)) {
-                u64 i_version = file_inode(file)->i_version;
+        if (iint->flags & IMA_COLLECTED)
+                goto out;
 
-                if (file->f_flags & O_DIRECT) {
-                        audit_cause = "failed(directio)";
-                        result = -EACCES;
-                        goto out;
-                }
+        /*
+         * Dectecting file change is based on i_version. On filesystems
+         * which do not support i_version, support is limited to an initial
+         * measurement/appraisal/audit.
+         */
+        i_version = file_inode(file)->i_version;
+        hash.hdr.algo = algo;
 
-                hash.hdr.algo = algo;
-
-                result = (!buf) ?  ima_calc_file_hash(file, &hash.hdr) :
-                        ima_calc_buffer_hash(buf, size, &hash.hdr);
-                if (!result) {
-                        int length = sizeof(hash.hdr) + hash.hdr.length;
-                        void *tmpbuf = krealloc(iint->ima_hash, length,
-                                                GFP_NOFS);
-                        if (tmpbuf) {
-                                iint->ima_hash = tmpbuf;
-                                memcpy(iint->ima_hash, &hash, length);
-                                iint->version = i_version;
-                                iint->flags |= IMA_COLLECTED;
-                        } else
-                                result = -ENOMEM;
-                }
+        /* Initialize hash digest to 0's in case of failure */
+        memset(&hash.digest, 0, sizeof(hash.digest));
+
+        if (buf)
+                result = ima_calc_buffer_hash(buf, size, &hash.hdr);
+        else
+                result = ima_calc_file_hash(file, &hash.hdr);
+
+        if (result && result != -EBADF && result != -EINVAL)
+                goto out;
+
+        length = sizeof(hash.hdr) + hash.hdr.length;
+        tmpbuf = krealloc(iint->ima_hash, length, GFP_NOFS);
+        if (!tmpbuf) {
+                result = -ENOMEM;
+                goto out;
         }
+
+        iint->ima_hash = tmpbuf;
+        memcpy(iint->ima_hash, &hash, length);
+        iint->version = i_version;
+
+        /* Possibly temporary failure due to type of read (eg. O_DIRECT) */
+        if (!result)
+                iint->flags |= IMA_COLLECTED;
 out:
-        if (result)
+        if (result) {
+                if (file->f_flags & O_DIRECT)
+                        audit_cause = "failed(directio)";
+
                 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
                                     filename, "collect_data", audit_cause,
                                     result, 0);
+        }
         return result;
 }
 
@@ -278,7 +295,7 @@ void ima_store_measurement(struct integrity_iint_cache *iint,
         }
 
         result = ima_store_template(entry, violation, inode, filename, pcr);
-        if (!result || result == -EEXIST) {
+        if ((!result || result == -EEXIST) && !(file->f_flags & O_DIRECT)) {
                 iint->flags |= IMA_MEASURED;
                 iint->measured_pcrs |= (0x1 << pcr);
         }
diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
index 809ba70fbbbf..ec7dfa02c051 100644
--- a/security/integrity/ima/ima_appraise.c
+++ b/security/integrity/ima/ima_appraise.c
@@ -40,7 +40,7 @@ __setup("ima_appraise=", default_appraise_setup);
  */
 bool is_ima_appraise_enabled(void)
 {
-        return (ima_appraise & IMA_APPRAISE_ENFORCE) ? 1 : 0;
+        return ima_appraise & IMA_APPRAISE_ENFORCE;
 }
 
 /*
@@ -405,7 +405,7 @@ int ima_inode_setxattr(struct dentry *dentry, const char *xattr_name,
                 if (!xattr_value_len || (xvalue->type >= IMA_XATTR_LAST))
                         return -EINVAL;
                 ima_reset_appraise_flags(d_backing_inode(dentry),
-                         (xvalue->type == EVM_IMA_XATTR_DIGSIG) ? 1 : 0);
+                        xvalue->type == EVM_IMA_XATTR_DIGSIG);
                 result = 0;
         }
         return result;
diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c
index 802d5d20f36f..a856d8c9c9f3 100644
--- a/security/integrity/ima/ima_crypto.c
+++ b/security/integrity/ima/ima_crypto.c
@@ -441,6 +441,16 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
         loff_t i_size;
         int rc;
 
+        /*
+         * For consistency, fail file's opened with the O_DIRECT flag on
+         * filesystems mounted with/without DAX option.
+         */
+        if (file->f_flags & O_DIRECT) {
+                hash->length = hash_digest_size[ima_hash_algo];
+                hash->algo = ima_hash_algo;
+                return -EINVAL;
+        }
+
         i_size = i_size_read(file_inode(file));
 
         if (ima_ahash_minsize && i_size >= ima_ahash_minsize) {
diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c
index ad491c51e833..fa540c0469da 100644
--- a/security/integrity/ima/ima_fs.c
+++ b/security/integrity/ima/ima_fs.c
@@ -32,7 +32,7 @@ bool ima_canonical_fmt;
 static int __init default_canonical_fmt_setup(char *str)
 {
 #ifdef __BIG_ENDIAN
-        ima_canonical_fmt = 1;
+        ima_canonical_fmt = true;
 #endif
         return 1;
 }
@@ -429,10 +429,10 @@ static int ima_release_policy(struct inode *inode, struct file *file)
         }
 
         ima_update_policy();
-#ifndef CONFIG_IMA_WRITE_POLICY
+#if !defined(CONFIG_IMA_WRITE_POLICY) && !defined(CONFIG_IMA_READ_POLICY)
         securityfs_remove(ima_policy);
         ima_policy = NULL;
-#else
+#elif defined(CONFIG_IMA_WRITE_POLICY)
         clear_bit(IMA_FS_BUSY, &ima_fs_flags);
 #endif
         return 0;
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index 2aebb7984437..770654694efc 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -51,6 +51,8 @@ static int __init hash_setup(char *str)
                         ima_hash_algo = HASH_ALGO_SHA1;
                 else if (strncmp(str, "md5", 3) == 0)
                         ima_hash_algo = HASH_ALGO_MD5;
+                else
+                        return 1;
                 goto out;
         }
 
@@ -60,6 +62,8 @@ static int __init hash_setup(char *str)
                         break;
                 }
         }
+        if (i == HASH_ALGO__LAST)
+                return 1;
 out:
         hash_setup_done = 1;
         return 1;
@@ -235,11 +239,8 @@ static int process_measurement(struct file *file, char *buf, loff_t size,
         hash_algo = ima_get_hash_algo(xattr_value, xattr_len);
 
         rc = ima_collect_measurement(iint, file, buf, size, hash_algo);
-        if (rc != 0) {
-                if (file->f_flags & O_DIRECT)
-                        rc = (iint->flags & IMA_PERMIT_DIRECTIO) ? 0 : -EACCES;
+        if (rc != 0 && rc != -EBADF && rc != -EINVAL)
                 goto out_digsig;
-        }
 
         if (!pathbuf)   /* ima_rdwr_violation possibly pre-fetched */
                 pathname = ima_d_path(&file->f_path, &pathbuf, filename);
@@ -247,12 +248,14 @@ static int process_measurement(struct file *file, char *buf, loff_t size,
         if (action & IMA_MEASURE)
                 ima_store_measurement(iint, file, pathname,
                                       xattr_value, xattr_len, pcr);
-        if (action & IMA_APPRAISE_SUBMASK)
+        if (rc == 0 && (action & IMA_APPRAISE_SUBMASK))
                 rc = ima_appraise_measurement(func, iint, file, pathname,
                                               xattr_value, xattr_len, opened);
         if (action & IMA_AUDIT)
                 ima_audit_measurement(iint, pathname);
 
+        if ((file->f_flags & O_DIRECT) && (iint->flags & IMA_PERMIT_DIRECTIO))
+                rc = 0;
 out_digsig:
         if ((mask & MAY_WRITE) && (iint->flags & IMA_DIGSIG) &&
              !(iint->flags & IMA_NEW_FILE))
@@ -359,12 +362,12 @@ void ima_post_path_mknod(struct dentry *dentry)
  */
 int ima_read_file(struct file *file, enum kernel_read_file_id read_id)
 {
+        bool sig_enforce = is_module_sig_enforced();
+
         if (!file && read_id == READING_MODULE) {
-#ifndef CONFIG_MODULE_SIG_FORCE
-                if ((ima_appraise & IMA_APPRAISE_MODULES) &&
+                if (!sig_enforce && (ima_appraise & IMA_APPRAISE_MODULES) &&
                     (ima_appraise & IMA_APPRAISE_ENFORCE))
                         return -EACCES; /* INTEGRITY_UNKNOWN */
-#endif
                 return 0;       /* We rely on module signature checking */
         }
         return 0;
@@ -406,6 +409,10 @@ int ima_post_read_file(struct file *file, void *buf, loff_t size,
         if (!file && read_id == READING_MODULE) /* MODULE_SIG_FORCE enabled */
                 return 0;
 
+        /* permit signed certs */
+        if (!file && read_id == READING_X509_CERTIFICATE)
+                return 0;
+
         if (!file || !buf || size == 0) { /* should never happen */
                 if (ima_appraise & IMA_APPRAISE_ENFORCE)
                         return -EACCES;
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index 95209a5f8595..ee4613fa5840 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -196,9 +196,9 @@ static int __init policy_setup(char *str)
                 if ((strcmp(p, "tcb") == 0) && !ima_policy)
                         ima_policy = DEFAULT_TCB;
                 else if (strcmp(p, "appraise_tcb") == 0)
-                        ima_use_appraise_tcb = 1;
+                        ima_use_appraise_tcb = true;
                 else if (strcmp(p, "secure_boot") == 0)
-                        ima_use_secure_boot = 1;
+                        ima_use_secure_boot = true;
         }
 
         return 1;
@@ -207,7 +207,7 @@ __setup("ima_policy=", policy_setup);
 
 static int __init default_appraise_policy_setup(char *str)
 {
-        ima_use_appraise_tcb = 1;
+        ima_use_appraise_tcb = true;
         return 1;
 }
 __setup("ima_appraise_tcb", default_appraise_policy_setup);