Skip to contentSkip to conversation

Add support for O_MAYEXEC

PATCH Superseded Mickaël Salaün 13 participants 44 messages Jul 23, 2020 – Aug 13, 2020

Subsystems (13)

v7 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v7 cover Add support for O_MAYEXEC

Hi,

This seventh patch series do not set __FMODE_EXEC for the sake of simplicity. A notification feature could be added later if needed. The handling of all file types is now well defined and tested: by default, when opening a path, access to a directory is denied (with EISDIR), access to a regular file depends on the sysctl policy, and access to other file types (i.e. fifo, device, socket) is denied if there is any enforced policy. There is new tests covering all these cases (cf. test_file_types() ).

As requested by Mimi Zohar, I completed the series with one of her patches for IMA. I also picked Kees Cook's patches to consolidate exec permission checking into do_filp_open()'s flow.

# Goal of O_MAYEXEC

The goal of this patch series is to enable to control script execution with interpreters help. A new O_MAYEXEC flag, usable through openat2(2), is added to enable userspace script interpreters to delegate to the kernel (and thus the system security policy) the permission to interpret/execute scripts or other files containing what can be seen as commands.

A simple system-wide security policy can be enforced by the system administrator through a sysctl configuration consistent with the mount points or the file access rights. The documentation patch explains the prerequisites.

Furthermore, the security policy can also be delegated to an LSM, either a MAC system or an integrity system. For instance, the new kernel MAY_OPENEXEC flag closes a major IMA measurement/appraisal interpreter integrity gap by bringing the ability to check the use of scripts [1]. Other uses are expected, such as for magic-links [2], SGX integration [3], bpffs [4] or IPE [5].

# Prerequisite of its use

Userspace needs to adapt to take advantage of this new feature. For example, the PEP 578 [6] (Runtime Audit Hooks) enables Python 3.8 to be extended with policy enforcement points related to code interpretation, which can be used to align with the PowerShell audit features. Additional Python security improvements (e.g. a limited interpreter withou -c, stdin piping of code) are on their way [7].

# Examples

The initial idea comes from CLIP OS 4 and the original implementation has been used for more than 12 years:
https://github.com/clipos-archive/clipos4_doc
Chrome OS has a similar approach:
https://chromium.googlesource.com/chromiumos/docs/+/master/security/noexec_shell_scripts.md

Userland patches can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC
Actually, there is more than the O_MAYEXEC changes (which matches this search) e.g., to prevent Python interactive execution. There are patches for Bash, Wine, Java (Icedtea), Busybox's ash, Perl and Python. There are also some related patches which do not directly rely on O_MAYEXEC but which restrict the use of browser plugins and extensions, which may be seen as scripts too:
https://github.com/clipos-archive/clipos4_portage-overlay/tree/master/www-client

An introduction to O_MAYEXEC was given at the Linux Security Summit Europe 2018 - Linux Kernel Security Contributions by ANSSI:
https://www.youtube.com/watch?v=chNjCRtPKQY&t=17m15s
The "write xor execute" principle was explained at Kernel Recipes 2018 - CLIP OS: a defense-in-depth OS:
https://www.youtube.com/watch?v=PjRE0uBtkHU&t=11m14s
See also an overview article: https://lwn.net/Articles/820000/

This patch series can be applied on top of v5.8-rc5 . This can be tested with CONFIG_SYSCTL. I would really appreciate constructive comments on this patch series.

Previous version:
https://lore.kernel.org/lkml/[email protected]/

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/[email protected]/
[3] https://lore.kernel.org/lkml/CALCETrVovr8XNZSroey7pHF46O=kj_c5D9K8h=z2T_cNrpvMig@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CALCETrVeZ0eufFXwfhtaG_j+AdvbzEWE0M3wjXMWVEO7pj+xkw@mail.gmail.com/
[5] https://lore.kernel.org/lkml/[email protected]/
[6] https://www.python.org/dev/peps/pep-0578/
[7] https://lore.kernel.org/lkml/[email protected]/

Regards,

Kees Cook (3):
exec: Change uselib(2) IS_SREG() failure to EACCES
exec: Move S_ISREG() check earlier
exec: Move path_noexec() check earlier

Mickaël Salaün (3):
fs: Introduce O_MAYEXEC flag for openat2(2)
fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC selftest/openat2: Add tests for O_MAYEXEC enforcing

Mimi Zohar (1):
ima: add policy support for the new file open MAY_OPENEXEC flag

 Documentation/ABI/testing/ima_policy          |   2 +-
 Documentation/admin-guide/sysctl/fs.rst       |  49 +++
 fs/exec.c                                     |  23 +-
 fs/fcntl.c                                    |   2 +-
 fs/namei.c                                    |  36 +-
 fs/open.c                                     |  12 +-
 include/linux/fcntl.h                         |   2 +-
 include/linux/fs.h                            |   3 +
 include/uapi/asm-generic/fcntl.h              |   7 +
 kernel/sysctl.c                               |  12 +-
 security/integrity/ima/ima_main.c             |   3 +-
 security/integrity/ima/ima_policy.c           |  15 +-
 tools/testing/selftests/kselftest_harness.h   |   3 +
 tools/testing/selftests/openat2/Makefile      |   3 +-
 tools/testing/selftests/openat2/config        |   1 +
 tools/testing/selftests/openat2/helpers.h     |   1 +
 .../testing/selftests/openat2/omayexec_test.c | 325 ++++++++++++++++++
 17 files changed, 470 insertions(+), 29 deletions(-)
 create mode 100644 tools/testing/selftests/openat2/config
 create mode 100644 tools/testing/selftests/openat2/omayexec_test.c
Signature · 1 line
2.27.0
#1 lore raw

PATCH v7 1/7 exec: Change uselib(2) IS_SREG() failure to EACCES

From: Kees Cook <[email protected]>

Change uselib(2)' S_ISREG() error return to EACCES instead of EINVAL so the behavior matches execve(2), and the seemingly documented value. The "not a regular file" failure mode of execve(2) is explicitly documented[1], but it is not mentioned in uselib(2)[2] which does, however, say that open(2) and mmap(2) errors may apply. The documentation for open(2) does not include a "not a regular file" error[3], but mmap(2) does[4], and it is EACCES.

[1] http://man7.org/linux/man-pages/man2/execve.2.html#ERRORS
[2] http://man7.org/linux/man-pages/man2/uselib.2.html#ERRORS
[3] http://man7.org/linux/man-pages/man2/open.2.html#ERRORS
[4] http://man7.org/linux/man-pages/man2/mmap.2.html#ERRORS

---
 fs/exec.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
fs/exec.c +1 -2
index e6e8a9a70327..d7c937044d10 100644
@@ -141,11 +141,10 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	if (IS_ERR(file))
 		goto out;
 
-	error = -EINVAL;
+	error = -EACCES;
 	if (!S_ISREG(file_inode(file)->i_mode))
 		goto exit;
 
-	error = -EACCES;
 	if (path_noexec(&file->f_path))
 		goto exit;
 
Signature · 1 line
2.27.0
#2 lore raw

Re: [PATCH v7 1/7] exec: Change uselib(2) IS_SREG() failure to EACCES

Quoted 9 lines · Mickaël Salaün

From: Kees Cook <[email protected]>

Change uselib(2)' S_ISREG() error return to EACCES instead of EINVAL so the behavior matches execve(2), and the seemingly documented value. The "not a regular file" failure mode of execve(2) is explicitly documented[1], but it is not mentioned in uselib(2)[2] which does, however, say that open(2) and mmap(2) errors may apply. The documentation for open(2) does not include a "not a regular file" error[3], but mmap(2) does[4], and it is EACCES.

Do you have enough visibility into uselib to be certain this will change will not cause regressions?

