Skip to contentSkip to conversation

ima: directory integrity appraisal

PATCH In review Dmitry Kasatkin 2 participants 7 messages Nov 18, 2013 – Dec 23, 2013

Subsystems (6)
lore
Share & tools
lore
#0 lore raw

cover ima: directory integrity appraisal

Hello,

This patchset provides extension to IMA to protect appraisal of directories.

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another. In all of these cases, the integrity of the file data and metadata are good.

To prevent such attacks, it is necessary to protect the integrity of the directory content. This patchset calculates a hash of the directory content and verify this hash against good reference value stored in 'security.ima' extended attribute. The directory hash is a hash over the list of directory entries, that includes name, ino, d_type. Initial idea how to calculate the directory hash was suggested by Jayant Mangalampalli (Intel).

This patchset adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

ima_dir_check() verifies the directory integrity during the initial path lookup, when the dentry is just being created and may block. It allocates the needed data structures and performs the integrity verification. The results of which are cached. Subsequent calls mostly happen under RCU locking, when the code may not block, and returns immediately with the cached verification status. So ima_dir_check() does not interrupt RCU path walk.

ima_dir_update(), which is called from several places in namei.c when the directory content is changing, for updating the directory hash.

- Dmitry

Dmitry Kasatkin (2):
ima: hooks for directory integrity protection
ima: directory integrity protection implementation

 fs/namei.c                          |  42 ++++-
 fs/open.c                           |   6 +
 include/linux/ima.h                 |  23 +++
 net/unix/af_unix.c                  |   2 +
 security/integrity/ima/Kconfig      |  10 +
 security/integrity/ima/Makefile     |   1 +
 security/integrity/ima/ima.h        |   3 +-
 security/integrity/ima/ima_dir.c    | 358 ++++++++++++++++++++++++++++++++++++
 security/integrity/ima/ima_main.c   |   3 +
 security/integrity/ima/ima_policy.c |   2 +
 10 files changed, 446 insertions(+), 4 deletions(-)
 create mode 100644 security/integrity/ima/ima_dir.c
Signature · 1 line
1.8.3.2
#1 lore raw

PATCH 1/2 ima: hooks for directory integrity protection

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds hooks for offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another one. In all of these cases, the integrity of the file data and metadata is good.

To prevent such attacks, it is necessary to protect integrity of directory content.

This patch adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

ima_dir_check() is called to verify integrity of the the directory during the initial path lookup.

ima_dir_update() is called from several places in namei.c, when the directory content is changing, for updating the directory hash.

---
 fs/namei.c                        | 42 ++++++++++++++++++++++++++++++++++++---
 fs/open.c                         |  6 ++++++
 include/linux/ima.h               | 23 +++++++++++++++++++++
 net/unix/af_unix.c                |  2 ++
 security/integrity/ima/ima_main.c |  3 +++
 5 files changed, 73 insertions(+), 3 deletions(-)
fs/namei.c +39 -3
index 645268f..d0e1821 100644
@@ -1469,16 +1469,33 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
 	return 0;
 }
 
+static inline int may_lookup_ima(struct nameidata *nd, int err)
+{
+	if (err)
+		return err;
+	err = ima_dir_check(&nd->path, MAY_EXEC|MAY_NOT_BLOCK);
+	if (err != -ECHILD)
+		return err;
+	if (unlazy_walk(nd, NULL))
+		return -ECHILD;
+	return ima_dir_check(&nd->path, MAY_EXEC);
+}
+
 static inline int may_lookup(struct nameidata *nd)
 {
+	int err = 0;
+
 	if (nd->flags & LOOKUP_RCU) {
-		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
+		err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
 		if (err != -ECHILD)
-			return err;
+			return may_lookup_ima(nd, err);
 		if (unlazy_walk(nd, NULL))
 			return -ECHILD;
 	}
-	return inode_permission(nd->inode, MAY_EXEC);
+	err = inode_permission(nd->inode, MAY_EXEC);
+	if (err)
+		return err;
+	return ima_dir_check(&nd->path, MAY_EXEC);
 }
 
 static inline int handle_dots(struct nameidata *nd, int type)
@@ -2956,6 +2973,8 @@ retry_lookup:
 	}
 	mutex_lock(&dir->d_inode->i_mutex);
 	error = lookup_open(nd, path, file, op, got_write, opened);
+	if (error >= 0 && (*opened & FILE_CREATED))
+		ima_dir_update(&nd->path, NULL);
 	mutex_unlock(&dir->d_inode->i_mutex);
 
 	if (error <= 0) {
@@ -3454,6 +3473,8 @@ retry:
 			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
 			break;
 	}
+	if (!error)
+		ima_dir_update(&path, dentry);
 out:
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
@@ -3510,6 +3531,8 @@ retry:
 	error = security_path_mkdir(&path, dentry, mode);
 	if (!error)
 		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3626,6 +3649,8 @@ retry:
 	if (error)
 		goto exit3;
 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+	if (!error)
+		ima_dir_update(&nd.path, NULL);
 exit3:
 	dput(dentry);
 exit2:
@@ -3721,6 +3746,8 @@ retry:
 		if (error)
 			goto exit2;
 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+		if (!error)
+			ima_dir_update(&nd.path, NULL);
 exit2:
 		dput(dentry);
 	}
@@ -3801,6 +3828,8 @@ retry:
 	error = security_path_symlink(&path, dentry, from->name);
 	if (!error)
 		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3919,6 +3948,8 @@ retry:
 	if (error)
 		goto out_dput;
 	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
+	if (!error)
+		ima_dir_update(&new_path, NULL);
 out_dput:
 	done_path_create(&new_path, new_dentry);
 	if (retry_estale(error, how)) {
@@ -4171,6 +4202,11 @@ retry:
 		goto exit5;
 	error = vfs_rename(old_dir->d_inode, old_dentry,
 				   new_dir->d_inode, new_dentry);
+	if (!error) {
+		ima_dir_update(&oldnd.path, NULL);
+		if (!path_equal(&oldnd.path, &newnd.path))
+			ima_dir_update(&newnd.path, NULL);
+	}
 exit5:
 	dput(new_dentry);
 exit4:
fs/open.c +6 -0
index d420331..021e2c5 100644
@@ -390,6 +390,9 @@ retry:
 	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
 	if (error)
 		goto dput_and_out;
+	error = ima_dir_check(&path, MAY_EXEC);
+	if (error)
+		goto dput_and_out;
 
 	set_fs_pwd(current->fs, &path);
 
@@ -420,6 +423,9 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 		goto out_putf;
 
 	error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
+	if (error)
+		goto out_putf;
+	error = ima_dir_check(&f.file->f_path, MAY_EXEC);
 	if (!error)
 		set_fs_pwd(current->fs, &f.file->f_path);
 out_putf:
include/linux/ima.h +23 -0
index 1b7f268..e33035e 100644
@@ -73,4 +73,27 @@ static inline int ima_inode_removexattr(struct dentry *dentry,
 	return 0;
 }
 #endif /* CONFIG_IMA_APPRAISE */
+
+#ifdef CONFIG_IMA_APPRAISE_DIRECTORIES
+extern int ima_dir_check(struct path *dir, int mask);
+extern int ima_special_check(struct file *file, int mask);
+extern void ima_dir_update(struct path *dir, struct dentry *dentry);
+#else
+static inline int ima_dir_check(struct path *dir, int mask)
+{
+	return 0;
+}
+
+static inline int ima_special_check(struct file *file, int mask)
+{
+	return 0;
+}
+
+static inline void ima_dir_update(struct path *dir, struct dentry *dentry)
+{
+	return;
+}
+
+#endif /* CONFIG_IMA_APPRAISE_DIRECTORIES */
+
 #endif /* _LINUX_IMA_H */
net/unix/af_unix.c +2 -0
index 86de99a..6230a50 100644
@@ -115,6 +115,7 @@
 #include <net/checksum.h>
 #include <linux/security.h>
 #include <linux/freezer.h>
+#include <linux/ima.h>
 
 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 EXPORT_SYMBOL_GPL(unix_socket_table);
@@ -841,6 +842,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 		if (!err) {
 			res->mnt = mntget(path.mnt);
 			res->dentry = dget(dentry);
+			ima_dir_update(&path, dentry);
 		}
 	}
 	done_path_create(&path, dentry);
security/integrity/ima/ima_main.c +3 -0
index 6c12811..18d76d8 100644
@@ -300,6 +300,9 @@ int ima_bprm_check(struct linux_binprm *bprm)
  */
 int ima_file_check(struct file *file, int mask)
 {
+	if (!S_ISREG(file->f_dentry->d_inode->i_mode))
+		return ima_special_check(file, mask);
+
 	ima_rdwr_violation_check(file);
 	return process_measurement(file, NULL,
 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
Signature · 1 line
1.8.3.2
#2 lore raw

Re: [PATCH 1/2] ima: hooks for directory integrity protection

Quoted 232 lines · Dmitry Kasatkin

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds hooks for offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another one. In all of these cases, the integrity of the file data and metadata is good.

To prevent such attacks, it is necessary to protect integrity of directory content.

This patch adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

ima_dir_check() is called to verify integrity of the the directory during the initial path lookup.

ima_dir_update() is called from several places in namei.c, when the directory content is changing, for updating the directory hash.

---
 fs/namei.c                        | 42 ++++++++++++++++++++++++++++++++++++---
 fs/open.c                         |  6 ++++++
 include/linux/ima.h               | 23 +++++++++++++++++++++
 net/unix/af_unix.c                |  2 ++
 security/integrity/ima/ima_main.c |  3 +++
 5 files changed, 73 insertions(+), 3 deletions(-)
fs/namei.c +39 -3
index 645268f..d0e1821 100644
@@ -1469,16 +1469,33 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
 	return 0;
 }
 
+static inline int may_lookup_ima(struct nameidata *nd, int err)
+{
+	if (err)
+		return err;
+	err = ima_dir_check(&nd->path, MAY_EXEC|MAY_NOT_BLOCK);
+	if (err != -ECHILD)
+		return err;
+	if (unlazy_walk(nd, NULL))
+		return -ECHILD;
+	return ima_dir_check(&nd->path, MAY_EXEC);
+}
+
 static inline int may_lookup(struct nameidata *nd)
 {
+	int err = 0;
+
 	if (nd->flags & LOOKUP_RCU) {
-		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
+		err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
 		if (err != -ECHILD)
-			return err;
+			return may_lookup_ima(nd, err);
 		if (unlazy_walk(nd, NULL))
 			return -ECHILD;
 	}
-	return inode_permission(nd->inode, MAY_EXEC);
+	err = inode_permission(nd->inode, MAY_EXEC);
+	if (err)
+		return err;
+	return ima_dir_check(&nd->path, MAY_EXEC);
 }
 
 static inline int handle_dots(struct nameidata *nd, int type)
@@ -2956,6 +2973,8 @@ retry_lookup:
 	}
 	mutex_lock(&dir->d_inode->i_mutex);
 	error = lookup_open(nd, path, file, op, got_write, opened);
+	if (error >= 0 && (*opened & FILE_CREATED))
+		ima_dir_update(&nd->path, NULL);
 	mutex_unlock(&dir->d_inode->i_mutex);
 
 	if (error <= 0) {
@@ -3454,6 +3473,8 @@ retry:
 			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
 			break;
 	}