My sense of uselib is that it would be easier to remove the system call entirely (I think it's last use was in libc5) than to validate that a change like this won't cause problems for the users of uselib.

For the kernel what is important are real world users and the manpages are only important as far as they suggest what the real world users do.

Eric

Quoted 29 lines

[1] http://man7.org/linux/man-pages/man2/execve.2.html#ERRORS
[2] http://man7.org/linux/man-pages/man2/uselib.2.html#ERRORS
[3] http://man7.org/linux/man-pages/man2/open.2.html#ERRORS
[4] http://man7.org/linux/man-pages/man2/mmap.2.html#ERRORS

---
 fs/exec.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
fs/exec.c +1 -2
index e6e8a9a70327..d7c937044d10 100644
@@ -141,11 +141,10 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	if (IS_ERR(file))
 		goto out;
 
-	error = -EINVAL;
+	error = -EACCES;
 	if (!S_ISREG(file_inode(file)->i_mode))
 		goto exit;
 
-	error = -EACCES;
 	if (path_noexec(&file->f_path))
 		goto exit;
#3 lore raw

Re: [PATCH v7 1/7] exec: Change uselib(2) IS_SREG() failure to EACCES

Quoted 15 lines · [email protected] (Eric W. Biederman) writes:
Quoted 9 lines · Mickaël Salaün

From: Kees Cook <[email protected]>

Change uselib(2)' S_ISREG() error return to EACCES instead of EINVAL so the behavior matches execve(2), and the seemingly documented value. The "not a regular file" failure mode of execve(2) is explicitly documented[1], but it is not mentioned in uselib(2)[2] which does, however, say that open(2) and mmap(2) errors may apply. The documentation for open(2) does not include a "not a regular file" error[3], but mmap(2) does[4], and it is EACCES.

Do you have enough visibility into uselib to be certain this will change will not cause regressions?

Quoted 7 lines

My sense of uselib is that it would be easier to remove the system call entirely (I think it's last use was in libc5) than to validate that a change like this won't cause problems for the users of uselib.

For the kernel what is important are real world users and the manpages are only important as far as they suggest what the real world users do.

Hmm.

My apologies. After reading the next patch I see that what really makes this safe is: 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()").

As in practice this change has already been made and uselib simply can not reach the !S_ISREG test.

It might make sense to drop this patch or include that reference in the next posting of this patch.

Eric

#4 lore raw

PATCH v7 2/7 exec: Move S_ISREG() check earlier

In reply to Mickaël Salaün

From: Kees Cook <[email protected]>

The execve(2)/uselib(2) syscalls have always rejected non-regular files. Recently, it was noticed that a deadlock was introduced when trying to execute pipes, as the S_ISREG() test was happening too late. This was fixed in commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()"), but it was added after inode_permission() had already run, which meant LSMs could see bogus attempts to execute non-regular files.

Move the test into the other inode type checks (which already look for other pathological conditions[1]). Since there is no need to use FMODE_EXEC while we still have access to "acc_mode", also switch the test to MAY_EXEC.

Also include a comment with the redundant S_ISREG() checks at the end of execve(2)/uselib(2) to note that they are present to avoid any mistakes.

My notes on the call path, and related arguments, checks, etc:

do_open_execat()
struct open_flags open_exec_flags = {
.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC, .acc_mode = MAY_EXEC,
...
do_filp_open(dfd, filename, open_flags)
path_openat(nameidata, open_flags, flags)
file = alloc_empty_file(open_flags, current_cred()); do_open(nameidata, file, open_flags)
may_open(path, acc_mode, open_flag)
/* new location of MAY_EXEC vs S_ISREG() test */ inode_permission(inode, MAY_OPEN | acc_mode)
security_inode_permission(inode, acc_mode)
vfs_open(path, file)
do_dentry_open(file, path->dentry->d_inode, open)
/* old location of FMODE_EXEC vs S_ISREG() test */ security_file_open(f)
open()

[1] https://lore.kernel.org/lkml/202006041910.9EF0C602@keescook/

---
 fs/exec.c  | 14 ++++++++++++--
 fs/namei.c |  6 ++++--
 fs/open.c  |  6 ------
 3 files changed, 16 insertions(+), 10 deletions(-)
fs/exec.c +12 -2
index d7c937044d10..bdc6a6eb5dce 100644
@@ -141,8 +141,13 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	if (IS_ERR(file))
 		goto out;
 
+	/*
+	 * may_open() has already checked for this, so it should be
+	 * impossible to trip now. But we need to be extra cautious
+	 * and check again at the very end too.
+	 */
 	error = -EACCES;
-	if (!S_ISREG(file_inode(file)->i_mode))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
 		goto exit;
 
 	if (path_noexec(&file->f_path))
@@ -886,8 +891,13 @@ static struct file *do_open_execat(int fd, struct filename *name, int flags)
 	if (IS_ERR(file))
 		goto out;
 
+	/*
+	 * may_open() has already checked for this, so it should be
+	 * impossible to trip now. But we need to be extra cautious
+	 * and check again at the very end too.
+	 */
 	err = -EACCES;
-	if (!S_ISREG(file_inode(file)->i_mode))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
 		goto exit;
 
 	if (path_noexec(&file->f_path))
fs/namei.c +4 -2
index 72d4219c93ac..a559ad943970 100644
@@ -2849,16 +2849,18 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFLNK:
 		return -ELOOP;
 	case S_IFDIR:
-		if (acc_mode & MAY_WRITE)
+		if (acc_mode & (MAY_WRITE | MAY_EXEC))
 			return -EISDIR;
 		break;
 	case S_IFBLK:
 	case S_IFCHR:
 		if (!may_open_dev(path))
 			return -EACCES;
-		/*FALLTHRU*/
+		fallthrough;
 	case S_IFIFO:
 	case S_IFSOCK:
+		if (acc_mode & MAY_EXEC)
+			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
 	}
fs/open.c +0 -6
index 6cd48a61cda3..623b7506a6db 100644
@@ -784,12 +784,6 @@ static int do_dentry_open(struct file *f,
 		return 0;
 	}
 
-	/* Any file opened for execve()/uselib() has to be a regular file. */
-	if (unlikely(f->f_flags & FMODE_EXEC && !S_ISREG(inode->i_mode))) {
-		error = -EACCES;
-		goto cleanup_file;
-	}
-
 	if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
 		error = get_write_access(inode);
 		if (unlikely(error))
Signature · 1 line
2.27.0
#5 lore raw

Re: [PATCH v7 2/7] exec: Move S_ISREG() check earlier

Quoted 10 lines · Mickaël Salaün

From: Kees Cook <[email protected]>

The execve(2)/uselib(2) syscalls have always rejected non-regular files. Recently, it was noticed that a deadlock was introduced when trying to execute pipes, as the S_ISREG() test was happening too late. This was fixed in commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()"), but it was added after inode_permission() had already run, which meant LSMs could see bogus attempts to execute non-regular files.

Quoted 7 lines

Move the test into the other inode type checks (which already look for other pathological conditions[1]). Since there is no need to use FMODE_EXEC while we still have access to "acc_mode", also switch the test to MAY_EXEC.

Also include a comment with the redundant S_ISREG() checks at the end of execve(2)/uselib(2) to note that they are present to avoid any mistakes.

The comment is:

fs/exec.c SYSCALL_DEFINE1(uselib, const char __user *, library) · line 148

Quoted 5 lines
fs/exec.c +5 -0
+	/*
+	 * may_open() has already checked for this, so it should be
+	 * impossible to trip now. But we need to be extra cautious
+	 * and check again at the very end too.
+	 */

Those comments scare me. Why do you need to be extra cautious? How can the file type possibly change between may_open and anywhere? The type of a file is immutable after it's creation.

If the comment said check just in case something went wrong with code maintenance I could understand but that isn't what the comment says.

Also the fallthrough change below really should be broken out into it's own change.

Quoted 74 lines

My notes on the call path, and related arguments, checks, etc:

do_open_execat()
struct open_flags open_exec_flags = {
.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC, .acc_mode = MAY_EXEC,
...
do_filp_open(dfd, filename, open_flags)
path_openat(nameidata, open_flags, flags)
file = alloc_empty_file(open_flags, current_cred()); do_open(nameidata, file, open_flags)
may_open(path, acc_mode, open_flag)
/* new location of MAY_EXEC vs S_ISREG() test */ inode_permission(inode, MAY_OPEN | acc_mode)
security_inode_permission(inode, acc_mode)
vfs_open(path, file)
do_dentry_open(file, path->dentry->d_inode, open)
/* old location of FMODE_EXEC vs S_ISREG() test */ security_file_open(f)
open()

[1] https://lore.kernel.org/lkml/202006041910.9EF0C602@keescook/

---
 fs/exec.c  | 14 ++++++++++++--
 fs/namei.c |  6 ++++--
 fs/open.c  |  6 ------
 3 files changed, 16 insertions(+), 10 deletions(-)
fs/exec.c +12 -2
index d7c937044d10..bdc6a6eb5dce 100644
@@ -141,8 +141,13 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	if (IS_ERR(file))
 		goto out;
 
+	/*
+	 * may_open() has already checked for this, so it should be
+	 * impossible to trip now. But we need to be extra cautious
+	 * and check again at the very end too.
+	 */
 	error = -EACCES;
-	if (!S_ISREG(file_inode(file)->i_mode))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
 		goto exit;
 
 	if (path_noexec(&file->f_path))
@@ -886,8 +891,13 @@ static struct file *do_open_execat(int fd, struct filename *name, int flags)
 	if (IS_ERR(file))
 		goto out;
 
+	/*
+	 * may_open() has already checked for this, so it should be
+	 * impossible to trip now. But we need to be extra cautious
+	 * and check again at the very end too.
+	 */
 	err = -EACCES;
-	if (!S_ISREG(file_inode(file)->i_mode))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
 		goto exit;
 
 	if (path_noexec(&file->f_path))
fs/namei.c +0 -0
index 72d4219c93ac..a559ad943970 100644
@@ -2849,16 +2849,18 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFLNK:
 		return -ELOOP;
 	case S_IFDIR:

fs/namei.c static int may_open(const struct path *path, int acc_mode, int flag) · line 2859

Quoted 10 lines
fs/namei.c +2 -2
-		if (acc_mode & MAY_WRITE)
+		if (acc_mode & (MAY_WRITE | MAY_EXEC))
 			return -EISDIR;
 		break;
 	case S_IFBLK:
 	case S_IFCHR:
 		if (!may_open_dev(path))
 			return -EACCES;
-		/*FALLTHRU*/
+		fallthrough;
                ^^^^^^^^^^^

That is an unrelated change and should be sent separately.

Quoted 24 lines
fs/namei.c +2 -0
 	case S_IFIFO:
 	case S_IFSOCK:
+		if (acc_mode & MAY_EXEC)
+			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
 	}
fs/open.c +0 -6
index 6cd48a61cda3..623b7506a6db 100644
@@ -784,12 +784,6 @@ static int do_dentry_open(struct file *f,
 		return 0;
 	}
 
-	/* Any file opened for execve()/uselib() has to be a regular file. */
-	if (unlikely(f->f_flags & FMODE_EXEC && !S_ISREG(inode->i_mode))) {
-		error = -EACCES;
-		goto cleanup_file;
-	}
-
 	if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
 		error = get_write_access(inode);
 		if (unlikely(error))
#6 lore raw

PATCH v7 3/7 exec: Move path_noexec() check earlier

In reply to Mickaël Salaün

From: Kees Cook <[email protected]>

The path_noexec() check, like the regular file check, was happening too late, letting LSMs see impossible execve()s. Check it earlier as well in may_open() and collect the redundant fs/exec.c path_noexec() test under the same robustness comment as the S_ISREG() check.

My notes on the call path, and related arguments, checks, etc:

do_open_execat()
struct open_flags open_exec_flags = {
.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC, .acc_mode = MAY_EXEC,
...
do_filp_open(dfd, filename, open_flags)
path_openat(nameidata, open_flags, flags)
file = alloc_empty_file(open_flags, current_cred()); do_open(nameidata, file, open_flags)
may_open(path, acc_mode, open_flag)
/* new location of MAY_EXEC vs path_noexec() test */ inode_permission(inode, MAY_OPEN | acc_mode)
security_inode_permission(inode, acc_mode)
vfs_open(path, file)
do_dentry_open(file, path->dentry->d_inode, open)
security_file_open(f)
open()
/* old location of path_noexec() test */

---
 fs/exec.c  | 12 ++++--------
 fs/namei.c |  4 ++++
 2 files changed, 8 insertions(+), 8 deletions(-)
fs/exec.c +4 -8
index bdc6a6eb5dce..4eea20c27b01 100644
@@ -147,10 +147,8 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	 * and check again at the very end too.
 	 */
 	error = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	fsnotify_open(file);
@@ -897,10 +895,8 @@ static struct file *do_open_execat(int fd, struct filename *name, int flags)
 	 * and check again at the very end too.
 	 */
 	err = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	err = deny_write_access(file);
fs/namei.c +4 -0
index a559ad943970..ddc9b25540fe 100644
@@ -2863,6 +2863,10 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
+	case S_IFREG:
+		if ((acc_mode & MAY_EXEC) && path_noexec(path))
+			return -EACCES;
+		break;
 	}
 
 	error = inode_permission(inode, MAY_OPEN | acc_mode);
Signature · 1 line
2.27.0
#7 lore raw

Re: [PATCH v7 3/7] exec: Move path_noexec() check earlier

Quoted 8 lines · Mickaël Salaün

From: Kees Cook <[email protected]>

The path_noexec() check, like the regular file check, was happening too late, letting LSMs see impossible execve()s. Check it earlier as well in may_open() and collect the redundant fs/exec.c path_noexec() test under the same robustness comment as the S_ISREG() check.

My notes on the call path, and related arguments, checks, etc:

A big question arises, that I think someone already asked.

Why perform this test in may_open directly instead of moving it into inode_permission. That way the code can be shared with faccessat, and any other code path that wants it?

That would look to provide a more maintainable kernel.

Eric

Quoted 72 lines

do_open_execat()
struct open_flags open_exec_flags = {
.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC, .acc_mode = MAY_EXEC,
...
do_filp_open(dfd, filename, open_flags)
path_openat(nameidata, open_flags, flags)
file = alloc_empty_file(open_flags, current_cred()); do_open(nameidata, file, open_flags)
may_open(path, acc_mode, open_flag)
/* new location of MAY_EXEC vs path_noexec() test */ inode_permission(inode, MAY_OPEN | acc_mode)
security_inode_permission(inode, acc_mode)
vfs_open(path, file)
do_dentry_open(file, path->dentry->d_inode, open)
security_file_open(f)
open()
/* old location of path_noexec() test */

---
 fs/exec.c  | 12 ++++--------
 fs/namei.c |  4 ++++
 2 files changed, 8 insertions(+), 8 deletions(-)
fs/exec.c +4 -8
index bdc6a6eb5dce..4eea20c27b01 100644
@@ -147,10 +147,8 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	 * and check again at the very end too.
 	 */
 	error = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	fsnotify_open(file);
@@ -897,10 +895,8 @@ static struct file *do_open_execat(int fd, struct filename *name, int flags)
 	 * and check again at the very end too.
 	 */
 	err = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	err = deny_write_access(file);
fs/namei.c +4 -0
index a559ad943970..ddc9b25540fe 100644
@@ -2863,6 +2863,10 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
+	case S_IFREG:
+		if ((acc_mode & MAY_EXEC) && path_noexec(path))
+			return -EACCES;
+		break;
 	}
 
 	error = inode_permission(inode, MAY_OPEN | acc_mode);
#8 lore raw

Re: [PATCH v7 3/7] exec: Move path_noexec() check earlier

Kees Cook wrote this patch, which is in Andrew Morton's tree, but I think you're talking about O_MAYEXEC, not this patch specifically.

Quoted 4 lines · Eric W. Biederman
Quoted 2 lines · Mickaël Salaün

From: Kees Cook <[email protected]>

Quoted 8 lines
Quoted 6 lines

The path_noexec() check, like the regular file check, was happening too late, letting LSMs see impossible execve()s. Check it earlier as well in may_open() and collect the redundant fs/exec.c path_noexec() test under the same robustness comment as the S_ISREG() check.

My notes on the call path, and related arguments, checks, etc:

A big question arises, that I think someone already asked.

Al Viro and Jann Horn expressed such concerns for O_MAYEXEC:
https://lore.kernel.org/lkml/[email protected]/

Quoted 4 lines

Why perform this test in may_open directly instead of moving it into inode_permission. That way the code can be shared with faccessat, and any other code path that wants it?

This patch is just a refactoring.

About O_MAYEXEC, path-based LSM, IMA and IPE need to work on a struct file, whereas inode_permission() only gives a struct inode. However, faccessat2(2) (with extended flags) seems to be the perfect candidate if we want to be able to check file descriptors.

Quoted 2 lines

That would look to provide a more maintainable kernel.

Why would it be more maintainable?

Quoted 76 lines

Eric

Quoted 72 lines

do_open_execat()
struct open_flags open_exec_flags = {
.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC, .acc_mode = MAY_EXEC,
...
do_filp_open(dfd, filename, open_flags)
path_openat(nameidata, open_flags, flags)
file = alloc_empty_file(open_flags, current_cred()); do_open(nameidata, file, open_flags)
may_open(path, acc_mode, open_flag)
/* new location of MAY_EXEC vs path_noexec() test */ inode_permission(inode, MAY_OPEN | acc_mode)
security_inode_permission(inode, acc_mode)
vfs_open(path, file)
do_dentry_open(file, path->dentry->d_inode, open)
security_file_open(f)
open()
/* old location of path_noexec() test */

---
 fs/exec.c  | 12 ++++--------
 fs/namei.c |  4 ++++
 2 files changed, 8 insertions(+), 8 deletions(-)
fs/exec.c +4 -8
index bdc6a6eb5dce..4eea20c27b01 100644
@@ -147,10 +147,8 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	 * and check again at the very end too.
 	 */
 	error = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	fsnotify_open(file);
@@ -897,10 +895,8 @@ static struct file *do_open_execat(int fd, struct filename *name, int flags)
 	 * and check again at the very end too.
 	 */
 	err = -EACCES;
-	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode)))
-		goto exit;
-
-	if (path_noexec(&file->f_path))
+	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||
+			 path_noexec(&file->f_path)))
 		goto exit;
 
 	err = deny_write_access(file);
fs/namei.c +4 -0
index a559ad943970..ddc9b25540fe 100644
@@ -2863,6 +2863,10 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
+	case S_IFREG:
+		if ((acc_mode & MAY_EXEC) && path_noexec(path))
+			return -EACCES;
+		break;
 	}
 
 	error = inode_permission(inode, MAY_OPEN | acc_mode);
#9 lore raw

PATCH v7 4/7 fs: Introduce O_MAYEXEC flag for openat2(2)

In reply to Mickaël Salaün

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

The underlying idea is to be able to restrict scripts interpretation according to a policy defined by the system administrator. For this to be possible, script interpreters must use the O_MAYEXEC flag appropriately. To be fully effective, these interpreters also need to handle the other ways to execute code: command line parameters (e.g., option -e for Perl), module loading (e.g., option -m for Python), stdin, file sourcing, environment variables, configuration files, etc. According to the threat model, it may be acceptable to allow some script interpreters (e.g. Bash) to interpret commands from stdin, may it be a TTY or a pipe, because it may not be enough to (directly) perform syscalls. Further documentation can be found in a following patch.

Even without enforced security policy, userland interpreters can set it to enforce the system policy at their level, knowing that it will not break anything on running systems which do not care about this feature. However, on systems which want this feature enforced, there will be knowledgeable people (i.e. sysadmins who enforced O_MAYEXEC deliberately) to manage it. A simple security policy implementation, configured through a dedicated sysctl, is available in a following patch.

O_MAYEXEC should not be confused with the O_EXEC flag which is intended for execute-only, which obviously doesn't work for scripts. However, a similar behavior could be implemented in userland with O_PATH:
https://lore.kernel.org/lkml/[email protected]/

The implementation of O_MAYEXEC almost duplicates what execve(2) and uselib(2) are already doing: setting MAY_OPENEXEC in acc_mode (which can then be checked as MAY_EXEC, if enforced).

This is an updated subset of the patch initially written by Vincent Strubel for CLIP OS 4:
https://github.com/clipos-archive/src_platform_clip-patches/blob/f5cb330d6b684752e403b4e41b39f7004d88e561/1901_open_mayexec.patch
This patch has been used for more than 12 years with customized script interpreters. Some examples (with the original O_MAYEXEC) can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC

---

Changes since v6:
* Do not set __FMODE_EXEC for now because of inconsistent behavior:
https://lore.kernel.org/lkml/202007160822.CCDB5478@keescook/
* Returns EISDIR when opening a directory with O_MAYEXEC.
* Removed Deven Bowers and Kees Cook Reviewed-by tags because of the current update.

Changes since v5:
* Update commit message.

Changes since v3:
* Switch back to O_MAYEXEC, but only handle it with openat2(2) which checks unknown flags (suggested by Aleksa Sarai). Cf.
https://lore.kernel.org/lkml/[email protected]/

Changes since v2:
* Replace O_MAYEXEC with RESOLVE_MAYEXEC from openat2(2). This change enables to not break existing application using bogus O_* flags that may be ignored by current kernels by using a new dedicated flag, only usable through openat2(2) (suggested by Jeff Layton). Using this flag will results in an error if the running kernel does not support it. User space needs to manage this case, as with other RESOLVE_* flags. The best effort approach to security (for most common distros) will simply consists of ignoring such an error and retry without RESOLVE_MAYEXEC. However, a fully controlled system may which to error out if such an inconsistency is detected.

Changes since v1:
* Set __FMODE_EXEC when using O_MAYEXEC to make this information available through the new fanotify/FAN_OPEN_EXEC event (suggested by Jan Kara and Matthew Bobrowski):
https://lore.kernel.org/lkml/[email protected]/

---
 fs/fcntl.c                       | 2 +-
 fs/namei.c                       | 4 ++--
 fs/open.c                        | 6 ++++++
 include/linux/fcntl.h            | 2 +-
 include/linux/fs.h               | 2 ++
 include/uapi/asm-generic/fcntl.h | 7 +++++++
 6 files changed, 19 insertions(+), 4 deletions(-)
fs/fcntl.c +1 -1
index 2e4c0fa2074b..0357ad667563 100644
@@ -1033,7 +1033,7 @@ static int __init fcntl_init(void)
 	 * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
 	 * is defined as O_NONBLOCK on some platforms and not on others.
 	 */
-	BUILD_BUG_ON(21 - 1 /* for O_RDONLY being 0 */ !=
+	BUILD_BUG_ON(22 - 1 /* for O_RDONLY being 0 */ !=
 		HWEIGHT32(
 			(VALID_OPEN_FLAGS & ~(O_NONBLOCK | O_NDELAY)) |
 			__FMODE_EXEC | __FMODE_NONOTIFY));
fs/namei.c +2 -2
index ddc9b25540fe..3f074ec77390 100644
@@ -428,7 +428,7 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
- * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, %MAY_OPENEXEC)
  *
  * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
  * this, letting us set arbitrary permissions for filesystem access without
@@ -2849,7 +2849,7 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFLNK:
 		return -ELOOP;
 	case S_IFDIR:
-		if (acc_mode & (MAY_WRITE | MAY_EXEC))
+		if (acc_mode & (MAY_WRITE | MAY_EXEC | MAY_OPENEXEC))
 			return -EISDIR;
 		break;
 	case S_IFBLK:
fs/open.c +6 -0
index 623b7506a6db..21c2c1020574 100644
@@ -987,6 +987,8 @@ inline struct open_how build_open_how(int flags, umode_t mode)
 		.mode = mode & S_IALLUGO,
 	};
 
+	/* O_MAYEXEC is ignored by syscalls relying on build_open_how(). */
+	how.flags &= ~O_MAYEXEC;
 	/* O_PATH beats everything else. */
 	if (how.flags & O_PATH)
 		how.flags &= O_PATH_FLAGS;
@@ -1054,6 +1056,10 @@ inline int build_open_flags(const struct open_how *how, struct open_flags *op)
 	if (flags & __O_SYNC)
 		flags |= O_DSYNC;
 
+	/* Checks execution permissions on open. */
+	if (flags & O_MAYEXEC)
+		acc_mode |= MAY_OPENEXEC;
+
 	op->open_flag = flags;
 
 	/* O_TRUNC implies we need access checks for write permissions */
include/linux/fcntl.h +1 -1
index 7bcdcf4f6ab2..e188a360fa5f 100644
@@ -10,7 +10,7 @@
 	(O_RDONLY | O_WRONLY | O_RDWR | O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC | \
 	 O_APPEND | O_NDELAY | O_NONBLOCK | O_NDELAY | __O_SYNC | O_DSYNC | \
 	 FASYNC	| O_DIRECT | O_LARGEFILE | O_DIRECTORY | O_NOFOLLOW | \
-	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE)
+	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE | O_MAYEXEC)
 
 /* List of all valid flags for the how->upgrade_mask argument: */
 #define VALID_UPGRADE_FLAGS \
include/linux/fs.h +2 -0
index f5abba86107d..56f835c9a87a 100644
@@ -101,6 +101,8 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define MAY_CHDIR		0x00000040
 /* called from RCU mode, don't block */
 #define MAY_NOT_BLOCK		0x00000080
+/* the inode is opened with O_MAYEXEC */
+#define MAY_OPENEXEC		0x00000100
 
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
include/uapi/asm-generic/fcntl.h +7 -0
index 9dc0bf0c5a6e..bca90620119f 100644
@@ -97,6 +97,13 @@
 #define O_NDELAY	O_NONBLOCK
 #endif
 
+/*
+ * Code execution from file is intended, checks such permission.  A simple
+ * policy can be enforced system-wide as explained in
+ * Documentation/admin-guide/sysctl/fs.rst .
+ */
+#define O_MAYEXEC	040000000
+
 #define F_DUPFD		0	/* dup */
 #define F_GETFD		1	/* get close_on_exec */
 #define F_SETFD		2	/* set/clear close_on_exec */
Signature · 1 line
2.27.0
Acked-by on v7 4/7
#10 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

Quoted 45 lines · Mickaël Salaün

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

The underlying idea is to be able to restrict scripts interpretation according to a policy defined by the system administrator. For this to be possible, script interpreters must use the O_MAYEXEC flag appropriately. To be fully effective, these interpreters also need to handle the other ways to execute code: command line parameters (e.g., option -e for Perl), module loading (e.g., option -m for Python), stdin, file sourcing, environment variables, configuration files, etc. According to the threat model, it may be acceptable to allow some script interpreters (e.g. Bash) to interpret commands from stdin, may it be a TTY or a pipe, because it may not be enough to (directly) perform syscalls. Further documentation can be found in a following patch.

Even without enforced security policy, userland interpreters can set it to enforce the system policy at their level, knowing that it will not break anything on running systems which do not care about this feature. However, on systems which want this feature enforced, there will be knowledgeable people (i.e. sysadmins who enforced O_MAYEXEC deliberately) to manage it. A simple security policy implementation, configured through a dedicated sysctl, is available in a following patch.

O_MAYEXEC should not be confused with the O_EXEC flag which is intended for execute-only, which obviously doesn't work for scripts. However, a similar behavior could be implemented in userland with O_PATH:
https://lore.kernel.org/lkml/[email protected]/

The implementation of O_MAYEXEC almost duplicates what execve(2) and uselib(2) are already doing: setting MAY_OPENEXEC in acc_mode (which can then be checked as MAY_EXEC, if enforced).

This is an updated subset of the patch initially written by Vincent Strubel for CLIP OS 4:
https://github.com/clipos-archive/src_platform_clip-patches/blob/f5cb330d6b684752e403b4e41b39f7004d88e561/1901_open_mayexec.patch
This patch has been used for more than 12 years with customized script interpreters. Some examples (with the original O_MAYEXEC) can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC

Quoted 2 lines
Signature · 1 line
Kees Cook
maintainer
#11 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

In reply to Mickaël Salaün
Quoted 6 lines · Mickaël Salaün

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

Correct me if I'm wrong, but it looks like you are introducing a magical flag that would mean "let the Linux S&M take an extra special whip for this open()".

Why is it done during open? If the caller is passing it deliberately, why not have an explicit request to apply given torture device to an already opened file? Why not sys_masochism(int fd, char *hurt_flavour), for that matter?

#12 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

* Al Viro:

Quoted 8 lines · Mickaël Salaün
Quoted 6 lines

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

Quoted 8 lines

Correct me if I'm wrong, but it looks like you are introducing a magical flag that would mean "let the Linux S&M take an extra special whip for this open()".

Why is it done during open? If the caller is passing it deliberately, why not have an explicit request to apply given torture device to an already opened file? Why not sys_masochism(int fd, char *hurt_flavour), for that matter?

While I do not think this is appropriate language for a workplace, Al has a point: If the auditing event can be generated on an already-open descriptor, it would also cover scenarios like this one:

perl < /path/to/script

Where the process that opens the file does not (and cannot) know that it will be used for execution purposes.

Thanks,
Florian

#13 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

Quoted 13 lines · Florian Weimer

* Al Viro:

Quoted 11 lines · Mickaël Salaün
Quoted 6 lines

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

Correct me if I'm wrong, but it looks like you are introducing a magical flag that would mean "let the Linux S&M take an extra special whip for this open()".

There is nothing magic, it doesn't only work with the LSM framework, and there is nothing painful nor humiliating here (except maybe this language).

Quoted 6 lines
Quoted 5 lines

Why is it done during open? If the caller is passing it deliberately, why not have an explicit request to apply given torture device to an already opened file? Why not sys_masochism(int fd, char *hurt_flavour), for that matter?

Quoted 8 lines

While I do not think this is appropriate language for a workplace, Al has a point: If the auditing event can be generated on an already-open descriptor, it would also cover scenarios like this one:

perl < /path/to/script

Where the process that opens the file does not (and cannot) know that it will be used for execution purposes.

The check is done during open because the goal of this patch series is to address the problem of script execution when opening a script in well controlled systems (e.g. to enforce a "write xor execute" policy, to do an atomic integrity check [1], to check specific execute/read permissions, etc.). As discussed multiple times, controlling other means to interpret commands (stdin, environment variables, etc.) is out of scope and should be handled by interpreters (in userspace). Someone could still extend fcntl(2) to enable to check file descriptors, but it is an independent change not required for now.
Specific audit features are also out of scope for now [2].

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/202007160822.CCDB5478@keescook/

#14 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

In reply to Mickaël Salaün
Quoted 28 lines · Mickaël Salaün

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

The underlying idea is to be able to restrict scripts interpretation according to a policy defined by the system administrator. For this to be possible, script interpreters must use the O_MAYEXEC flag appropriately. To be fully effective, these interpreters also need to handle the other ways to execute code: command line parameters (e.g., option -e for Perl), module loading (e.g., option -m for Python), stdin, file sourcing, environment variables, configuration files, etc. According to the threat model, it may be acceptable to allow some script interpreters (e.g. Bash) to interpret commands from stdin, may it be a TTY or a pipe, because it may not be enough to (directly) perform syscalls. Further documentation can be found in a following patch.

Even without enforced security policy, userland interpreters can set it to enforce the system policy at their level, knowing that it will not break anything on running systems which do not care about this feature. However, on systems which want this feature enforced, there will be knowledgeable people (i.e. sysadmins who enforced O_MAYEXEC deliberately) to manage it. A simple security policy implementation, configured through a dedicated sysctl, is available in a following patch.

Quoted 8 lines

O_MAYEXEC should not be confused with the O_EXEC flag which is intended for execute-only, which obviously doesn't work for scripts. However, a similar behavior could be implemented in userland with O_PATH:
https://lore.kernel.org/lkml/[email protected]/

The implementation of O_MAYEXEC almost duplicates what execve(2) and uselib(2) are already doing: setting MAY_OPENEXEC in acc_mode (which can then be checked as MAY_EXEC, if enforced).

You are allowing S_IFBLK, S_IFCHR, S_IFIFO, S_IFSOCK as targets for O_MAYEXEC?

You are not requiring the opened script be executable?

You are not requring path_noexec? Despite the original patch that inspired this was checking path_noexec?

I honestly think this patch is buggy. If you could reuse MAY_EXEC in the kernel and mean what exec means when it says MAY_EXEC that would be useful.

As it is this patch appears wrong and dangerously confusing as it implies execness but does not implement execness.

If you were simply defining O_EXEC and reusing MAY_EXEC as it exists or exists with cleanups in the kernel this would be a small change that would seem to make reasonable sense. But as you are not reusing anything from MAY_EXEC this code does not make any sense as I am reading it.

Eric

Quoted 163 lines

This is an updated subset of the patch initially written by Vincent Strubel for CLIP OS 4:
https://github.com/clipos-archive/src_platform_clip-patches/blob/f5cb330d6b684752e403b4e41b39f7004d88e561/1901_open_mayexec.patch
This patch has been used for more than 12 years with customized script interpreters. Some examples (with the original O_MAYEXEC) can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC

---

Changes since v6:
* Do not set __FMODE_EXEC for now because of inconsistent behavior:
https://lore.kernel.org/lkml/202007160822.CCDB5478@keescook/
* Returns EISDIR when opening a directory with O_MAYEXEC.
* Removed Deven Bowers and Kees Cook Reviewed-by tags because of the current update.

Changes since v5:
* Update commit message.

Changes since v3:
* Switch back to O_MAYEXEC, but only handle it with openat2(2) which checks unknown flags (suggested by Aleksa Sarai). Cf.
https://lore.kernel.org/lkml/[email protected]/

Changes since v2:
* Replace O_MAYEXEC with RESOLVE_MAYEXEC from openat2(2). This change enables to not break existing application using bogus O_* flags that may be ignored by current kernels by using a new dedicated flag, only usable through openat2(2) (suggested by Jeff Layton). Using this flag will results in an error if the running kernel does not support it. User space needs to manage this case, as with other RESOLVE_* flags. The best effort approach to security (for most common distros) will simply consists of ignoring such an error and retry without RESOLVE_MAYEXEC. However, a fully controlled system may which to error out if such an inconsistency is detected.

Changes since v1:
* Set __FMODE_EXEC when using O_MAYEXEC to make this information available through the new fanotify/FAN_OPEN_EXEC event (suggested by Jan Kara and Matthew Bobrowski):
https://lore.kernel.org/lkml/[email protected]/

---
 fs/fcntl.c                       | 2 +-
 fs/namei.c                       | 4 ++--
 fs/open.c                        | 6 ++++++
 include/linux/fcntl.h            | 2 +-
 include/linux/fs.h               | 2 ++
 include/uapi/asm-generic/fcntl.h | 7 +++++++
 6 files changed, 19 insertions(+), 4 deletions(-)
fs/fcntl.c +1 -1
index 2e4c0fa2074b..0357ad667563 100644
@@ -1033,7 +1033,7 @@ static int __init fcntl_init(void)
 	 * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
 	 * is defined as O_NONBLOCK on some platforms and not on others.
 	 */
-	BUILD_BUG_ON(21 - 1 /* for O_RDONLY being 0 */ !=
+	BUILD_BUG_ON(22 - 1 /* for O_RDONLY being 0 */ !=
 		HWEIGHT32(
 			(VALID_OPEN_FLAGS & ~(O_NONBLOCK | O_NDELAY)) |
 			__FMODE_EXEC | __FMODE_NONOTIFY));
fs/namei.c +2 -2
index ddc9b25540fe..3f074ec77390 100644
@@ -428,7 +428,7 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
- * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, %MAY_OPENEXEC)
  *
  * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
  * this, letting us set arbitrary permissions for filesystem access without
@@ -2849,7 +2849,7 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFLNK:
 		return -ELOOP;
 	case S_IFDIR:
-		if (acc_mode & (MAY_WRITE | MAY_EXEC))
+		if (acc_mode & (MAY_WRITE | MAY_EXEC | MAY_OPENEXEC))
 			return -EISDIR;
 		break;
 	case S_IFBLK:
fs/open.c +6 -0
index 623b7506a6db..21c2c1020574 100644
@@ -987,6 +987,8 @@ inline struct open_how build_open_how(int flags, umode_t mode)
 		.mode = mode & S_IALLUGO,
 	};
 
+	/* O_MAYEXEC is ignored by syscalls relying on build_open_how(). */
+	how.flags &= ~O_MAYEXEC;
 	/* O_PATH beats everything else. */
 	if (how.flags & O_PATH)
 		how.flags &= O_PATH_FLAGS;
@@ -1054,6 +1056,10 @@ inline int build_open_flags(const struct open_how *how, struct open_flags *op)
 	if (flags & __O_SYNC)
 		flags |= O_DSYNC;
 
+	/* Checks execution permissions on open. */
+	if (flags & O_MAYEXEC)
+		acc_mode |= MAY_OPENEXEC;
+
 	op->open_flag = flags;
 
 	/* O_TRUNC implies we need access checks for write permissions */
include/linux/fcntl.h +1 -1
index 7bcdcf4f6ab2..e188a360fa5f 100644
@@ -10,7 +10,7 @@
 	(O_RDONLY | O_WRONLY | O_RDWR | O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC | \
 	 O_APPEND | O_NDELAY | O_NONBLOCK | O_NDELAY | __O_SYNC | O_DSYNC | \
 	 FASYNC	| O_DIRECT | O_LARGEFILE | O_DIRECTORY | O_NOFOLLOW | \
-	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE)
+	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE | O_MAYEXEC)
 
 /* List of all valid flags for the how->upgrade_mask argument: */
 #define VALID_UPGRADE_FLAGS \
include/linux/fs.h +2 -0
index f5abba86107d..56f835c9a87a 100644
@@ -101,6 +101,8 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define MAY_CHDIR		0x00000040
 /* called from RCU mode, don't block */
 #define MAY_NOT_BLOCK		0x00000080
+/* the inode is opened with O_MAYEXEC */
+#define MAY_OPENEXEC		0x00000100
 
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
include/uapi/asm-generic/fcntl.h +7 -0
index 9dc0bf0c5a6e..bca90620119f 100644
@@ -97,6 +97,13 @@
 #define O_NDELAY	O_NONBLOCK
 #endif
 
+/*
+ * Code execution from file is intended, checks such permission.  A simple
+ * policy can be enforced system-wide as explained in
+ * Documentation/admin-guide/sysctl/fs.rst .
+ */
+#define O_MAYEXEC	040000000
+
 #define F_DUPFD		0	/* dup */
 #define F_GETFD		1	/* get close_on_exec */
 #define F_SETFD		2	/* set/clear close_on_exec */
#15 lore raw

Re: [PATCH v7 4/7] fs: Introduce O_MAYEXEC flag for openat2(2)

Quoted 35 lines · Eric W. Biederman
Quoted 33 lines · Mickaël Salaün

When the O_MAYEXEC flag is passed, openat2(2) may be subject to additional restrictions depending on a security policy managed by the kernel through a sysctl or implemented by an LSM thanks to the inode_permission hook. This new flag is ignored by open(2) and openat(2) because of their unspecified flags handling. When used with openat2(2), the default behavior is only to forbid to open a directory.

The underlying idea is to be able to restrict scripts interpretation according to a policy defined by the system administrator. For this to be possible, script interpreters must use the O_MAYEXEC flag appropriately. To be fully effective, these interpreters also need to handle the other ways to execute code: command line parameters (e.g., option -e for Perl), module loading (e.g., option -m for Python), stdin, file sourcing, environment variables, configuration files, etc. According to the threat model, it may be acceptable to allow some script interpreters (e.g. Bash) to interpret commands from stdin, may it be a TTY or a pipe, because it may not be enough to (directly) perform syscalls. Further documentation can be found in a following patch.

Even without enforced security policy, userland interpreters can set it to enforce the system policy at their level, knowing that it will not break anything on running systems which do not care about this feature. However, on systems which want this feature enforced, there will be knowledgeable people (i.e. sysadmins who enforced O_MAYEXEC deliberately) to manage it. A simple security policy implementation, configured through a dedicated sysctl, is available in a following patch.

O_MAYEXEC should not be confused with the O_EXEC flag which is intended for execute-only, which obviously doesn't work for scripts. However, a similar behavior could be implemented in userland with O_PATH:
https://lore.kernel.org/lkml/[email protected]/

Quoted 6 lines
Quoted 3 lines

The implementation of O_MAYEXEC almost duplicates what execve(2) and uselib(2) are already doing: setting MAY_OPENEXEC in acc_mode (which can then be checked as MAY_EXEC, if enforced).

You are allowing S_IFBLK, S_IFCHR, S_IFIFO, S_IFSOCK as targets for O_MAYEXEC?

There is a switch case for each file type (in this patch and the next one).

Quoted 2 lines

You are not requiring the opened script be executable?

The (conditional) enforcement is in the next patch, with the rational.

Quoted 3 lines

You are not requring path_noexec? Despite the original patch that inspired this was checking path_noexec?

This patch just introduces the new flag and its default behavior. See the next patch for a security policy configuration.