+	if (!error)
+		ima_dir_update(&path, dentry);
 out:
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
@@ -3510,6 +3531,8 @@ retry:
 	error = security_path_mkdir(&path, dentry, mode);
 	if (!error)
 		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3626,6 +3649,8 @@ retry:
 	if (error)
 		goto exit3;
 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+	if (!error)
+		ima_dir_update(&nd.path, NULL);
 exit3:
 	dput(dentry);
 exit2:
@@ -3721,6 +3746,8 @@ retry:
 		if (error)
 			goto exit2;
 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+		if (!error)
+			ima_dir_update(&nd.path, NULL);
 exit2:
 		dput(dentry);
 	}
@@ -3801,6 +3828,8 @@ retry:
 	error = security_path_symlink(&path, dentry, from->name);
 	if (!error)
 		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3919,6 +3948,8 @@ retry:
 	if (error)
 		goto out_dput;
 	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
+	if (!error)
+		ima_dir_update(&new_path, NULL);
 out_dput:
 	done_path_create(&new_path, new_dentry);
 	if (retry_estale(error, how)) {
@@ -4171,6 +4202,11 @@ retry:
 		goto exit5;
 	error = vfs_rename(old_dir->d_inode, old_dentry,
 				   new_dir->d_inode, new_dentry);
+	if (!error) {
+		ima_dir_update(&oldnd.path, NULL);
+		if (!path_equal(&oldnd.path, &newnd.path))
+			ima_dir_update(&newnd.path, NULL);
+	}
 exit5:
 	dput(new_dentry);
 exit4:
fs/open.c +6 -0
index d420331..021e2c5 100644
@@ -390,6 +390,9 @@ retry:
 	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
 	if (error)
 		goto dput_and_out;
+	error = ima_dir_check(&path, MAY_EXEC);
+	if (error)
+		goto dput_and_out;
 
 	set_fs_pwd(current->fs, &path);
 
@@ -420,6 +423,9 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 		goto out_putf;
 
 	error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
+	if (error)
+		goto out_putf;
+	error = ima_dir_check(&f.file->f_path, MAY_EXEC);
 	if (!error)
 		set_fs_pwd(current->fs, &f.file->f_path);
 out_putf:
include/linux/ima.h +23 -0
index 1b7f268..e33035e 100644
@@ -73,4 +73,27 @@ static inline int ima_inode_removexattr(struct dentry *dentry,
 	return 0;
 }
 #endif /* CONFIG_IMA_APPRAISE */
+
+#ifdef CONFIG_IMA_APPRAISE_DIRECTORIES
+extern int ima_dir_check(struct path *dir, int mask);
+extern int ima_special_check(struct file *file, int mask);
+extern void ima_dir_update(struct path *dir, struct dentry *dentry);
+#else
+static inline int ima_dir_check(struct path *dir, int mask)
+{
+	return 0;
+}
+
+static inline int ima_special_check(struct file *file, int mask)
+{
+	return 0;
+}
+
+static inline void ima_dir_update(struct path *dir, struct dentry *dentry)
+{
+	return;
+}
+
+#endif /* CONFIG_IMA_APPRAISE_DIRECTORIES */
+
 #endif /* _LINUX_IMA_H */
net/unix/af_unix.c +2 -0
index 86de99a..6230a50 100644
@@ -115,6 +115,7 @@
 #include <net/checksum.h>
 #include <linux/security.h>
 #include <linux/freezer.h>
+#include <linux/ima.h>
 
 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 EXPORT_SYMBOL_GPL(unix_socket_table);
@@ -841,6 +842,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 		if (!err) {
 			res->mnt = mntget(path.mnt);
 			res->dentry = dget(dentry);
+			ima_dir_update(&path, dentry);
 		}
 	}
 	done_path_create(&path, dentry);
security/integrity/ima/ima_main.c +0 -0
index 6c12811..18d76d8 100644

security/integrity/ima/ima_main.c int ima_bprm_check(struct linux_binprm *bprm) · line 308

Quoted 9 lines
security/integrity/ima/ima_main.c +3 -0
@@ -300,6 +300,9 @@ int ima_bprm_check(struct linux_binprm *bprm)
  */
 int ima_file_check(struct file *file, int mask)
 {
+	if (!S_ISREG(file->f_dentry->d_inode->i_mode))
+		return ima_special_check(file, mask);
+
 	ima_rdwr_violation_check(file);
 	return process_measurement(file, NULL,
 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),

Hi Al,

Are you OK with the hooks?
If so can you please ack or discuss the patch?

- Dmitry

#3 lore raw

Re: [PATCH 1/2] ima: hooks for directory integrity protection

In reply to Dmitry Kasatkin
Quoted 14 lines · Dmitry Kasatkin

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds hooks for offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another one. In all of these cases, the integrity of the file data and metadata is good.

Quoted 2 lines

To prevent such attacks, it is necessary to protect integrity of directory content.

Thanks Dmitry for re-posting these 'directory integrity protection' patches.
The patches have evolved nicely. Perhaps not a formal changelog, but a short
summary of the major changes, would have been nice.

Quoted 3 lines

This patch adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

Although these patches are probably bisect safe, as they rely on Kconfig, the normal ordering of patches is to define a function and use it in the same patch. In the case, like here, where a new function/hook is defined in one subsystem, but called from another, we can split them, but the normal convention is to add the new function/hook first in one patch, and then use it in a subsequent patch.

Quoted 21 lines

ima_dir_check() is called to verify integrity of the the directory during the initial path lookup.

ima_dir_update() is called from several places in namei.c, when the directory content is changing, for updating the directory hash.

---
 fs/namei.c                        | 42 ++++++++++++++++++++++++++++++++++++---
 fs/open.c                         |  6 ++++++
 include/linux/ima.h               | 23 +++++++++++++++++++++
 net/unix/af_unix.c                |  2 ++
 security/integrity/ima/ima_main.c |  3 +++
 5 files changed, 73 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 645268f..d0e1821 100644

fs/namei.c static int lookup_slow(struct nameidata *nd, struct path *path) · line 1478

Quoted 10 lines
fs/namei.c +7 -0
@@ -1469,16 +1469,33 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
 	return 0;
 }
 