Quoted 4 lines

I honestly think this patch is buggy. If you could reuse MAY_EXEC in the kernel and mean what exec means when it says MAY_EXEC that would be useful.

Yeah, but unfortunately this is not possible in practice because of general Linux distro, as explained in the next patch.

Quoted 3 lines

As it is this patch appears wrong and dangerously confusing as it implies execness but does not implement execness.

Please see next patch.

Quoted 6 lines

If you were simply defining O_EXEC and reusing MAY_EXEC as it exists or exists with cleanups in the kernel this would be a small change that would seem to make reasonable sense. But as you are not reusing anything from MAY_EXEC this code does not make any sense as I am reading it.

As explained in this commit message, O_EXEC doesn't have the same semantic. Also, see next patch.

Quoted 167 lines

Eric

Quoted 163 lines

This is an updated subset of the patch initially written by Vincent Strubel for CLIP OS 4:
https://github.com/clipos-archive/src_platform_clip-patches/blob/f5cb330d6b684752e403b4e41b39f7004d88e561/1901_open_mayexec.patch
This patch has been used for more than 12 years with customized script interpreters. Some examples (with the original O_MAYEXEC) can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC

---

Changes since v6:
* Do not set __FMODE_EXEC for now because of inconsistent behavior:
https://lore.kernel.org/lkml/202007160822.CCDB5478@keescook/
* Returns EISDIR when opening a directory with O_MAYEXEC.
* Removed Deven Bowers and Kees Cook Reviewed-by tags because of the current update.

Changes since v5:
* Update commit message.

Changes since v3:
* Switch back to O_MAYEXEC, but only handle it with openat2(2) which checks unknown flags (suggested by Aleksa Sarai). Cf.
https://lore.kernel.org/lkml/[email protected]/

Changes since v2:
* Replace O_MAYEXEC with RESOLVE_MAYEXEC from openat2(2). This change enables to not break existing application using bogus O_* flags that may be ignored by current kernels by using a new dedicated flag, only usable through openat2(2) (suggested by Jeff Layton). Using this flag will results in an error if the running kernel does not support it. User space needs to manage this case, as with other RESOLVE_* flags. The best effort approach to security (for most common distros) will simply consists of ignoring such an error and retry without RESOLVE_MAYEXEC. However, a fully controlled system may which to error out if such an inconsistency is detected.

Changes since v1:
* Set __FMODE_EXEC when using O_MAYEXEC to make this information available through the new fanotify/FAN_OPEN_EXEC event (suggested by Jan Kara and Matthew Bobrowski):
https://lore.kernel.org/lkml/[email protected]/

---
 fs/fcntl.c                       | 2 +-
 fs/namei.c                       | 4 ++--
 fs/open.c                        | 6 ++++++
 include/linux/fcntl.h            | 2 +-
 include/linux/fs.h               | 2 ++
 include/uapi/asm-generic/fcntl.h | 7 +++++++
 6 files changed, 19 insertions(+), 4 deletions(-)
fs/fcntl.c +1 -1
index 2e4c0fa2074b..0357ad667563 100644
@@ -1033,7 +1033,7 @@ static int __init fcntl_init(void)
 	 * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
 	 * is defined as O_NONBLOCK on some platforms and not on others.
 	 */
-	BUILD_BUG_ON(21 - 1 /* for O_RDONLY being 0 */ !=
+	BUILD_BUG_ON(22 - 1 /* for O_RDONLY being 0 */ !=
 		HWEIGHT32(
 			(VALID_OPEN_FLAGS & ~(O_NONBLOCK | O_NDELAY)) |
 			__FMODE_EXEC | __FMODE_NONOTIFY));
fs/namei.c +2 -2
index ddc9b25540fe..3f074ec77390 100644
@@ -428,7 +428,7 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
- * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, %MAY_OPENEXEC)
  *
  * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
  * this, letting us set arbitrary permissions for filesystem access without
@@ -2849,7 +2849,7 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFLNK:
 		return -ELOOP;
 	case S_IFDIR:
-		if (acc_mode & (MAY_WRITE | MAY_EXEC))
+		if (acc_mode & (MAY_WRITE | MAY_EXEC | MAY_OPENEXEC))
 			return -EISDIR;
 		break;
 	case S_IFBLK:
fs/open.c +6 -0
index 623b7506a6db..21c2c1020574 100644
@@ -987,6 +987,8 @@ inline struct open_how build_open_how(int flags, umode_t mode)
 		.mode = mode & S_IALLUGO,
 	};
 
+	/* O_MAYEXEC is ignored by syscalls relying on build_open_how(). */
+	how.flags &= ~O_MAYEXEC;
 	/* O_PATH beats everything else. */
 	if (how.flags & O_PATH)
 		how.flags &= O_PATH_FLAGS;
@@ -1054,6 +1056,10 @@ inline int build_open_flags(const struct open_how *how, struct open_flags *op)
 	if (flags & __O_SYNC)
 		flags |= O_DSYNC;
 
+	/* Checks execution permissions on open. */
+	if (flags & O_MAYEXEC)
+		acc_mode |= MAY_OPENEXEC;
+
 	op->open_flag = flags;
 
 	/* O_TRUNC implies we need access checks for write permissions */
include/linux/fcntl.h +1 -1
index 7bcdcf4f6ab2..e188a360fa5f 100644
@@ -10,7 +10,7 @@
 	(O_RDONLY | O_WRONLY | O_RDWR | O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC | \
 	 O_APPEND | O_NDELAY | O_NONBLOCK | O_NDELAY | __O_SYNC | O_DSYNC | \
 	 FASYNC	| O_DIRECT | O_LARGEFILE | O_DIRECTORY | O_NOFOLLOW | \
-	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE)
+	 O_NOATIME | O_CLOEXEC | O_PATH | __O_TMPFILE | O_MAYEXEC)
 
 /* List of all valid flags for the how->upgrade_mask argument: */
 #define VALID_UPGRADE_FLAGS \
include/linux/fs.h +2 -0
index f5abba86107d..56f835c9a87a 100644
@@ -101,6 +101,8 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define MAY_CHDIR		0x00000040
 /* called from RCU mode, don't block */
 #define MAY_NOT_BLOCK		0x00000080
+/* the inode is opened with O_MAYEXEC */
+#define MAY_OPENEXEC		0x00000100
 
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
include/uapi/asm-generic/fcntl.h +7 -0
index 9dc0bf0c5a6e..bca90620119f 100644
@@ -97,6 +97,13 @@
 #define O_NDELAY	O_NONBLOCK
 #endif
 
+/*
+ * Code execution from file is intended, checks such permission.  A simple
+ * policy can be enforced system-wide as explained in
+ * Documentation/admin-guide/sysctl/fs.rst .
+ */
+#define O_MAYEXEC	040000000
+
 #define F_DUPFD		0	/* dup */
 #define F_GETFD		1	/* get close_on_exec */
 #define F_SETFD		2	/* set/clear close_on_exec */
#16 lore raw

PATCH v7 5/7 fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC

In reply to Mickaël Salaün

Allow for the enforcement of the O_MAYEXEC openat2(2) flag. Thanks to the noexec option from the underlying VFS mount, or to the file execute permission, userspace can enforce these execution policies. This may allow script interpreters to check execution permission before reading commands from a file, or dynamic linkers to allow shared object loading.

Add a new sysctl fs.open_mayexec_enforce to enable system administrators to enforce two complementary security policies according to the installed system: enforce the noexec mount option, and enforce executable file permission. Indeed, because of compatibility with installed systems, only system administrators are able to check that this new enforcement is in line with the system mount points and file permissions. A following patch adds documentation.

Being able to restrict execution also enables to protect the kernel by restricting arbitrary syscalls that an attacker could perform with a crafted binary or certain script languages. It also improves multilevel isolation by reducing the ability of an attacker to use side channels with specific code. These restrictions can natively be enforced for ELF binaries (with the noexec mount option) but require this kernel extension to properly handle scripts (e.g., Python, Perl). To get a consistent execution policy, additional memory restrictions should also be enforced (e.g. thanks to SELinux).

Because the O_MAYEXEC flag is a meant to enforce a system-wide security policy (but not application-centric policies), it does not make sense for userland to check the sysctl value. Indeed, this new flag only enables to extend the system ability to enforce a policy thanks to (some trusted) userland collaboration. Moreover, additional security policies could be managed by LSMs. This is a best-effort approach from the application developer point of view:
https://lore.kernel.org/lkml/[email protected]/

Cc Aleksa Sarai <[email protected]>
Cc Al Viro <[email protected]>
Cc Jonathan Corbet <[email protected]>
Cc Kees Cook <[email protected]>
Cc Randy Dunlap <[email protected]>

---

Changes since v6:
* Allow opening pipes, block devices and character devices with O_MAYEXEC when there is no enforced policy, but forbid any non-regular file opened with O_MAYEXEC otherwise (i.e. for any enforced policy).
* Add a paragraph about the non-regular files policy.
* Move path_noexec() calls out of the fast-path (suggested by Kees Cook).

Changes since v5:
* Remove the static enforcement configuration through Kconfig because it makes the code more simple like this, and because the current sysctl configuration can only be set with CAP_SYS_ADMIN, the same way mount options (i.e. noexec) can be set. If an harden distro wants to enforce a configuration, it should restrict capabilities or sysctl configuration. Furthermore, an LSM can easily leverage O_MAYEXEC to fit its need.
* Move checks from inode_permission() to may_open() and make the error codes more consistent according to file types (in line with a previous commit): opening a directory with O_MAYEXEC returns EISDIR and other non-regular file types may return EACCES.
* In may_open(), when OMAYEXEC_ENFORCE_FILE is set, replace explicit call to generic_permission() with an artificial MAY_EXEC to avoid double calls. This makes sense especially when an LSM policy forbids execution of a file.
* Replace the custom proc_omayexec() with proc_dointvec_minmax_sysadmin(), and then replace the CAP_MAC_ADMIN check with a CAP_SYS_ADMIN one (suggested by Kees Cook and Stephen Smalley).
* Use BIT() (suggested by Kees Cook).
* Rename variables (suggested by Kees Cook).
* Reword the kconfig help.
* Import the documentation patch (suggested by Kees Cook):
https://lore.kernel.org/lkml/[email protected]/
* Update documentation and add LWN.net article.

Changes since v4:
* Add kernel configuration options to enforce O_MAYEXEC at build time, and disable the sysctl in such case (requested by James Morris).
* Reword commit message.

Changes since v3:
* Update comment with O_MAYEXEC.

Changes since v2:
* Cosmetic changes.

Changes since v1:
* Move code from Yama to the FS subsystem (suggested by Kees Cook).
* Make omayexec_inode_permission() static (suggested by Jann Horn).
* Use mode 0600 for the sysctl.
* Only match regular files (not directories nor other types), which follows the same semantic as commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()").

---
 Documentation/admin-guide/sysctl/fs.rst | 49 +++++++++++++++++++++++++
 fs/namei.c                              | 24 ++++++++++++
 include/linux/fs.h                      |  1 +
 kernel/sysctl.c                         | 12 +++++-
 4 files changed, 84 insertions(+), 2 deletions(-)
Documentation/admin-guide/sysctl/fs.rst +49 -0
index 2a45119e3331..ce6e2081d3a9 100644
@@ -37,6 +37,7 @@ Currently, these files are in /proc/sys/fs:
 - inode-nr
 - inode-state
 - nr_open
+- open_mayexec_enforce
 - overflowuid
 - overflowgid
 - pipe-user-pages-hard
@@ -165,6 +166,54 @@ system needs to prune the inode list instead of allocating
 more.
 
 
+open_mayexec_enforce
+--------------------
+
+While being ignored by :manpage:`open(2)` and :manpage:`openat(2)`, the
+``O_MAYEXEC`` flag can be passed to :manpage:`openat2(2)` to only open regular
+files that are expected to be executable.  If the file is not identified as
+executable, then the syscall returns -EACCES.  This may allow a script
+interpreter to check executable permission before reading commands from a file,
+or a dynamic linker to only load executable shared objects.  One interesting
+use case is to enforce a "write xor execute" policy through interpreters.
+
+The ability to restrict code execution must be thought as a system-wide policy,
+which first starts by restricting mount points with the ``noexec`` option.
+This option is also automatically applied to special filesystems such as /proc .
+This prevents files on such mount points to be directly executed by the kernel
+or mapped as executable memory (e.g. libraries).  With script interpreters
+using the ``O_MAYEXEC`` flag, the executable permission can then be checked
+before reading commands from files. This makes it possible to enforce the
+``noexec`` at the interpreter level, and thus propagates this security policy
+to scripts.  To be fully effective, these interpreters also need to handle the
+other ways to execute code: command line parameters (e.g., option ``-e`` for
+Perl), module loading (e.g., option ``-m`` for Python), stdin, file sourcing,
+environment variables, configuration files, etc.  According to the threat
+model, it may be acceptable to allow some script interpreters (e.g. Bash) to
+interpret commands from stdin, may it be a TTY or a pipe, because it may not be
+enough to (directly) perform syscalls.
+
+There are two complementary security policies: enforce the ``noexec`` mount
+option, and enforce executable file permission.  These policies are handled by
+the ``fs.open_mayexec_enforce`` sysctl (writable only with ``CAP_SYS_ADMIN``)
+as a bitmask:
+
+1 - Mount restriction: checks that the mount options for the underlying VFS
+    mount do not prevent execution.
+
+2 - File permission restriction: checks that the to-be-opened file is marked as
+    executable for the current process (e.g., POSIX permissions).
+
+Note that as long as a policy is enforced, opening any non-regular file with
+``O_MAYEXEC`` is denied (e.g. TTYs, pipe), even when such a file is marked as
+executable or is on an executable mount point.
+
+Code samples can be found in tools/testing/selftests/openat2/omayexec_test.c
+and interpreter patches (for the original O_MAYEXEC version) may be found at
+https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC .
+See also an overview article: https://lwn.net/Articles/820000/ .
+
+
 overflowgid & overflowuid
 -------------------------
 
fs/namei.c +24 -0
index 3f074ec77390..8ec13c7fd403 100644
@@ -39,6 +39,7 @@
 #include <linux/bitops.h>
 #include <linux/init_task.h>
 #include <linux/uaccess.h>
+#include <linux/sysctl.h>
 
 #include "internal.h"
 #include "mount.h"
@@ -425,6 +426,11 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 	return 0;
 }
 
+#define OPEN_MAYEXEC_ENFORCE_MOUNT	BIT(0)
+#define OPEN_MAYEXEC_ENFORCE_FILE	BIT(1)
+
+int sysctl_open_mayexec_enforce __read_mostly;
+
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
@@ -2861,11 +2867,29 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFSOCK:
 		if (acc_mode & MAY_EXEC)
 			return -EACCES;
+		/*
+		 * Opening devices (e.g. TTYs) or pipes with O_MAYEXEC may be
+		 * legitimate when there is no enforced policy.
+		 */
+		if ((acc_mode & MAY_OPENEXEC) && sysctl_open_mayexec_enforce)
+			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
 	case S_IFREG:
 		if ((acc_mode & MAY_EXEC) && path_noexec(path))
 			return -EACCES;
+		if (acc_mode & MAY_OPENEXEC) {
+			if ((sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_MOUNT)
+					&& path_noexec(path))
+				return -EACCES;
+			if (sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_FILE)
+				/*
+				 * Because acc_mode may change here, the next and only
+				 * use of acc_mode should then be by the following call
+				 * to inode_permission().
+				 */
+				acc_mode |= MAY_EXEC;
+		}
 		break;
 	}
 
include/linux/fs.h +1 -0
index 56f835c9a87a..071f37707ccc 100644
@@ -83,6 +83,7 @@ extern int sysctl_protected_symlinks;
 extern int sysctl_protected_hardlinks;
 extern int sysctl_protected_fifos;
 extern int sysctl_protected_regular;
+extern int sysctl_open_mayexec_enforce;
 
 typedef __kernel_rwf_t rwf_t;
 
kernel/sysctl.c +10 -2
index db1ce7af2563..5008a2566e79 100644
@@ -113,6 +113,7 @@ static int sixty = 60;
 
 static int __maybe_unused neg_one = -1;
 static int __maybe_unused two = 2;
+static int __maybe_unused three = 3;
 static int __maybe_unused four = 4;
 static unsigned long zero_ul;
 static unsigned long one_ul = 1;
@@ -888,7 +889,6 @@ static int proc_taint(struct ctl_table *table, int write,
 	return err;
 }
 
-#ifdef CONFIG_PRINTK
 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 				void *buffer, size_t *lenp, loff_t *ppos)
 {
@@ -897,7 +897,6 @@ static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 
 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
 }
-#endif
 
 /**
  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
@@ -3264,6 +3263,15 @@ static struct ctl_table fs_table[] = {
 		.extra1		= SYSCTL_ZERO,
 		.extra2		= &two,
 	},
+	{
+		.procname       = "open_mayexec_enforce",
+		.data           = &sysctl_open_mayexec_enforce,
+		.maxlen         = sizeof(int),
+		.mode           = 0600,
+		.proc_handler	= proc_dointvec_minmax_sysadmin,
+		.extra1		= SYSCTL_ZERO,
+		.extra2		= &three,
+	},
 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
 	{
 		.procname	= "binfmt_misc",
Signature · 1 line
2.27.0
Acked-by on v7 5/7
#17 lore raw

Re: [PATCH v7 5/7] fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC

Quoted 33 lines · Mickaël Salaün

Allow for the enforcement of the O_MAYEXEC openat2(2) flag. Thanks to the noexec option from the underlying VFS mount, or to the file execute permission, userspace can enforce these execution policies. This may allow script interpreters to check execution permission before reading commands from a file, or dynamic linkers to allow shared object loading.

Add a new sysctl fs.open_mayexec_enforce to enable system administrators to enforce two complementary security policies according to the installed system: enforce the noexec mount option, and enforce executable file permission. Indeed, because of compatibility with installed systems, only system administrators are able to check that this new enforcement is in line with the system mount points and file permissions. A following patch adds documentation.

Being able to restrict execution also enables to protect the kernel by restricting arbitrary syscalls that an attacker could perform with a crafted binary or certain script languages. It also improves multilevel isolation by reducing the ability of an attacker to use side channels with specific code. These restrictions can natively be enforced for ELF binaries (with the noexec mount option) but require this kernel extension to properly handle scripts (e.g., Python, Perl). To get a consistent execution policy, additional memory restrictions should also be enforced (e.g. thanks to SELinux).

Because the O_MAYEXEC flag is a meant to enforce a system-wide security policy (but not application-centric policies), it does not make sense for userland to check the sysctl value. Indeed, this new flag only enables to extend the system ability to enforce a policy thanks to (some trusted) userland collaboration. Moreover, additional security policies could be managed by LSMs. This is a best-effort approach from the application developer point of view:
https://lore.kernel.org/lkml/[email protected]/

Quoted 1 line
Signature · 1 line
Kees Cook
#18 lore raw

Re: [PATCH v7 5/7] fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC

In reply to Mickaël Salaün
Quoted 6 lines · Mickaël Salaün

Allow for the enforcement of the O_MAYEXEC openat2(2) flag. Thanks to the noexec option from the underlying VFS mount, or to the file execute permission, userspace can enforce these execution policies. This may allow script interpreters to check execution permission before reading commands from a file, or dynamic linkers to allow shared object loading.

Ick!!!!!

This feels like being so open minded your brains fall out.

I can see having a sysctl that allows the new open flag to be ignored so that the existing lack of enforcement when the flag is passed continues.

But having the sysctl be fine grained seems like way too much rope.

I don't think the code needs to do more than enforce or not enforce this logic.

You can test the sysctl once when you process O_MAYEXEC. But code such as may_open should not have the conditional behavior. It should get an appropriate set of flags that are always enforced. With the madness of what to do left at the edge of userspace.

Anything else appears to be madness, overengineering, and a failure to separate concerns.

Eric

Quoted 273 lines

Add a new sysctl fs.open_mayexec_enforce to enable system administrators to enforce two complementary security policies according to the installed system: enforce the noexec mount option, and enforce executable file permission. Indeed, because of compatibility with installed systems, only system administrators are able to check that this new enforcement is in line with the system mount points and file permissions. A following patch adds documentation.

Being able to restrict execution also enables to protect the kernel by restricting arbitrary syscalls that an attacker could perform with a crafted binary or certain script languages. It also improves multilevel isolation by reducing the ability of an attacker to use side channels with specific code. These restrictions can natively be enforced for ELF binaries (with the noexec mount option) but require this kernel extension to properly handle scripts (e.g., Python, Perl). To get a consistent execution policy, additional memory restrictions should also be enforced (e.g. thanks to SELinux).

Because the O_MAYEXEC flag is a meant to enforce a system-wide security policy (but not application-centric policies), it does not make sense for userland to check the sysctl value. Indeed, this new flag only enables to extend the system ability to enforce a policy thanks to (some trusted) userland collaboration. Moreover, additional security policies could be managed by LSMs. This is a best-effort approach from the application developer point of view:
https://lore.kernel.org/lkml/[email protected]/

Cc Aleksa Sarai <[email protected]>
Cc Al Viro <[email protected]>
Cc Jonathan Corbet <[email protected]>
Cc Kees Cook <[email protected]>
Cc Randy Dunlap <[email protected]>

---

Changes since v6:
* Allow opening pipes, block devices and character devices with O_MAYEXEC when there is no enforced policy, but forbid any non-regular file opened with O_MAYEXEC otherwise (i.e. for any enforced policy).
* Add a paragraph about the non-regular files policy.
* Move path_noexec() calls out of the fast-path (suggested by Kees Cook).

Changes since v5:
* Remove the static enforcement configuration through Kconfig because it makes the code more simple like this, and because the current sysctl configuration can only be set with CAP_SYS_ADMIN, the same way mount options (i.e. noexec) can be set. If an harden distro wants to enforce a configuration, it should restrict capabilities or sysctl configuration. Furthermore, an LSM can easily leverage O_MAYEXEC to fit its need.
* Move checks from inode_permission() to may_open() and make the error codes more consistent according to file types (in line with a previous commit): opening a directory with O_MAYEXEC returns EISDIR and other non-regular file types may return EACCES.
* In may_open(), when OMAYEXEC_ENFORCE_FILE is set, replace explicit call to generic_permission() with an artificial MAY_EXEC to avoid double calls. This makes sense especially when an LSM policy forbids execution of a file.
* Replace the custom proc_omayexec() with proc_dointvec_minmax_sysadmin(), and then replace the CAP_MAC_ADMIN check with a CAP_SYS_ADMIN one (suggested by Kees Cook and Stephen Smalley).
* Use BIT() (suggested by Kees Cook).
* Rename variables (suggested by Kees Cook).
* Reword the kconfig help.
* Import the documentation patch (suggested by Kees Cook):
https://lore.kernel.org/lkml/[email protected]/
* Update documentation and add LWN.net article.

Changes since v4:
* Add kernel configuration options to enforce O_MAYEXEC at build time, and disable the sysctl in such case (requested by James Morris).
* Reword commit message.

Changes since v3:
* Update comment with O_MAYEXEC.

Changes since v2:
* Cosmetic changes.

Changes since v1:
* Move code from Yama to the FS subsystem (suggested by Kees Cook).
* Make omayexec_inode_permission() static (suggested by Jann Horn).
* Use mode 0600 for the sysctl.
* Only match regular files (not directories nor other types), which follows the same semantic as commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()").

---
 Documentation/admin-guide/sysctl/fs.rst | 49 +++++++++++++++++++++++++
 fs/namei.c                              | 24 ++++++++++++
 include/linux/fs.h                      |  1 +
 kernel/sysctl.c                         | 12 +++++-
 4 files changed, 84 insertions(+), 2 deletions(-)
Documentation/admin-guide/sysctl/fs.rst +49 -0
index 2a45119e3331..ce6e2081d3a9 100644
@@ -37,6 +37,7 @@ Currently, these files are in /proc/sys/fs:
 - inode-nr
 - inode-state
 - nr_open
+- open_mayexec_enforce
 - overflowuid
 - overflowgid
 - pipe-user-pages-hard
@@ -165,6 +166,54 @@ system needs to prune the inode list instead of allocating
 more.
 
 
+open_mayexec_enforce
+--------------------
+
+While being ignored by :manpage:`open(2)` and :manpage:`openat(2)`, the
+``O_MAYEXEC`` flag can be passed to :manpage:`openat2(2)` to only open regular
+files that are expected to be executable.  If the file is not identified as
+executable, then the syscall returns -EACCES.  This may allow a script
+interpreter to check executable permission before reading commands from a file,
+or a dynamic linker to only load executable shared objects.  One interesting
+use case is to enforce a "write xor execute" policy through interpreters.
+
+The ability to restrict code execution must be thought as a system-wide policy,
+which first starts by restricting mount points with the ``noexec`` option.
+This option is also automatically applied to special filesystems such as /proc .
+This prevents files on such mount points to be directly executed by the kernel
+or mapped as executable memory (e.g. libraries).  With script interpreters
+using the ``O_MAYEXEC`` flag, the executable permission can then be checked
+before reading commands from files. This makes it possible to enforce the
+``noexec`` at the interpreter level, and thus propagates this security policy
+to scripts.  To be fully effective, these interpreters also need to handle the
+other ways to execute code: command line parameters (e.g., option ``-e`` for
+Perl), module loading (e.g., option ``-m`` for Python), stdin, file sourcing,
+environment variables, configuration files, etc.  According to the threat
+model, it may be acceptable to allow some script interpreters (e.g. Bash) to
+interpret commands from stdin, may it be a TTY or a pipe, because it may not be
+enough to (directly) perform syscalls.
+
+There are two complementary security policies: enforce the ``noexec`` mount
+option, and enforce executable file permission.  These policies are handled by
+the ``fs.open_mayexec_enforce`` sysctl (writable only with ``CAP_SYS_ADMIN``)
+as a bitmask:
+
+1 - Mount restriction: checks that the mount options for the underlying VFS
+    mount do not prevent execution.
+
+2 - File permission restriction: checks that the to-be-opened file is marked as
+    executable for the current process (e.g., POSIX permissions).
+
+Note that as long as a policy is enforced, opening any non-regular file with
+``O_MAYEXEC`` is denied (e.g. TTYs, pipe), even when such a file is marked as
+executable or is on an executable mount point.
+
+Code samples can be found in tools/testing/selftests/openat2/omayexec_test.c
+and interpreter patches (for the original O_MAYEXEC version) may be found at
+https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC .
+See also an overview article: https://lwn.net/Articles/820000/ .
+
+
 overflowgid & overflowuid
 -------------------------
 
fs/namei.c +24 -0
index 3f074ec77390..8ec13c7fd403 100644
@@ -39,6 +39,7 @@
 #include <linux/bitops.h>
 #include <linux/init_task.h>
 #include <linux/uaccess.h>
+#include <linux/sysctl.h>
 
 #include "internal.h"
 #include "mount.h"
@@ -425,6 +426,11 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 	return 0;
 }
 
+#define OPEN_MAYEXEC_ENFORCE_MOUNT	BIT(0)
+#define OPEN_MAYEXEC_ENFORCE_FILE	BIT(1)
+
+int sysctl_open_mayexec_enforce __read_mostly;
+
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
@@ -2861,11 +2867,29 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFSOCK:
 		if (acc_mode & MAY_EXEC)
 			return -EACCES;
+		/*
+		 * Opening devices (e.g. TTYs) or pipes with O_MAYEXEC may be
+		 * legitimate when there is no enforced policy.
+		 */
+		if ((acc_mode & MAY_OPENEXEC) && sysctl_open_mayexec_enforce)
+			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
 	case S_IFREG:
 		if ((acc_mode & MAY_EXEC) && path_noexec(path))
 			return -EACCES;
+		if (acc_mode & MAY_OPENEXEC) {
+			if ((sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_MOUNT)
+					&& path_noexec(path))
+				return -EACCES;
+			if (sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_FILE)
+				/*
+				 * Because acc_mode may change here, the next and only
+				 * use of acc_mode should then be by the following call
+				 * to inode_permission().
+				 */
+				acc_mode |= MAY_EXEC;
+		}
 		break;
 	}
 
include/linux/fs.h +1 -0
index 56f835c9a87a..071f37707ccc 100644
@@ -83,6 +83,7 @@ extern int sysctl_protected_symlinks;
 extern int sysctl_protected_hardlinks;
 extern int sysctl_protected_fifos;
 extern int sysctl_protected_regular;
+extern int sysctl_open_mayexec_enforce;
 
 typedef __kernel_rwf_t rwf_t;
 
kernel/sysctl.c +10 -2
index db1ce7af2563..5008a2566e79 100644
@@ -113,6 +113,7 @@ static int sixty = 60;
 
 static int __maybe_unused neg_one = -1;
 static int __maybe_unused two = 2;
+static int __maybe_unused three = 3;
 static int __maybe_unused four = 4;
 static unsigned long zero_ul;
 static unsigned long one_ul = 1;
@@ -888,7 +889,6 @@ static int proc_taint(struct ctl_table *table, int write,
 	return err;
 }
 
-#ifdef CONFIG_PRINTK
 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 				void *buffer, size_t *lenp, loff_t *ppos)
 {
@@ -897,7 +897,6 @@ static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 
 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
 }