+static inline int may_lookup_ima(struct nameidata *nd, int err)
+{
+	if (err)
+		return err;
+	err = ima_dir_check(&nd->path, MAY_EXEC|MAY_NOT_BLOCK);
+	if (err != -ECHILD)
+		return err;

A short comment here, why -ECHILD is special, would be good.

Quoted 130 lines
fs/namei.c +32 -3
+	if (unlazy_walk(nd, NULL))
+		return -ECHILD;
+	return ima_dir_check(&nd->path, MAY_EXEC);
+}
+
 static inline int may_lookup(struct nameidata *nd)
 {
+	int err = 0;
+
 	if (nd->flags & LOOKUP_RCU) {
-		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
+		err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
 		if (err != -ECHILD)
-			return err;
+			return may_lookup_ima(nd, err);
 		if (unlazy_walk(nd, NULL))
 			return -ECHILD;
 	}
-	return inode_permission(nd->inode, MAY_EXEC);
+	err = inode_permission(nd->inode, MAY_EXEC);
+	if (err)
+		return err;
+	return ima_dir_check(&nd->path, MAY_EXEC);
 }
 
 static inline int handle_dots(struct nameidata *nd, int type)
@@ -2956,6 +2973,8 @@ retry_lookup:
 	}
 	mutex_lock(&dir->d_inode->i_mutex);
 	error = lookup_open(nd, path, file, op, got_write, opened);
+	if (error >= 0 && (*opened & FILE_CREATED))
+		ima_dir_update(&nd->path, NULL);
 	mutex_unlock(&dir->d_inode->i_mutex);
 
 	if (error <= 0) {
@@ -3454,6 +3473,8 @@ retry:
 			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
 			break;
 	}
+	if (!error)
+		ima_dir_update(&path, dentry);
 out:
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
@@ -3510,6 +3531,8 @@ retry:
 	error = security_path_mkdir(&path, dentry, mode);
 	if (!error)
 		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3626,6 +3649,8 @@ retry:
 	if (error)
 		goto exit3;
 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+	if (!error)
+		ima_dir_update(&nd.path, NULL);
 exit3:
 	dput(dentry);
 exit2:
@@ -3721,6 +3746,8 @@ retry:
 		if (error)
 			goto exit2;
 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+		if (!error)
+			ima_dir_update(&nd.path, NULL);
 exit2:
 		dput(dentry);
 	}
@@ -3801,6 +3828,8 @@ retry:
 	error = security_path_symlink(&path, dentry, from->name);
 	if (!error)
 		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3919,6 +3948,8 @@ retry:
 	if (error)
 		goto out_dput;
 	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
+	if (!error)
+		ima_dir_update(&new_path, NULL);
 out_dput:
 	done_path_create(&new_path, new_dentry);
 	if (retry_estale(error, how)) {
@@ -4171,6 +4202,11 @@ retry:
 		goto exit5;
 	error = vfs_rename(old_dir->d_inode, old_dentry,
 				   new_dir->d_inode, new_dentry);
+	if (!error) {
+		ima_dir_update(&oldnd.path, NULL);
+		if (!path_equal(&oldnd.path, &newnd.path))
+			ima_dir_update(&newnd.path, NULL);
+	}
 exit5:
 	dput(new_dentry);
 exit4:
fs/open.c +6 -0
index d420331..021e2c5 100644
@@ -390,6 +390,9 @@ retry:
 	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
 	if (error)
 		goto dput_and_out;
+	error = ima_dir_check(&path, MAY_EXEC);
+	if (error)
+		goto dput_and_out;
 
 	set_fs_pwd(current->fs, &path);
 
@@ -420,6 +423,9 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 		goto out_putf;
 
 	error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
+	if (error)
+		goto out_putf;
+	error = ima_dir_check(&f.file->f_path, MAY_EXEC);
 	if (!error)
 		set_fs_pwd(current->fs, &f.file->f_path);
 out_putf:
include/linux/ima.h +0 -0
index 1b7f268..e33035e 100644

include/linux/ima.h static inline int ima_inode_removexattr(struct dentry *dentry, · line 79

Quoted 7 lines
include/linux/ima.h +4 -0
@@ -73,4 +73,27 @@ static inline int ima_inode_removexattr(struct dentry *dentry,
 	return 0;
 }
 #endif /* CONFIG_IMA_APPRAISE */
+
+#ifdef CONFIG_IMA_APPRAISE_DIRECTORIES
+extern int ima_dir_check(struct path *dir, int mask);
+extern int ima_special_check(struct file *file, int mask);

No mention was made of this new hook. This should be a separate patch, with its own patch description.

thanks,

Mimi

Quoted 54 lines
include/linux/ima.h +19 -0
+extern void ima_dir_update(struct path *dir, struct dentry *dentry);
+#else
+static inline int ima_dir_check(struct path *dir, int mask)
+{
+	return 0;
+}
+
+static inline int ima_special_check(struct file *file, int mask)
+{
+	return 0;
+}
+
+static inline void ima_dir_update(struct path *dir, struct dentry *dentry)
+{
+	return;
+}
+
+#endif /* CONFIG_IMA_APPRAISE_DIRECTORIES */
+
 #endif /* _LINUX_IMA_H */
net/unix/af_unix.c +2 -0
index 86de99a..6230a50 100644
@@ -115,6 +115,7 @@
 #include <net/checksum.h>
 #include <linux/security.h>
 #include <linux/freezer.h>
+#include <linux/ima.h>
 
 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 EXPORT_SYMBOL_GPL(unix_socket_table);
@@ -841,6 +842,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 		if (!err) {
 			res->mnt = mntget(path.mnt);
 			res->dentry = dget(dentry);
+			ima_dir_update(&path, dentry);
 		}
 	}
 	done_path_create(&path, dentry);
security/integrity/ima/ima_main.c +3 -0
index 6c12811..18d76d8 100644
@@ -300,6 +300,9 @@ int ima_bprm_check(struct linux_binprm *bprm)
  */
 int ima_file_check(struct file *file, int mask)
 {
+	if (!S_ISREG(file->f_dentry->d_inode->i_mode))
+		return ima_special_check(file, mask);
+
 	ima_rdwr_violation_check(file);
 	return process_measurement(file, NULL,
 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
#4 lore raw

Re: [PATCH 1/2] ima: hooks for directory integrity protection

Hi,

Quoted 15 lines · Mimi Zohar
Quoted 14 lines · Dmitry Kasatkin

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds hooks for offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another one. In all of these cases, the integrity of the file data and metadata is good.

Quoted 7 lines
Quoted 2 lines

To prevent such attacks, it is necessary to protect integrity of directory content.

Thanks Dmitry for re-posting these 'directory integrity protection' patches.
The patches have evolved nicely. Perhaps not a formal changelog, but a short
summary of the major changes, would have been nice.

Will do in re-post...

Quoted 8 lines
Quoted 2 lines

This patch adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

Although these patches are probably bisect safe, as they rely on Kconfig, the normal ordering of patches is to define a function and use it in the same patch. In the case, like here, where a new function/hook is defined in one subsystem, but called from another, we can split them, but the normal convention is to add the new function/hook first in one patch, and then use it in a subsequent patch.

Sorry, I did not get...

Quoted 1 line
Quoted 1 line

"normal convention is to add the new function/hook first in one

patch, and then use it in a subsequent patch. "

This is what patches do. Add hook in one patch and use in an other..

Do you mean to swap the order of these 2 patches??

Quoted 24 lines
Quoted 24 lines

ima_dir_check() is called to verify integrity of the the directory during the initial path lookup.

ima_dir_update() is called from several places in namei.c, when the directory content is changing, for updating the directory hash.

---
 fs/namei.c                        | 42 ++++++++++++++++++++++++++++++++++++---
 fs/open.c                         |  6 ++++++
 include/linux/ima.h               | 23 +++++++++++++++++++++
 net/unix/af_unix.c                |  2 ++
 security/integrity/ima/ima_main.c |  3 +++
 5 files changed, 73 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 645268f..d0e1821 100644
@@ -1469,16 +1469,33 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
 	return 0;
 }
 
Quoted 8 lines

fs/namei.c static int lookup_slow(struct nameidata *nd, struct path *path) · line 1478

Quoted 7 lines
fs/namei.c +7 -0
+static inline int may_lookup_ima(struct nameidata *nd, int err)
+{
+	if (err)
+		return err;
+	err = ima_dir_check(&nd->path, MAY_EXEC|MAY_NOT_BLOCK);
+	if (err != -ECHILD)
+		return err;

A short comment here, why -ECHILD is special, would be good.

This is the same as for inode_permission().
If calling code requires locking, we have to interrupt RCU path walk and re-start with ref path walk...

Quoted 131 lines
Quoted 131 lines
fs/namei.c +32 -3
+	if (unlazy_walk(nd, NULL))
+		return -ECHILD;
+	return ima_dir_check(&nd->path, MAY_EXEC);
+}
+
 static inline int may_lookup(struct nameidata *nd)
 {
+	int err = 0;
+
 	if (nd->flags & LOOKUP_RCU) {
-		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
+		err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
 		if (err != -ECHILD)
-			return err;
+			return may_lookup_ima(nd, err);
 		if (unlazy_walk(nd, NULL))
 			return -ECHILD;
 	}
-	return inode_permission(nd->inode, MAY_EXEC);
+	err = inode_permission(nd->inode, MAY_EXEC);
+	if (err)
+		return err;
+	return ima_dir_check(&nd->path, MAY_EXEC);
 }
 
 static inline int handle_dots(struct nameidata *nd, int type)
@@ -2956,6 +2973,8 @@ retry_lookup:
 	}
 	mutex_lock(&dir->d_inode->i_mutex);
 	error = lookup_open(nd, path, file, op, got_write, opened);
+	if (error >= 0 && (*opened & FILE_CREATED))
+		ima_dir_update(&nd->path, NULL);
 	mutex_unlock(&dir->d_inode->i_mutex);
 
 	if (error <= 0) {
@@ -3454,6 +3473,8 @@ retry:
 			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
 			break;
 	}
+	if (!error)
+		ima_dir_update(&path, dentry);
 out:
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
@@ -3510,6 +3531,8 @@ retry:
 	error = security_path_mkdir(&path, dentry, mode);
 	if (!error)
 		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3626,6 +3649,8 @@ retry:
 	if (error)
 		goto exit3;
 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+	if (!error)
+		ima_dir_update(&nd.path, NULL);
 exit3:
 	dput(dentry);
 exit2:
@@ -3721,6 +3746,8 @@ retry:
 		if (error)
 			goto exit2;
 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+		if (!error)
+			ima_dir_update(&nd.path, NULL);
 exit2:
 		dput(dentry);
 	}
@@ -3801,6 +3828,8 @@ retry:
 	error = security_path_symlink(&path, dentry, from->name);
 	if (!error)
 		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3919,6 +3948,8 @@ retry:
 	if (error)
 		goto out_dput;
 	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