-#endif
 
 /**
  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
@@ -3264,6 +3263,15 @@ static struct ctl_table fs_table[] = {
 		.extra1		= SYSCTL_ZERO,
 		.extra2		= &two,
 	},
+	{
+		.procname       = "open_mayexec_enforce",
+		.data           = &sysctl_open_mayexec_enforce,
+		.maxlen         = sizeof(int),
+		.mode           = 0600,
+		.proc_handler	= proc_dointvec_minmax_sysadmin,
+		.extra1		= SYSCTL_ZERO,
+		.extra2		= &three,
+	},
 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
 	{
 		.procname	= "binfmt_misc",
#19 lore raw

Re: [PATCH v7 5/7] fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC

Quoted 9 lines · Eric W. Biederman
Quoted 6 lines · Mickaël Salaün

Allow for the enforcement of the O_MAYEXEC openat2(2) flag. Thanks to the noexec option from the underlying VFS mount, or to the file execute permission, userspace can enforce these execution policies. This may allow script interpreters to check execution permission before reading commands from a file, or dynamic linkers to allow shared object loading.

Quoted 3 lines

Ick!!!!!

This feels like being so open minded your brains fall out.

Really? :)

Quoted 4 lines

I can see having a sysctl that allows the new open flag to be ignored so that the existing lack of enforcement when the flag is passed continues.

And that could break distros (i.e. multiple interpreters, with or without O_MAYEXEC, different versions, and different kernels).

Quoted 2 lines

But having the sysctl be fine grained seems like way too much rope.

This follow the same rational: file permissions and mount options can change but they are controled by the sysadmin, how also configure sysctl values.

Quoted 3 lines

I don't think the code needs to do more than enforce or not enforce this logic.

I think this is the more viable behavior for an eclectic set of distros (and different use cases).

Quoted 5 lines

You can test the sysctl once when you process O_MAYEXEC. But code such as may_open should not have the conditional behavior. It should get an appropriate set of flags that are always enforced. With the madness of what to do left at the edge of userspace.

The problem is that this userspace is not in charge of the system-wide policy, the sysadmin is. As pointed out by the commit message, please take a look at the rational:
https://lore.kernel.org/lkml/[email protected]/

Quoted 3 lines

Anything else appears to be madness, overengineering, and a failure to separate concerns.

Oh! What a conclusion! :)

I'd say it is a pragmatic approach.

Quoted 277 lines

Eric

Quoted 273 lines

Add a new sysctl fs.open_mayexec_enforce to enable system administrators to enforce two complementary security policies according to the installed system: enforce the noexec mount option, and enforce executable file permission. Indeed, because of compatibility with installed systems, only system administrators are able to check that this new enforcement is in line with the system mount points and file permissions. A following patch adds documentation.

Being able to restrict execution also enables to protect the kernel by restricting arbitrary syscalls that an attacker could perform with a crafted binary or certain script languages. It also improves multilevel isolation by reducing the ability of an attacker to use side channels with specific code. These restrictions can natively be enforced for ELF binaries (with the noexec mount option) but require this kernel extension to properly handle scripts (e.g., Python, Perl). To get a consistent execution policy, additional memory restrictions should also be enforced (e.g. thanks to SELinux).

Because the O_MAYEXEC flag is a meant to enforce a system-wide security policy (but not application-centric policies), it does not make sense for userland to check the sysctl value. Indeed, this new flag only enables to extend the system ability to enforce a policy thanks to (some trusted) userland collaboration. Moreover, additional security policies could be managed by LSMs. This is a best-effort approach from the application developer point of view:
https://lore.kernel.org/lkml/[email protected]/

Cc Aleksa Sarai <[email protected]>
Cc Al Viro <[email protected]>
Cc Jonathan Corbet <[email protected]>
Cc Kees Cook <[email protected]>
Cc Randy Dunlap <[email protected]>

---

Changes since v6:
* Allow opening pipes, block devices and character devices with O_MAYEXEC when there is no enforced policy, but forbid any non-regular file opened with O_MAYEXEC otherwise (i.e. for any enforced policy).
* Add a paragraph about the non-regular files policy.
* Move path_noexec() calls out of the fast-path (suggested by Kees Cook).

Changes since v5:
* Remove the static enforcement configuration through Kconfig because it makes the code more simple like this, and because the current sysctl configuration can only be set with CAP_SYS_ADMIN, the same way mount options (i.e. noexec) can be set. If an harden distro wants to enforce a configuration, it should restrict capabilities or sysctl configuration. Furthermore, an LSM can easily leverage O_MAYEXEC to fit its need.
* Move checks from inode_permission() to may_open() and make the error codes more consistent according to file types (in line with a previous commit): opening a directory with O_MAYEXEC returns EISDIR and other non-regular file types may return EACCES.
* In may_open(), when OMAYEXEC_ENFORCE_FILE is set, replace explicit call to generic_permission() with an artificial MAY_EXEC to avoid double calls. This makes sense especially when an LSM policy forbids execution of a file.
* Replace the custom proc_omayexec() with proc_dointvec_minmax_sysadmin(), and then replace the CAP_MAC_ADMIN check with a CAP_SYS_ADMIN one (suggested by Kees Cook and Stephen Smalley).
* Use BIT() (suggested by Kees Cook).
* Rename variables (suggested by Kees Cook).
* Reword the kconfig help.
* Import the documentation patch (suggested by Kees Cook):
https://lore.kernel.org/lkml/[email protected]/
* Update documentation and add LWN.net article.

Changes since v4:
* Add kernel configuration options to enforce O_MAYEXEC at build time, and disable the sysctl in such case (requested by James Morris).
* Reword commit message.

Changes since v3:
* Update comment with O_MAYEXEC.

Changes since v2:
* Cosmetic changes.

Changes since v1:
* Move code from Yama to the FS subsystem (suggested by Kees Cook).
* Make omayexec_inode_permission() static (suggested by Jann Horn).
* Use mode 0600 for the sysctl.
* Only match regular files (not directories nor other types), which follows the same semantic as commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()").

---
 Documentation/admin-guide/sysctl/fs.rst | 49 +++++++++++++++++++++++++
 fs/namei.c                              | 24 ++++++++++++
 include/linux/fs.h                      |  1 +
 kernel/sysctl.c                         | 12 +++++-
 4 files changed, 84 insertions(+), 2 deletions(-)
Documentation/admin-guide/sysctl/fs.rst +49 -0
index 2a45119e3331..ce6e2081d3a9 100644
@@ -37,6 +37,7 @@ Currently, these files are in /proc/sys/fs:
 - inode-nr
 - inode-state
 - nr_open
+- open_mayexec_enforce
 - overflowuid
 - overflowgid
 - pipe-user-pages-hard
@@ -165,6 +166,54 @@ system needs to prune the inode list instead of allocating
 more.
 
 
+open_mayexec_enforce
+--------------------
+
+While being ignored by :manpage:`open(2)` and :manpage:`openat(2)`, the
+``O_MAYEXEC`` flag can be passed to :manpage:`openat2(2)` to only open regular
+files that are expected to be executable.  If the file is not identified as
+executable, then the syscall returns -EACCES.  This may allow a script
+interpreter to check executable permission before reading commands from a file,
+or a dynamic linker to only load executable shared objects.  One interesting
+use case is to enforce a "write xor execute" policy through interpreters.
+
+The ability to restrict code execution must be thought as a system-wide policy,
+which first starts by restricting mount points with the ``noexec`` option.
+This option is also automatically applied to special filesystems such as /proc .
+This prevents files on such mount points to be directly executed by the kernel
+or mapped as executable memory (e.g. libraries).  With script interpreters
+using the ``O_MAYEXEC`` flag, the executable permission can then be checked
+before reading commands from files. This makes it possible to enforce the
+``noexec`` at the interpreter level, and thus propagates this security policy
+to scripts.  To be fully effective, these interpreters also need to handle the
+other ways to execute code: command line parameters (e.g., option ``-e`` for
+Perl), module loading (e.g., option ``-m`` for Python), stdin, file sourcing,
+environment variables, configuration files, etc.  According to the threat
+model, it may be acceptable to allow some script interpreters (e.g. Bash) to
+interpret commands from stdin, may it be a TTY or a pipe, because it may not be
+enough to (directly) perform syscalls.
+
+There are two complementary security policies: enforce the ``noexec`` mount
+option, and enforce executable file permission.  These policies are handled by
+the ``fs.open_mayexec_enforce`` sysctl (writable only with ``CAP_SYS_ADMIN``)
+as a bitmask:
+
+1 - Mount restriction: checks that the mount options for the underlying VFS
+    mount do not prevent execution.
+
+2 - File permission restriction: checks that the to-be-opened file is marked as
+    executable for the current process (e.g., POSIX permissions).
+
+Note that as long as a policy is enforced, opening any non-regular file with
+``O_MAYEXEC`` is denied (e.g. TTYs, pipe), even when such a file is marked as
+executable or is on an executable mount point.
+
+Code samples can be found in tools/testing/selftests/openat2/omayexec_test.c
+and interpreter patches (for the original O_MAYEXEC version) may be found at
+https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC .
+See also an overview article: https://lwn.net/Articles/820000/ .
+
+
 overflowgid & overflowuid
 -------------------------
 
fs/namei.c +24 -0
index 3f074ec77390..8ec13c7fd403 100644
@@ -39,6 +39,7 @@
 #include <linux/bitops.h>
 #include <linux/init_task.h>
 #include <linux/uaccess.h>
+#include <linux/sysctl.h>
 
 #include "internal.h"
 #include "mount.h"
@@ -425,6 +426,11 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
 	return 0;
 }
 
+#define OPEN_MAYEXEC_ENFORCE_MOUNT	BIT(0)
+#define OPEN_MAYEXEC_ENFORCE_FILE	BIT(1)
+
+int sysctl_open_mayexec_enforce __read_mostly;
+
 /**
  * inode_permission - Check for access rights to a given inode
  * @inode: Inode to check permission on
@@ -2861,11 +2867,29 @@ static int may_open(const struct path *path, int acc_mode, int flag)
 	case S_IFSOCK:
 		if (acc_mode & MAY_EXEC)
 			return -EACCES;
+		/*
+		 * Opening devices (e.g. TTYs) or pipes with O_MAYEXEC may be
+		 * legitimate when there is no enforced policy.
+		 */
+		if ((acc_mode & MAY_OPENEXEC) && sysctl_open_mayexec_enforce)
+			return -EACCES;
 		flag &= ~O_TRUNC;
 		break;
 	case S_IFREG:
 		if ((acc_mode & MAY_EXEC) && path_noexec(path))
 			return -EACCES;
+		if (acc_mode & MAY_OPENEXEC) {
+			if ((sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_MOUNT)
+					&& path_noexec(path))
+				return -EACCES;
+			if (sysctl_open_mayexec_enforce & OPEN_MAYEXEC_ENFORCE_FILE)
+				/*
+				 * Because acc_mode may change here, the next and only
+				 * use of acc_mode should then be by the following call
+				 * to inode_permission().
+				 */
+				acc_mode |= MAY_EXEC;
+		}
 		break;
 	}
 
include/linux/fs.h +1 -0
index 56f835c9a87a..071f37707ccc 100644
@@ -83,6 +83,7 @@ extern int sysctl_protected_symlinks;
 extern int sysctl_protected_hardlinks;
 extern int sysctl_protected_fifos;
 extern int sysctl_protected_regular;
+extern int sysctl_open_mayexec_enforce;
 
 typedef __kernel_rwf_t rwf_t;
 
kernel/sysctl.c +10 -2
index db1ce7af2563..5008a2566e79 100644
@@ -113,6 +113,7 @@ static int sixty = 60;
 
 static int __maybe_unused neg_one = -1;
 static int __maybe_unused two = 2;
+static int __maybe_unused three = 3;
 static int __maybe_unused four = 4;
 static unsigned long zero_ul;
 static unsigned long one_ul = 1;
@@ -888,7 +889,6 @@ static int proc_taint(struct ctl_table *table, int write,
 	return err;
 }
 
-#ifdef CONFIG_PRINTK
 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 				void *buffer, size_t *lenp, loff_t *ppos)
 {
@@ -897,7 +897,6 @@ static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 
 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
 }