+	if (!error)
+		ima_dir_update(&new_path, NULL);
 out_dput:
 	done_path_create(&new_path, new_dentry);
 	if (retry_estale(error, how)) {
@@ -4171,6 +4202,11 @@ retry:
 		goto exit5;
 	error = vfs_rename(old_dir->d_inode, old_dentry,
 				   new_dir->d_inode, new_dentry);
+	if (!error) {
+		ima_dir_update(&oldnd.path, NULL);
+		if (!path_equal(&oldnd.path, &newnd.path))
+			ima_dir_update(&newnd.path, NULL);
+	}
 exit5:
 	dput(new_dentry);
 exit4:
fs/open.c +6 -0
index d420331..021e2c5 100644
@@ -390,6 +390,9 @@ retry:
 	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
 	if (error)
 		goto dput_and_out;
+	error = ima_dir_check(&path, MAY_EXEC);
+	if (error)
+		goto dput_and_out;
 
 	set_fs_pwd(current->fs, &path);
 
@@ -420,6 +423,9 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 		goto out_putf;
 
 	error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
+	if (error)
+		goto out_putf;
+	error = ima_dir_check(&f.file->f_path, MAY_EXEC);
 	if (!error)
 		set_fs_pwd(current->fs, &f.file->f_path);
 out_putf:
include/linux/ima.h +0 -0
index 1b7f268..e33035e 100644
@@ -73,4 +73,27 @@ static inline int ima_inode_removexattr(struct dentry *dentry,
 	return 0;
Quoted 8 lines

include/linux/ima.h static inline int ima_inode_removexattr(struct dentry *dentry, · line 79

Quoted 6 lines
include/linux/ima.h +4 -0
 }
 #endif /* CONFIG_IMA_APPRAISE */
+
+#ifdef CONFIG_IMA_APPRAISE_DIRECTORIES
+extern int ima_dir_check(struct path *dir, int mask);
+extern int ima_special_check(struct file *file, int mask);

No mention was made of this new hook. This should be a separate patch, with its own patch description.

Yes. This is a patch split mistake.. Thanks.

Quoted 51 lines

thanks,

Mimi

Quoted 46 lines
include/linux/ima.h +19 -0
+extern void ima_dir_update(struct path *dir, struct dentry *dentry);
+#else
+static inline int ima_dir_check(struct path *dir, int mask)
+{
+	return 0;
+}
+
+static inline int ima_special_check(struct file *file, int mask)
+{
+	return 0;
+}
+
+static inline void ima_dir_update(struct path *dir, struct dentry *dentry)
+{
+	return;
+}
+
+#endif /* CONFIG_IMA_APPRAISE_DIRECTORIES */
+
 #endif /* _LINUX_IMA_H */
net/unix/af_unix.c +2 -0
index 86de99a..6230a50 100644
@@ -115,6 +115,7 @@
 #include <net/checksum.h>
 #include <linux/security.h>
 #include <linux/freezer.h>
+#include <linux/ima.h>
 
 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 EXPORT_SYMBOL_GPL(unix_socket_table);
@@ -841,6 +842,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 		if (!err) {
 			res->mnt = mntget(path.mnt);
 			res->dentry = dget(dentry);
+			ima_dir_update(&path, dentry);
 		}
 	}
 	done_path_create(&path, dentry);
security/integrity/ima/ima_main.c +0 -0
index 6c12811..18d76d8 100644
@@ -300,6 +300,9 @@ int ima_bprm_check(struct linux_binprm *bprm)
  */
Quoted 10 lines

security/integrity/ima/ima_main.c int ima_bprm_check(struct linux_binprm *bprm) · line 308

Quoted 8 lines
security/integrity/ima/ima_main.c +3 -0
 int ima_file_check(struct file *file, int mask)
 {
+	if (!S_ISREG(file->f_dentry->d_inode->i_mode))
+		return ima_special_check(file, mask);
+
 	ima_rdwr_violation_check(file);
 	return process_measurement(file, NULL,
 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),

Thanks

#5 lore raw

Re: [PATCH 1/2] ima: hooks for directory integrity protection

Quoted 37 lines · Dmitry Kasatkin

Hi,

Quoted 15 lines · Mimi Zohar
Quoted 14 lines · Dmitry Kasatkin

Both IMA-appraisal and EVM protect the integrity of regular files. IMA protects file data integrity, while EVM protects the file meta-data integrity, such as file attributes and extended attributes. This patch set adds hooks for offline directory integrity protection.

An inode itself does not have any file name associated with it. The association of the file name to inode is done via directory entries. On a running system, mandatory and/or discretionary access control prevent unprivileged file deletion, file name change, or hardlink creation. In an offline attack, without these protections, the association between a file name and an inode is unprotected. Files can be deleted, renamed or moved from one directory to another one. In all of these cases, the integrity of the file data and metadata is good.

Quoted 7 lines
Quoted 2 lines

To prevent such attacks, it is necessary to protect integrity of directory content.

Thanks Dmitry for re-posting these 'directory integrity protection' patches.
The patches have evolved nicely. Perhaps not a formal changelog, but a short
summary of the major changes, would have been nice.

Will do in re-post...

Quoted 8 lines
Quoted 2 lines

This patch adds 2 new hooks for directory integrity protection:
ima_dir_check() and ima_dir_update().

Although these patches are probably bisect safe, as they rely on Kconfig, the normal ordering of patches is to define a function and use it in the same patch. In the case, like here, where a new function/hook is defined in one subsystem, but called from another, we can split them, but the normal convention is to add the new function/hook first in one patch, and then use it in a subsequent patch.

Quoted 6 lines

Sorry, I did not get...

Quoted 1 line
Quoted 1 line

"normal convention is to add the new function/hook first in one

patch, and then use it in a subsequent patch. "

This is what patches do. Add hook in one patch and use in an other..

Yes, define the hook/function, before using it.

thanks,

Mimi

Quoted 251 lines

Do you mean to swap the order of these 2 patches??

Quoted 24 lines
Quoted 24 lines

ima_dir_check() is called to verify integrity of the the directory during the initial path lookup.

ima_dir_update() is called from several places in namei.c, when the directory content is changing, for updating the directory hash.

---
 fs/namei.c                        | 42 ++++++++++++++++++++++++++++++++++++---
 fs/open.c                         |  6 ++++++
 include/linux/ima.h               | 23 +++++++++++++++++++++
 net/unix/af_unix.c                |  2 ++
 security/integrity/ima/ima_main.c |  3 +++
 5 files changed, 73 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 645268f..d0e1821 100644
@@ -1469,16 +1469,33 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
 	return 0;
 }
 
Quoted 8 lines

fs/namei.c static int lookup_slow(struct nameidata *nd, struct path *path) · line 1478

Quoted 7 lines
fs/namei.c +7 -0
+static inline int may_lookup_ima(struct nameidata *nd, int err)
+{
+	if (err)
+		return err;
+	err = ima_dir_check(&nd->path, MAY_EXEC|MAY_NOT_BLOCK);
+	if (err != -ECHILD)
+		return err;

A short comment here, why -ECHILD is special, would be good.

This is the same as for inode_permission().
If calling code requires locking, we have to interrupt RCU path walk and re-start with ref path walk...

Quoted 131 lines
Quoted 131 lines
fs/namei.c +32 -3
+	if (unlazy_walk(nd, NULL))
+		return -ECHILD;
+	return ima_dir_check(&nd->path, MAY_EXEC);
+}
+
 static inline int may_lookup(struct nameidata *nd)
 {
+	int err = 0;
+
 	if (nd->flags & LOOKUP_RCU) {
-		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
+		err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
 		if (err != -ECHILD)
-			return err;
+			return may_lookup_ima(nd, err);
 		if (unlazy_walk(nd, NULL))
 			return -ECHILD;
 	}
-	return inode_permission(nd->inode, MAY_EXEC);
+	err = inode_permission(nd->inode, MAY_EXEC);
+	if (err)
+		return err;
+	return ima_dir_check(&nd->path, MAY_EXEC);
 }
 
 static inline int handle_dots(struct nameidata *nd, int type)
@@ -2956,6 +2973,8 @@ retry_lookup:
 	}
 	mutex_lock(&dir->d_inode->i_mutex);
 	error = lookup_open(nd, path, file, op, got_write, opened);
+	if (error >= 0 && (*opened & FILE_CREATED))
+		ima_dir_update(&nd->path, NULL);
 	mutex_unlock(&dir->d_inode->i_mutex);
 
 	if (error <= 0) {
@@ -3454,6 +3473,8 @@ retry:
 			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
 			break;
 	}
+	if (!error)
+		ima_dir_update(&path, dentry);
 out:
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
@@ -3510,6 +3531,8 @@ retry:
 	error = security_path_mkdir(&path, dentry, mode);
 	if (!error)
 		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3626,6 +3649,8 @@ retry:
 	if (error)
 		goto exit3;
 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+	if (!error)
+		ima_dir_update(&nd.path, NULL);
 exit3:
 	dput(dentry);
 exit2:
@@ -3721,6 +3746,8 @@ retry:
 		if (error)
 			goto exit2;
 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+		if (!error)
+			ima_dir_update(&nd.path, NULL);
 exit2:
 		dput(dentry);
 	}
@@ -3801,6 +3828,8 @@ retry:
 	error = security_path_symlink(&path, dentry, from->name);
 	if (!error)
 		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
+	if (!error)
+		ima_dir_update(&path, dentry);
 	done_path_create(&path, dentry);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -3919,6 +3948,8 @@ retry:
 	if (error)
 		goto out_dput;
 	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