-#endif
 
 /**
  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
@@ -3264,6 +3263,15 @@ static struct ctl_table fs_table[] = {
 		.extra1		= SYSCTL_ZERO,
 		.extra2		= &two,
 	},
+	{
+		.procname       = "open_mayexec_enforce",
+		.data           = &sysctl_open_mayexec_enforce,
+		.maxlen         = sizeof(int),
+		.mode           = 0600,
+		.proc_handler	= proc_dointvec_minmax_sysadmin,
+		.extra1		= SYSCTL_ZERO,
+		.extra2		= &three,
+	},
 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
 	{
 		.procname	= "binfmt_misc",
#20 lore raw

PATCH v7 6/7 selftest/openat2: Add tests for O_MAYEXEC enforcing

In reply to Mickaël Salaün

Test propagation of noexec mount points or file executability through files open with or without O_MAYEXEC, thanks to the fs.open_mayexec_enforce sysctl.

---

Changes since v6:
* Add full combination tests for all file types, including block devices, character devices, fifos, sockets and symlinks.
* Properly save and restore initial sysctl value for all tests.

Changes since v5:
* Refactor with FIXTURE_VARIANT, which make the tests much more easy to read and maintain.
* Save and restore initial sysctl value (suggested by Kees Cook).
* Test with a sysctl value of 0.
* Check errno in sysctl_access_write test.
* Update tests for the CAP_SYS_ADMIN switch.
* Update tests to check -EISDIR (replacing -EACCES).
* Replace FIXTURE_DATA() with FIXTURE() (spotted by Kees Cook).
* Use global const strings.

Changes since v3:
* Replace RESOLVE_MAYEXEC with O_MAYEXEC.
* Add tests to check that O_MAYEXEC is ignored by open(2) and openat(2).

Changes since v2:
* Move tests from exec/ to openat2/ .
* Replace O_MAYEXEC with RESOLVE_MAYEXEC from openat2(2).
* Cleanup tests.

Changes since v1:
* Move tests from yama/ to exec/ .
* Fix _GNU_SOURCE in kselftest_harness.h .
* Add a new test sysctl_access_write to check if CAP_MAC_ADMIN is taken into account.
* Test directory execution which is always forbidden since commit 73601ea5b7b1 ("fs/open.c: allow opening only regular files during execve()"), and also check that even the root user can not bypass file execution checks.
* Make sure delete_workspace() always as enough right to succeed.
* Cosmetic cleanup.

---
 tools/testing/selftests/kselftest_harness.h   |   3 +
 tools/testing/selftests/openat2/Makefile      |   3 +-
 tools/testing/selftests/openat2/config        |   1 +
 tools/testing/selftests/openat2/helpers.h     |   1 +
 .../testing/selftests/openat2/omayexec_test.c | 325 ++++++++++++++++++
 5 files changed, 332 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/openat2/config
 create mode 100644 tools/testing/selftests/openat2/omayexec_test.c
tools/testing/selftests/kselftest_harness.h +3 -0
index c9f03ef93338..68a0acd9ea1e 100644
@@ -50,7 +50,10 @@
 #ifndef __KSELFTEST_HARNESS_H
 #define __KSELFTEST_HARNESS_H
 
+#ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#endif
+
 #include <asm/types.h>
 #include <errno.h>
 #include <stdbool.h>
tools/testing/selftests/openat2/Makefile +2 -1
index 4b93b1417b86..cb98bdb4d5b1 100644
@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined
-TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test
+LDLIBS += -lcap
+TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test omayexec_test
 
 include ../lib.mk
 
tools/testing/selftests/openat2/config new file +1 -0
new file mode 100644
index 000000000000..dd53c266bf52
@@ -0,0 +1 @@
+CONFIG_SYSCTL=y
tools/testing/selftests/openat2/helpers.h +1 -0
index a6ea27344db2..1dcd3e1e2f38 100644
@@ -9,6 +9,7 @@
 
 #define _GNU_SOURCE
 #include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <linux/types.h>
 #include "../kselftest.h"
tools/testing/selftests/openat2/omayexec_test.c new file +325 -0

325 lines not on this page · raw message

Signature · 1 line
2.27.0
Reviewed-by on v7 6/7
#21 lore raw

Re: [PATCH v7 6/7] selftest/openat2: Add tests for O_MAYEXEC enforcing

Quoted 5 lines · Mickaël Salaün

Test propagation of noexec mount points or file executability through files open with or without O_MAYEXEC, thanks to the fs.open_mayexec_enforce sysctl.

Signature · 1 line
Kees Cook
#22 lore raw

PATCH v7 7/7 ima: add policy support for the new file open MAY_OPENEXEC flag

In reply to Mickaël Salaün

From: Mimi Zohar <[email protected]>

The kernel has no way of differentiating between a file containing data or code being opened by an interpreter. The proposed O_MAYEXEC openat2(2) flag bridges this gap by defining and enabling the MAY_OPENEXEC flag.

This patch adds IMA policy support for the new MAY_OPENEXEC flag.

Example:
measure func=FILE_CHECK mask=^MAY_OPENEXEC
appraise func=FILE_CHECK appraise_type=imasig mask=^MAY_OPENEXEC

---
 Documentation/ABI/testing/ima_policy |  2 +-
 security/integrity/ima/ima_main.c    |  3 ++-
 security/integrity/ima/ima_policy.c  | 15 +++++++++++----
 3 files changed, 14 insertions(+), 6 deletions(-)
Documentation/ABI/testing/ima_policy +1 -1
index cd572912c593..caca46125fe0 100644
@@ -31,7 +31,7 @@ Description:
 				[KEXEC_KERNEL_CHECK] [KEXEC_INITRAMFS_CHECK]
 				[KEXEC_CMDLINE] [KEY_CHECK]
 			mask:= [[^]MAY_READ] [[^]MAY_WRITE] [[^]MAY_APPEND]
-			       [[^]MAY_EXEC]
+			       [[^]MAY_EXEC] [[^]MAY_OPENEXEC]
 			fsmagic:= hex value
 			fsuuid:= file system UUID (e.g 8bcbe394-4f13-4144-be8e-5aa9ea2ce2f6)
 			uid:= decimal value
security/integrity/ima/ima_main.c +2 -1
index c1583d98c5e5..59fd1658a203 100644
@@ -490,7 +490,8 @@ int ima_file_check(struct file *file, int mask)
 
 	security_task_getsecid(current, &secid);
 	return process_measurement(file, current_cred(), secid, NULL, 0,
-				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC |
+				   mask & (MAY_READ | MAY_WRITE |
+					   MAY_EXEC | MAY_OPENEXEC |
 					   MAY_APPEND), FILE_CHECK);
 }
 EXPORT_SYMBOL_GPL(ima_file_check);
security/integrity/ima/ima_policy.c +11 -4
index e493063a3c34..6487f0b2afdd 100644
@@ -406,7 +406,8 @@ static bool ima_match_keyring(struct ima_rule_entry *rule,
  * @cred: a pointer to a credentials structure for user validation
  * @secid: the secid of the task to be validated
  * @func: LIM hook identifier
- * @mask: requested action (MAY_READ | MAY_WRITE | MAY_APPEND | MAY_EXEC)
+ * @mask: requested action (MAY_READ | MAY_WRITE | MAY_APPEND | MAY_EXEC |
+ *			    MAY_OPENEXEC)
  * @keyring: keyring name to check in policy for KEY_CHECK func
  *
  * Returns true on rule match, false on failure.
@@ -527,7 +528,8 @@ static int get_subaction(struct ima_rule_entry *rule, enum ima_hooks func)
  *        being made
  * @secid: LSM secid of the task to be validated
  * @func: IMA hook identifier
- * @mask: requested action (MAY_READ | MAY_WRITE | MAY_APPEND | MAY_EXEC)
+ * @mask: requested action (MAY_READ | MAY_WRITE | MAY_APPEND | MAY_EXEC |
+ *			    MAY_OPENEXEC)
  * @pcr: set the pcr to extend
  * @template_desc: the template that should be used for this rule
  * @keyring: the keyring name, if given, to be used to check in the policy.
@@ -1091,6 +1093,8 @@ static int ima_parse_rule(char *rule, struct ima_rule_entry *entry)
 				entry->mask = MAY_READ;
 			else if (strcmp(from, "MAY_APPEND") == 0)
 				entry->mask = MAY_APPEND;
+			else if (strcmp(from, "MAY_OPENEXEC") == 0)
+				entry->mask = MAY_OPENEXEC;
 			else
 				result = -EINVAL;
 			if (!result)
@@ -1422,14 +1426,15 @@ const char *const func_tokens[] = {
 
 #ifdef	CONFIG_IMA_READ_POLICY
 enum {
-	mask_exec = 0, mask_write, mask_read, mask_append
+	mask_exec = 0, mask_write, mask_read, mask_append, mask_openexec
 };
 
 static const char *const mask_tokens[] = {
 	"^MAY_EXEC",
 	"^MAY_WRITE",
 	"^MAY_READ",
-	"^MAY_APPEND"
+	"^MAY_APPEND",
+	"^MAY_OPENEXEC"
 };
 
 void *ima_policy_start(struct seq_file *m, loff_t *pos)
@@ -1518,6 +1523,8 @@ int ima_policy_show(struct seq_file *m, void *v)
 			seq_printf(m, pt(Opt_mask), mt(mask_read) + offset);
 		if (entry->mask & MAY_APPEND)
 			seq_printf(m, pt(Opt_mask), mt(mask_append) + offset);
+		if (entry->mask & MAY_OPENEXEC)
+			seq_printf(m, pt(Opt_mask), mt(mask_openexec) + offset);
 		seq_puts(m, " ");
 	}
 
Signature · 1 line
2.27.0
Reviewed-by on v7 7/7
#23 lore raw

Re: [PATCH v7 7/7] ima: add policy support for the new file open MAY_OPENEXEC flag

Quoted 7 lines · Mickaël Salaün

From: Mimi Zohar <[email protected]>

The kernel has no way of differentiating between a file containing data or code being opened by an interpreter. The proposed O_MAYEXEC openat2(2) flag bridges this gap by defining and enabling the MAY_OPENEXEC flag.

Quoted 7 lines

This patch adds IMA policy support for the new MAY_OPENEXEC flag.

Example:
measure func=FILE_CHECK mask=^MAY_OPENEXEC
appraise func=FILE_CHECK appraise_type=imasig mask=^MAY_OPENEXEC

^^^ this S-o-b should the last in the fields.

Quoted 3 lines
Signature · 1 line
Kees Cook
#25 lore raw
In reply to Mickaël Salaün

I think this looks good now.

Andrew, since you're already carrying my exec clean-ups (repeated here in patch 1-3), can you pick the rest of this series too?

Thanks!

-Kees

Quoted 130 lines · Mickaël Salaün

Hi,

This seventh patch series do not set __FMODE_EXEC for the sake of simplicity. A notification feature could be added later if needed. The handling of all file types is now well defined and tested: by default, when opening a path, access to a directory is denied (with EISDIR), access to a regular file depends on the sysctl policy, and access to other file types (i.e. fifo, device, socket) is denied if there is any enforced policy. There is new tests covering all these cases (cf. test_file_types() ).

As requested by Mimi Zohar, I completed the series with one of her patches for IMA. I also picked Kees Cook's patches to consolidate exec permission checking into do_filp_open()'s flow.

# Goal of O_MAYEXEC

The goal of this patch series is to enable to control script execution with interpreters help. A new O_MAYEXEC flag, usable through openat2(2), is added to enable userspace script interpreters to delegate to the kernel (and thus the system security policy) the permission to interpret/execute scripts or other files containing what can be seen as commands.

A simple system-wide security policy can be enforced by the system administrator through a sysctl configuration consistent with the mount points or the file access rights. The documentation patch explains the prerequisites.

Furthermore, the security policy can also be delegated to an LSM, either a MAC system or an integrity system. For instance, the new kernel MAY_OPENEXEC flag closes a major IMA measurement/appraisal interpreter integrity gap by bringing the ability to check the use of scripts [1]. Other uses are expected, such as for magic-links [2], SGX integration [3], bpffs [4] or IPE [5].

# Prerequisite of its use

Userspace needs to adapt to take advantage of this new feature. For example, the PEP 578 [6] (Runtime Audit Hooks) enables Python 3.8 to be extended with policy enforcement points related to code interpretation, which can be used to align with the PowerShell audit features. Additional Python security improvements (e.g. a limited interpreter withou -c, stdin piping of code) are on their way [7].

# Examples

The initial idea comes from CLIP OS 4 and the original implementation has been used for more than 12 years:
https://github.com/clipos-archive/clipos4_doc
Chrome OS has a similar approach:
https://chromium.googlesource.com/chromiumos/docs/+/master/security/noexec_shell_scripts.md

Userland patches can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC
Actually, there is more than the O_MAYEXEC changes (which matches this search) e.g., to prevent Python interactive execution. There are patches for Bash, Wine, Java (Icedtea), Busybox's ash, Perl and Python. There are also some related patches which do not directly rely on O_MAYEXEC but which restrict the use of browser plugins and extensions, which may be seen as scripts too:
https://github.com/clipos-archive/clipos4_portage-overlay/tree/master/www-client

An introduction to O_MAYEXEC was given at the Linux Security Summit Europe 2018 - Linux Kernel Security Contributions by ANSSI:
https://www.youtube.com/watch?v=chNjCRtPKQY&t=17m15s
The "write xor execute" principle was explained at Kernel Recipes 2018 - CLIP OS: a defense-in-depth OS:
https://www.youtube.com/watch?v=PjRE0uBtkHU&t=11m14s
See also an overview article: https://lwn.net/Articles/820000/

This patch series can be applied on top of v5.8-rc5 . This can be tested with CONFIG_SYSCTL. I would really appreciate constructive comments on this patch series.

Previous version:
https://lore.kernel.org/lkml/[email protected]/

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/[email protected]/
[3] https://lore.kernel.org/lkml/CALCETrVovr8XNZSroey7pHF46O=kj_c5D9K8h=z2T_cNrpvMig@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CALCETrVeZ0eufFXwfhtaG_j+AdvbzEWE0M3wjXMWVEO7pj+xkw@mail.gmail.com/
[5] https://lore.kernel.org/lkml/[email protected]/
[6] https://www.python.org/dev/peps/pep-0578/
[7] https://lore.kernel.org/lkml/[email protected]/

Regards,

Kees Cook (3):
exec: Change uselib(2) IS_SREG() failure to EACCES
exec: Move S_ISREG() check earlier
exec: Move path_noexec() check earlier

Mickaël Salaün (3):
fs: Introduce O_MAYEXEC flag for openat2(2)
fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC selftest/openat2: Add tests for O_MAYEXEC enforcing

Mimi Zohar (1):
ima: add policy support for the new file open MAY_OPENEXEC flag

 Documentation/ABI/testing/ima_policy          |   2 +-
 Documentation/admin-guide/sysctl/fs.rst       |  49 +++
 fs/exec.c                                     |  23 +-
 fs/fcntl.c                                    |   2 +-
 fs/namei.c                                    |  36 +-
 fs/open.c                                     |  12 +-
 include/linux/fcntl.h                         |   2 +-
 include/linux/fs.h                            |   3 +
 include/uapi/asm-generic/fcntl.h              |   7 +
 kernel/sysctl.c                               |  12 +-
 security/integrity/ima/ima_main.c             |   3 +-
 security/integrity/ima/ima_policy.c           |  15 +-
 tools/testing/selftests/kselftest_harness.h   |   3 +
 tools/testing/selftests/openat2/Makefile      |   3 +-
 tools/testing/selftests/openat2/config        |   1 +
 tools/testing/selftests/openat2/helpers.h     |   1 +
 .../testing/selftests/openat2/omayexec_test.c | 325 ++++++++++++++++++
 17 files changed, 470 insertions(+), 29 deletions(-)
 create mode 100644 tools/testing/selftests/openat2/config
 create mode 100644 tools/testing/selftests/openat2/omayexec_test.c
Signature · 1 line
2.27.0
Signature · 1 line
Kees Cook
#26 lore raw
Quoted 4 lines · Kees Cook

I think this looks good now.

Andrew, since you're already carrying my exec clean-ups (repeated here in patch 1-3), can you pick the rest of this series too?

Al,

Not sure if you have already re-surfaced from your csum()/raw_copy_from_user() work completely yet but you had thoughts about this series iirc.

Aleksa, thoughts?

Thanks!
Christian

#27 lore raw
In reply to Kees Cook

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

Quoted 141 lines · Kees Cook

I think this looks good now.

Andrew, since you're already carrying my exec clean-ups (repeated here in patch 1-3), can you pick the rest of this series too?

Thanks!

-Kees

Quoted 130 lines · Mickaël Salaün

Hi,

This seventh patch series do not set __FMODE_EXEC for the sake of simplicity. A notification feature could be added later if needed. The handling of all file types is now well defined and tested: by default, when opening a path, access to a directory is denied (with EISDIR), access to a regular file depends on the sysctl policy, and access to other file types (i.e. fifo, device, socket) is denied if there is any enforced policy. There is new tests covering all these cases (cf. test_file_types() ).

As requested by Mimi Zohar, I completed the series with one of her patches for IMA. I also picked Kees Cook's patches to consolidate exec permission checking into do_filp_open()'s flow.

# Goal of O_MAYEXEC

The goal of this patch series is to enable to control script execution with interpreters help. A new O_MAYEXEC flag, usable through openat2(2), is added to enable userspace script interpreters to delegate to the kernel (and thus the system security policy) the permission to interpret/execute scripts or other files containing what can be seen as commands.

A simple system-wide security policy can be enforced by the system administrator through a sysctl configuration consistent with the mount points or the file access rights. The documentation patch explains the prerequisites.

Furthermore, the security policy can also be delegated to an LSM, either a MAC system or an integrity system. For instance, the new kernel MAY_OPENEXEC flag closes a major IMA measurement/appraisal interpreter integrity gap by bringing the ability to check the use of scripts [1]. Other uses are expected, such as for magic-links [2], SGX integration [3], bpffs [4] or IPE [5].

# Prerequisite of its use

Userspace needs to adapt to take advantage of this new feature. For example, the PEP 578 [6] (Runtime Audit Hooks) enables Python 3.8 to be extended with policy enforcement points related to code interpretation, which can be used to align with the PowerShell audit features. Additional Python security improvements (e.g. a limited interpreter withou -c, stdin piping of code) are on their way [7].

# Examples

The initial idea comes from CLIP OS 4 and the original implementation has been used for more than 12 years:
https://github.com/clipos-archive/clipos4_doc
Chrome OS has a similar approach:
https://chromium.googlesource.com/chromiumos/docs/+/master/security/noexec_shell_scripts.md

Userland patches can be found here:
https://github.com/clipos-archive/clipos4_portage-overlay/search?q=O_MAYEXEC
Actually, there is more than the O_MAYEXEC changes (which matches this search) e.g., to prevent Python interactive execution. There are patches for Bash, Wine, Java (Icedtea), Busybox's ash, Perl and Python. There are also some related patches which do not directly rely on O_MAYEXEC but which restrict the use of browser plugins and extensions, which may be seen as scripts too:
https://github.com/clipos-archive/clipos4_portage-overlay/tree/master/www-client

An introduction to O_MAYEXEC was given at the Linux Security Summit Europe 2018 - Linux Kernel Security Contributions by ANSSI:
https://www.youtube.com/watch?v=chNjCRtPKQY&t=17m15s
The "write xor execute" principle was explained at Kernel Recipes 2018 - CLIP OS: a defense-in-depth OS:
https://www.youtube.com/watch?v=PjRE0uBtkHU&t=11m14s
See also an overview article: https://lwn.net/Articles/820000/

This patch series can be applied on top of v5.8-rc5 . This can be tested with CONFIG_SYSCTL. I would really appreciate constructive comments on this patch series.

Previous version:
https://lore.kernel.org/lkml/[email protected]/

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/[email protected]/
[3] https://lore.kernel.org/lkml/CALCETrVovr8XNZSroey7pHF46O=kj_c5D9K8h=z2T_cNrpvMig@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CALCETrVeZ0eufFXwfhtaG_j+AdvbzEWE0M3wjXMWVEO7pj+xkw@mail.gmail.com/
[5] https://lore.kernel.org/lkml/[email protected]/
[6] https://www.python.org/dev/peps/pep-0578/
[7] https://lore.kernel.org/lkml/[email protected]/

Regards,

Kees Cook (3):
exec: Change uselib(2) IS_SREG() failure to EACCES
exec: Move S_ISREG() check earlier
exec: Move path_noexec() check earlier

Mickaël Salaün (3):
fs: Introduce O_MAYEXEC flag for openat2(2)
fs,doc: Enable to enforce noexec mounts or file exec through O_MAYEXEC selftest/openat2: Add tests for O_MAYEXEC enforcing

Mimi Zohar (1):
ima: add policy support for the new file open MAY_OPENEXEC flag

 Documentation/ABI/testing/ima_policy          |   2 +-
 Documentation/admin-guide/sysctl/fs.rst       |  49 +++
 fs/exec.c                                     |  23 +-
 fs/fcntl.c                                    |   2 +-
 fs/namei.c                                    |  36 +-
 fs/open.c                                     |  12 +-
 include/linux/fcntl.h                         |   2 +-
 include/linux/fs.h                            |   3 +
 include/uapi/asm-generic/fcntl.h              |   7 +
 kernel/sysctl.c                               |  12 +-
 security/integrity/ima/ima_main.c             |   3 +-
 security/integrity/ima/ima_policy.c           |  15 +-
 tools/testing/selftests/kselftest_harness.h   |   3 +
 tools/testing/selftests/openat2/Makefile      |   3 +-
 tools/testing/selftests/openat2/config        |   1 +
 tools/testing/selftests/openat2/helpers.h     |   1 +
 .../testing/selftests/openat2/omayexec_test.c | 325 ++++++++++++++++++
 17 files changed, 470 insertions(+), 29 deletions(-)
 create mode 100644 tools/testing/selftests/openat2/config
 create mode 100644 tools/testing/selftests/openat2/omayexec_test.c
Signature · 1 line
2.27.0
maintainer
#28 lore raw
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

#29 lore raw
Quoted 7 lines · Mickaël Salaün
Quoted 2 lines

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

The kernel 'policy' then decides whether that needs 'r-x' access or whether 'r--' access in enough.

I think that is what you 100 line comment in 0/n means.

David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

maintainer
#30 lore raw
Quoted 11 lines · David Laight
Quoted 7 lines · Mickaël Salaün
Quoted 2 lines

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

... which does not answer the question - name of constant is the least of the worries here. Why the hell is "apply some unspecified checks to file" combined with opening it, rather than being an independent primitive you apply to an already opened file? Just in case - "'cuz that's how we'd done it" does not make a good answer...

#31 lore raw
Quoted 5 lines · Al Viro
Quoted 4 lines · David Laight
Quoted 4 lines · Mickaël Salaün
Quoted 2 lines

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

The properties is "execute permission". This can then be checked by interpreters or other applications, then the generic O_MAYEXEC name.

Quoted 7 lines

... which does not answer the question - name of constant is the least of the worries here. Why the hell is "apply some unspecified checks to file" combined with opening it, rather than being an independent primitive you apply to an already opened file? Just in case - "'cuz that's how we'd done it" does not make a good answer...

That is not the case, see
https://lore.kernel.org/lkml/[email protected]/

#32 lore raw
Quoted 10 lines · Al Viro
Quoted 9 lines · David Laight
Quoted 8 lines
Quoted 7 lines · Mickaël Salaün
Quoted 2 lines

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Quoted 6 lines
Quoted 3 lines
Quoted 3 lines

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

The properties is "execute permission". This can then be checked by interpreters or other applications, then the generic O_MAYEXEC name.

The english sense of MAYEXEC is just wrong for what you are trying to check.

Quoted 5 lines
Quoted 5 lines

... which does not answer the question - name of constant is the least of the worries here. Why the hell is "apply some unspecified checks to file" combined with opening it, rather than being an independent primitive you apply to an already opened file? Just in case - "'cuz that's how we'd done it" does not make a good answer...

Maybe an access_ok() that acts on an open fd would be more appropriate.
Which might end up being an fcntrl() action.
That would give you a full 32bit mask of options.

David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

#33 lore raw
Quoted 14 lines · David Laight
Quoted 14 lines · Al Viro
Quoted 12 lines · David Laight
Quoted 11 lines
Quoted 7 lines · Mickaël Salaün
Quoted 2 lines

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

Quoted 5 lines
Quoted 2 lines

The properties is "execute permission". This can then be checked by interpreters or other applications, then the generic O_MAYEXEC name.

The english sense of MAYEXEC is just wrong for what you are trying to check.

We think it reflects exactly what it's purpose is.

Quoted 11 lines
Quoted 6 lines
Quoted 6 lines

... which does not answer the question - name of constant is the least of the worries here. Why the hell is "apply some unspecified checks to file" combined with opening it, rather than being an independent primitive you apply to an already opened file? Just in case - "'cuz that's how we'd done it" does not make a good answer...

Maybe an access_ok() that acts on an open fd would be more appropriate.
Which might end up being an fcntrl() action.
That would give you a full 32bit mask of options.

I previously talk about fcntl(2):
https://lore.kernel.org/lkml/[email protected]/

#34 lore raw
Quoted 34 lines · EDT Mickaël Salaün
Quoted 16 lines · David Laight
Quoted 16 lines · Al Viro
Quoted 14 lines · David Laight
Quoted 13 lines
Quoted 9 lines · Mickaël Salaün
Quoted 3 lines

It seems that there is no more complains nor questions. Do you want me
to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling
a coherent answer.

To me O_MAYEXEC is just the wrong name.
The bit would be (something like) O_INTERPRET to indicate what you want to do with the contents.

Quoted 5 lines
Quoted 2 lines

The properties is "execute permission". This can then be checked by interpreters or other applications, then the generic O_MAYEXEC name.

The english sense of MAYEXEC is just wrong for what you are trying to check.

We think it reflects exactly what it's purpose is.

Quoted 9 lines
Quoted 8 lines
Quoted 8 lines

... which does not answer the question - name of constant is the least of
the worries here. Why the hell is "apply some unspecified checks to file" combined with opening it, rather than being an independent primitive
you apply to an already opened file? Just in case - "'cuz that's how we'd
done it" does not make a good answer...

Quoted 8 lines
Quoted 4 lines

Maybe an access_ok() that acts on an open fd would be more appropriate.
Which might end up being an fcntrl() action.
That would give you a full 32bit mask of options.

I previously talk about fcntl(2):
https://lore.kernel.org/lkml/[email protected]
et/

Fcntl is too late for anything using FANOTIFY. Everything needs to be upfront or other security systems cannot use it.

-Steve

#35 lore raw
In reply to Al Viro
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied. It is a good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources). It is important to keep in mind that the use cases we are addressing consider that the (user space) script interpreters (or linkers) are trusted and unaltered (i.e. integrity/authenticity checked). These are similar sought defensive properties as for SUID/SGID binaries: attackers can still launch them with malicious inputs (e.g. file paths, file descriptors, environment variables, etc.), but the binaries can then have a way to check if they can extend their trust to some file paths.

Checking file descriptors may help in some use cases, but not the ones motivating this series. Checking (already) opened resources could be a *complementary* way to check execute permission, but it is not in the scope of this series.

#36 lore raw
Quoted 15 lines · Mickaël Salaün
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Quoted 3 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied.

You can do exactly the same thing if you do the check in a separate syscall though.

And it provides a greater degree of flexibility; for example, you can use it in combination with fopen() without having to modify the internals of fopen() or having to use fdopen().

Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

I don't see how TOCTOU issues are relevant in any way here. If someone can turn a script that is considered a trusted file into an untrusted file and then maliciously change its contents, you're going to have issues either way because the modifications could still happen after openat(); if this was possible, the whole thing would kind of fall apart. And if that isn't possible, I don't see any TOCTOU.

Quoted 11 lines

It is important to keep
in mind that the use cases we are addressing consider that the (user space) script interpreters (or linkers) are trusted and unaltered (i.e. integrity/authenticity checked). These are similar sought defensive properties as for SUID/SGID binaries: attackers can still launch them with malicious inputs (e.g. file paths, file descriptors, environment variables, etc.), but the binaries can then have a way to check if they can extend their trust to some file paths.

Checking file descriptors may help in some use cases, but not the ones motivating this series.

It actually provides a superset of the functionality that your existing patches provide.

Quoted 3 lines

Checking (already) opened resources could be a *complementary* way to check execute permission, but it is not in the scope of this series.

#37 lore raw
Quoted 38 lines · Jann Horn
Quoted 15 lines · Mickaël Salaün
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Quoted 3 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied.

You can do exactly the same thing if you do the check in a separate syscall though.

And it provides a greater degree of flexibility; for example, you can use it in combination with fopen() without having to modify the internals of fopen() or having to use fdopen().

Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Quoted 4 lines

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

I'd be interested with such security issue examples.

I hope that delaying checks will not be an issue for mechanisms such as IMA or IPE:
https://lore.kernel.org/lkml/[email protected]/

Any though Mimi, Deven, Chrome OS folks?

Quoted 7 lines

I don't see how TOCTOU issues are relevant in any way here. If someone can turn a script that is considered a trusted file into an untrusted file and then maliciously change its contents, you're going to have issues either way because the modifications could still happen after openat(); if this was possible, the whole thing would kind of fall apart. And if that isn't possible, I don't see any TOCTOU.

Sure, and if the scripts are not protected in some way there is no point to check anything.

Quoted 10 lines
Quoted 10 lines

It is important to keep
in mind that the use cases we are addressing consider that the (user space) script interpreters (or linkers) are trusted and unaltered (i.e. integrity/authenticity checked). These are similar sought defensive properties as for SUID/SGID binaries: attackers can still launch them with malicious inputs (e.g. file paths, file descriptors, environment variables, etc.), but the binaries can then have a way to check if they can extend their trust to some file paths.

Quoted 5 lines
Quoted 2 lines

Checking file descriptors may help in some use cases, but not the ones motivating this series.

It actually provides a superset of the functionality that your existing patches provide.

It also brings new issues with multiple file descriptor origins (e.g. memfd_create).

Quoted 4 lines
Quoted 4 lines

Checking (already) opened resources could be a *complementary* way to check execute permission, but it is not in the scope of this series.

maintainer
#38 lore raw
Quoted 44 lines · Mickaël Salaün
Quoted 38 lines · Jann Horn
Quoted 15 lines · Mickaël Salaün
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Quoted 3 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied.

You can do exactly the same thing if you do the check in a separate syscall though.

And it provides a greater degree of flexibility; for example, you can use it in combination with fopen() without having to modify the internals of fopen() or having to use fdopen().

Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Quoted 4 lines

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

Quoted 7 lines

I'd be interested with such security issue examples.

I hope that delaying checks will not be an issue for mechanisms such as IMA or IPE:
https://lore.kernel.org/lkml/[email protected]/

Any though Mimi, Deven, Chrome OS folks?

One of the major gaps, defining a system wide policy requiring all code being executed to be signed, is interpreters. The kernel has no context for the interpreter's opening the file. From an IMA perspective, this information needs to be conveyed to the kernel prior to ima_file_check(), which would allow IMA policy rules to be defined in terms of O_MAYEXEC.

Quoted 10 lines
Quoted 7 lines

I don't see how TOCTOU issues are relevant in any way here. If someone can turn a script that is considered a trusted file into an untrusted file and then maliciously change its contents, you're going to have issues either way because the modifications could still happen after openat(); if this was possible, the whole thing would kind of fall apart. And if that isn't possible, I don't see any TOCTOU.

Sure, and if the scripts are not protected in some way there is no point to check anything.

The interpreter itself would be signed.

Mimi

Quoted 22 lines
Quoted 10 lines
Quoted 10 lines

It is important to keep
in mind that the use cases we are addressing consider that the (user space) script interpreters (or linkers) are trusted and unaltered (i.e. integrity/authenticity checked). These are similar sought defensive properties as for SUID/SGID binaries: attackers can still launch them with malicious inputs (e.g. file paths, file descriptors, environment variables, etc.), but the binaries can then have a way to check if they can extend their trust to some file paths.

Quoted 5 lines
Quoted 2 lines

Checking file descriptors may help in some use cases, but not the ones motivating this series.

It actually provides a superset of the functionality that your existing patches provide.

It also brings new issues with multiple file descriptor origins (e.g. memfd_create).

Quoted 3 lines
Quoted 3 lines

Checking (already) opened resources could be a *complementary* way to check execute permission, but it is not in the scope of this series.

#39 lore raw
Quoted 51 lines · Mimi Zohar
Quoted 50 lines · Mickaël Salaün
Quoted 38 lines · Jann Horn
Quoted 15 lines · Mickaël Salaün
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Quoted 3 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied.

You can do exactly the same thing if you do the check in a separate syscall though.

And it provides a greater degree of flexibility; for example, you can use it in combination with fopen() without having to modify the internals of fopen() or having to use fdopen().

Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Quoted 4 lines

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

I'd be interested with such security issue examples.

I hope that delaying checks will not be an issue for mechanisms such as IMA or IPE:
https://lore.kernel.org/lkml/[email protected]/

Quoted 8 lines
Quoted 1 line

Any though Mimi, Deven, Chrome OS folks?

One of the major gaps, defining a system wide policy requiring all code being executed to be signed, is interpreters. The kernel has no context for the interpreter's opening the file. From an IMA perspective, this information needs to be conveyed to the kernel prior to ima_file_check(), which would allow IMA policy rules to be defined in terms of O_MAYEXEC.

This is kind of evading the point -- Mickaël is proposing a new flag to open() to tell IMA to measure the file being opened before the fd is returned to userspace, and Al is suggesting a new syscall to allow a previously-obtained fd to be measured.

I think what you're saying is that you don't see any reason to prefer one over the other.

maintainer
#40 lore raw
Quoted 61 lines · Matthew Wilcox
Quoted 51 lines · Mimi Zohar
Quoted 50 lines · Mickaël Salaün
Quoted 38 lines · Jann Horn
Quoted 15 lines · Mickaël Salaün
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

It seems that there is no more complains nor questions. Do you want me to send another series to fix the order of the S-o-b in patch 7?

There is a major question regarding the API design and the choice of hooking that stuff on open(). And I have not heard anything resembling a coherent answer.

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them. From an API point of view, this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

Quoted 3 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied.

You can do exactly the same thing if you do the check in a separate syscall though.

And it provides a greater degree of flexibility; for example, you can use it in combination with fopen() without having to modify the internals of fopen() or having to use fdopen().

Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Quoted 4 lines

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

I'd be interested with such security issue examples.

I hope that delaying checks will not be an issue for mechanisms such as IMA or IPE:
https://lore.kernel.org/lkml/[email protected]/

Quoted 8 lines
Quoted 1 line

Any though Mimi, Deven, Chrome OS folks?

One of the major gaps, defining a system wide policy requiring all code being executed to be signed, is interpreters. The kernel has no context for the interpreter's opening the file. From an IMA perspective, this information needs to be conveyed to the kernel prior to ima_file_check(), which would allow IMA policy rules to be defined in terms of O_MAYEXEC.

Quoted 7 lines

This is kind of evading the point -- Mickaël is proposing a new flag to open() to tell IMA to measure the file being opened before the fd is returned to userspace, and Al is suggesting a new syscall to allow a previously-obtained fd to be measured.

I think what you're saying is that you don't see any reason to prefer one over the other.

Being able to define IMA appraise and measure file open (func=FILE_CHECK) policy rules to prevent the interpreter from executing unsigned files would be really nice. Otherwise, the file would be measured and appraised multiple times, once on file open and again at the point of this new syscall.

Mimi

#41 lore raw
In reply to Mickaël Salaün

On 8/11/2020 1:48 AM, Mickaël Salaün wrote:

[...snip]

Quoted 16 lines
Quoted 11 lines
Quoted 4 lines

It is a
good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

The assumption that security checks should happen as early as possible can actually cause security problems. For example, because seccomp was designed to do its checks as early as possible, including before ptrace, we had an issue for a long time where the ptrace API could be abused to bypass seccomp filters.

Quoted 4 lines

Please don't decide that a check must be ordered first _just_ because it is a security check. While that can be good for limiting attack surface, it can also create issues when the idea is applied too broadly.

Quoted 8 lines

I'd be interested with such security issue examples.

I hope that delaying checks will not be an issue for mechanisms such as IMA or IPE:
https://lore.kernel.org/lkml/[email protected]/

Any though Mimi, Deven, Chrome OS folks?

I don't see an issue with IPE. As long as the hypothetical new syscall and associated security hook have the file struct available in the hook, it should integrate fairly easily.

[...snip]

maintainer
#42 lore raw
In reply to Mickaël Salaün
Quoted 2 lines · Mickaël Salaün

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them.

Which is a good thing, because...?

Quoted 4 lines

From an API point of view,
this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

That's what "unspecified" means - as far as the kernel concerned, it's "something completely opaque, will let these hooks to play, semantics is entirely up to them".

Quoted 6 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied. It is a good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

????? You explicitly assume a cooperating caller. If it can't be trusted to issue the check between open and use, or can be manipulated (ptraced, etc.) into not doing so, how can you rely upon the flag having been passed in the first place? And TOCTOU window is definitely not wider that way.

If you want to have it done immediately after open(), bloody well do it immediately after open. If attacker has subverted your control flow to the extent that allows them to hit descriptor table in the interval between these two syscalls, you have already lost - they'll simply prevent that flag from being passed.

What's the point of burying it inside openat2()? A convenient multiplexor to hook into? We already have one - it's called do_syscall_...

#43 lore raw
Quoted 7 lines · Al Viro
Quoted 2 lines · Mickaël Salaün

Hooking on open is a simple design that enables processes to check files they intend to open, before they open them.

Which is a good thing, because...?

Quoted 8 lines
Quoted 4 lines

From an API point of view,
this series extends openat2(2) with one simple flag: O_MAYEXEC. The enforcement is then subject to the system policy (e.g. mount points, file access rights, IMA, etc.).

That's what "unspecified" means - as far as the kernel concerned, it's "something completely opaque, will let these hooks to play, semantics is entirely up to them".

I see it as an access controls mechanism; access may be granted or denied, as for O_RDONLY, O_WRONLY or (non-Linux) O_EXEC. Even for common access controls, there are capabilities to bypass them (i.e. CAP_DAC_OVERRIDE), but multiple layers may enforce different complementary policies.

Quoted 9 lines
Quoted 7 lines

Checking on open enables to not open a file if it does not meet some requirements, the same way as if the path doesn't exist or (for whatever reasons, including execution permission) if access is denied. It is a good practice to check as soon as possible such properties, and it may enables to avoid (user space) time-of-check to time-of-use (TOCTOU) attacks (i.e. misuse of already open resources).

????? You explicitly assume a cooperating caller.

As said in the below (removed) reply, no, quite the contrary.

Quoted 4 lines

If it can't be trusted
to issue the check between open and use, or can be manipulated (ptraced, etc.) into not doing so, how can you rely upon the flag having been passed in the first place? And TOCTOU window is definitely not wider that way.

OK, I guess it would be considered a bug in the application (e.g. buggy resource management between threads).

Quoted 10 lines

If you want to have it done immediately after open(), bloody well do it immediately after open. If attacker has subverted your control flow to the extent that allows them to hit descriptor table in the interval between these two syscalls, you have already lost - they'll simply prevent that flag from being passed.

What's the point of burying it inside openat2()? A convenient multiplexor to hook into? We already have one - it's called do_syscall_...

To check as soon as possible without opening something that should not be opened in the first place.

Isn't a dedicated syscall a bit too much for this feature? What about adding a new command/flag to fcntl(2)?