+	if (!error)
+		ima_dir_update(&new_path, NULL);
 out_dput:
 	done_path_create(&new_path, new_dentry);
 	if (retry_estale(error, how)) {
@@ -4171,6 +4202,11 @@ retry:
 		goto exit5;
 	error = vfs_rename(old_dir->d_inode, old_dentry,
 				   new_dir->d_inode, new_dentry);
+	if (!error) {
+		ima_dir_update(&oldnd.path, NULL);
+		if (!path_equal(&oldnd.path, &newnd.path))
+			ima_dir_update(&newnd.path, NULL);
+	}
 exit5:
 	dput(new_dentry);
 exit4:
fs/open.c +6 -0
index d420331..021e2c5 100644
@@ -390,6 +390,9 @@ retry:
 	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
 	if (error)
 		goto dput_and_out;
+	error = ima_dir_check(&path, MAY_EXEC);
+	if (error)
+		goto dput_and_out;
 
 	set_fs_pwd(current->fs, &path);
 
@@ -420,6 +423,9 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 		goto out_putf;
 
 	error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
+	if (error)
+		goto out_putf;
+	error = ima_dir_check(&f.file->f_path, MAY_EXEC);
 	if (!error)
 		set_fs_pwd(current->fs, &f.file->f_path);
 out_putf:
include/linux/ima.h +0 -0
index 1b7f268..e33035e 100644
@@ -73,4 +73,27 @@ static inline int ima_inode_removexattr(struct dentry *dentry,
 	return 0;
Quoted 8 lines

include/linux/ima.h static inline int ima_inode_removexattr(struct dentry *dentry, · line 79

Quoted 6 lines
include/linux/ima.h +4 -0
 }
 #endif /* CONFIG_IMA_APPRAISE */
+
+#ifdef CONFIG_IMA_APPRAISE_DIRECTORIES
+extern int ima_dir_check(struct path *dir, int mask);
+extern int ima_special_check(struct file *file, int mask);

No mention was made of this new hook. This should be a separate patch, with its own patch description.

Yes. This is a patch split mistake.. Thanks.

Quoted 51 lines

thanks,

Mimi

Quoted 46 lines
include/linux/ima.h +19 -0
+extern void ima_dir_update(struct path *dir, struct dentry *dentry);
+#else
+static inline int ima_dir_check(struct path *dir, int mask)
+{
+	return 0;
+}
+
+static inline int ima_special_check(struct file *file, int mask)
+{
+	return 0;
+}
+
+static inline void ima_dir_update(struct path *dir, struct dentry *dentry)
+{
+	return;
+}
+
+#endif /* CONFIG_IMA_APPRAISE_DIRECTORIES */
+
 #endif /* _LINUX_IMA_H */
net/unix/af_unix.c +2 -0
index 86de99a..6230a50 100644
@@ -115,6 +115,7 @@
 #include <net/checksum.h>
 #include <linux/security.h>
 #include <linux/freezer.h>
+#include <linux/ima.h>
 
 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 EXPORT_SYMBOL_GPL(unix_socket_table);
@@ -841,6 +842,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 		if (!err) {
 			res->mnt = mntget(path.mnt);
 			res->dentry = dget(dentry);
+			ima_dir_update(&path, dentry);
 		}
 	}
 	done_path_create(&path, dentry);
security/integrity/ima/ima_main.c +0 -0
index 6c12811..18d76d8 100644
@@ -300,6 +300,9 @@ int ima_bprm_check(struct linux_binprm *bprm)
  */
Quoted 10 lines

security/integrity/ima/ima_main.c int ima_bprm_check(struct linux_binprm *bprm) · line 308

Quoted 8 lines
security/integrity/ima/ima_main.c +3 -0
 int ima_file_check(struct file *file, int mask)
 {
+	if (!S_ISREG(file->f_dentry->d_inode->i_mode))
+		return ima_special_check(file, mask);
+
 	ima_rdwr_violation_check(file);
 	return process_measurement(file, NULL,
 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),

Thanks

--
To unsubscribe from this list: send the line "unsubscribe linux-security-module" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#6 lore raw

PATCH 2/2 ima: directory integrity protection implementation

In reply to Dmitry Kasatkin

This patch provides implmentation of directory integrity protection hooks.

This patch implements ima_dir_check() and ima_dir_update() hooks.

ima_dir_check() verifies the directory integrity during the initial path lookup, when the dentry is just being created and may block. It allocates the needed data structures and performs the integrity verification. The results of which are cached. Subsequent calls mostly happen under RCU locking, when the code may not block, and returns immediately with the cached verification status. So ima_dir_check() does not interrupt RCU path walk.

Directory hash is a hash over the list of directory entries, that includes name, ino and d_type. ima_dir_check() caclculates a directory hash and compaires it against good reference value stored in 'security.ima' extended attribute.

ima_dir_update() is called when directory content is changing, and updates the directory hash.

---
 security/integrity/ima/Kconfig      |  10 +
 security/integrity/ima/Makefile     |   1 +
 security/integrity/ima/ima.h        |   3 +-
 security/integrity/ima/ima_dir.c    | 358 ++++++++++++++++++++++++++++++++++++
 security/integrity/ima/ima_policy.c |   2 +
 5 files changed, 373 insertions(+), 1 deletion(-)
 create mode 100644 security/integrity/ima/ima_dir.c
security/integrity/ima/Kconfig +10 -0
index dad8d4c..ec4ef2a 100644
@@ -131,3 +131,13 @@ config IMA_TRUSTED_KEYRING
 	help
 	   This option requires that all keys added to the _ima
 	   keyring be signed by a key on the system trusted keyring.
+
+config IMA_APPRAISE_DIRECTORIES
+	bool "Performs directory integrity appraisal"
+	depends on IMA_APPRAISE
+	default n
+	help
+	  This option enables directory integrity appraisal.
+
+	  If unsure, say N.
+
security/integrity/ima/Makefile +1 -0
index d79263d..518450a 100644
@@ -8,3 +8,4 @@ obj-$(CONFIG_IMA) += ima.o
 ima-y := ima_fs.o ima_queue.o ima_init.o ima_main.o ima_crypto.o ima_api.o \
 	 ima_policy.o ima_template.o ima_template_lib.o
 ima-$(CONFIG_IMA_APPRAISE) += ima_appraise.o
+ima-$(CONFIG_IMA_APPRAISE_DIRECTORIES) += ima_dir.o
security/integrity/ima/ima.h +2 -1
index 6b326a2..fa2dd8b 100644
@@ -160,7 +160,8 @@ struct integrity_iint_cache *integrity_iint_insert(struct inode *inode);
 struct integrity_iint_cache *integrity_iint_find(struct inode *inode);
 
 /* IMA policy related functions */
-enum ima_hooks { FILE_CHECK = 1, MMAP_CHECK, BPRM_CHECK, MODULE_CHECK, POST_SETATTR };
+enum ima_hooks { FILE_CHECK = 1, MMAP_CHECK, BPRM_CHECK, MODULE_CHECK,
+		 POST_SETATTR, DIR_CHECK };
 
 int ima_match_policy(struct dentry *dentry, enum ima_hooks func, int mask,
 		     int flags);
security/integrity/ima/ima_dir.c new file +358 -0

358 lines not on this page · raw message

security/integrity/ima/ima_policy.c +2 -0
index 317826d..9051e3f 100644
@@ -516,6 +516,8 @@ static int ima_parse_rule(char *rule, struct ima_rule_entry *entry)
 				entry->func = MMAP_CHECK;
 			else if (strcmp(args[0].from, "BPRM_CHECK") == 0)
 				entry->func = BPRM_CHECK;
+			else if (strcmp(args[0].from, "DIR_CHECK") == 0)
+				entry->func = DIR_CHECK;
 			else
 				result = -EINVAL;
 			if (!result)
Signature · 1 line
1.8.3.2