Skip to contentSkip to conversation

Relocate execve() sanity checks

PATCH In review Kees Cook 3 participants 8 messages Jun 5, 2020 – Aug 13, 2020

Subsystems (2)
lore
Share & tools
lore

Kees Cook

author
#0 lore raw

v2 cover Relocate execve() sanity checks

Hi,

While looking at the code paths for the proposed O_MAYEXEC flag, I saw some things that looked like they should be fixed up.

exec: Change uselib(2) IS_SREG() failure to EACCES
This just regularizes the return code on uselib(2).

exec: Move S_ISREG() check earlier
This moves the S_ISREG() check even earlier than it was already.

exec: Move path_noexec() check earlier
This adds the path_noexec() check to the same place as the S_ISREG() check.

v2:
- move checks into may_open() using acc_mode instead of f_mode to correctly compose with other inode file type tests[1].
- drop the FMODE_EXEC f_flags -> f_mode change for now since it remains unclear if it's useful (and is not needed any more for this series).
v1: https://lore.kernel.org/linux-api/[email protected]/

Thanks!

-Kees

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

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

 fs/exec.c  | 23 ++++++++++++++---------
 fs/namei.c | 10 ++++++++--
 fs/open.c  |  6 ------
 3 files changed, 22 insertions(+), 17 deletions(-)
Signature · 1 line
2.25.1
author
#1 lore raw

PATCH v2 1/3 exec: Change uselib(2) IS_SREG() failure to EACCES

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 06b4c550af5d..30735ce1dc0e 100644
@@ -139,11 +139,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.25.1
author
#2 lore raw

PATCH v2 2/3 exec: Move S_ISREG() check earlier

In reply to Kees Cook

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 30735ce1dc0e..2b708629dcd6 100644
@@ -139,8 +139,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))
@@ -860,8 +865,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 a320371899cf..0a759b68d66e 100644
@@ -2835,16 +2835,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 719b320ede52..bb16e4e3cd57 100644
@@ -753,12 +753,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.25.1
#3 lore raw

Re: [PATCH v2 2/3] exec: Move S_ISREG() check earlier

On Fri, 5 Jun 2020 09:00:12 -0700
Kees Cook <[email protected]> wrote:

Hi Kees,

Quoted 85 lines

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 30735ce1dc0e..2b708629dcd6 100644
@@ -139,8 +139,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))
@@ -860,8 +865,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 a320371899cf..0a759b68d66e 100644

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

Quoted 6 lines
fs/namei.c +1 -1
@@ -2835,16 +2835,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;

This seems to change (break?) the behaviour of syscalls such as execv, which can now return -EISDIR, whereas the existing behaviour was to return -EACCES. The man page never hints at the possibility of -EISDIR being returned, making it feel like a regression.

POSIX (FWIW) also says:

<quote>
[EACCES]
The new process image file is not a regular file and the implementation does not support execution of files of its type.
</quote>

This has been picked up by the Bionic test suite[1], but can just as easily be reproduced with the following snippet:

$ cat x.c
#include <unistd.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
	execv("/", NULL);
	perror("execv");
	return 0;
}

Before this patch:

$ ./x
execv: Permission denied

After this patch:

$ ./x
execv: Is a directory

Thanks,

	M.

[1] https://android.googlesource.com/platform/bionic/+/master/tests/unistd_test.cpp#1346

Signature · 1 line
Jazz is not dead. It just smells funny...
author
#4 lore raw

Re: [PATCH v2 2/3] exec: Move S_ISREG() check earlier

Quoted 123 lines · Marc Zyngier

On Fri, 5 Jun 2020 09:00:12 -0700
Kees Cook <[email protected]> wrote:

Hi Kees,

Quoted 85 lines

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 30735ce1dc0e..2b708629dcd6 100644
@@ -139,8 +139,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))
@@ -860,8 +865,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 a320371899cf..0a759b68d66e 100644

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

Quoted 6 lines
fs/namei.c +1 -1
@@ -2835,16 +2835,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;

This seems to change (break?) the behaviour of syscalls such as execv, which can now return -EISDIR, whereas the existing behaviour was to return -EACCES. The man page never hints at the possibility of -EISDIR being returned, making it feel like a regression.

POSIX (FWIW) also says:

<quote>
[EACCES]
The new process image file is not a regular file and the implementation does not support execution of files of its type.
</quote>

This has been picked up by the Bionic test suite[1], but can just as easily be reproduced with the following snippet:

$ cat x.c
#include <unistd.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
	execv("/", NULL);
	perror("execv");
	return 0;
}
Quoted 7 lines

Before this patch:

$ ./x
execv: Permission denied

After this patch:

$ ./x
execv: Is a directory

That's a good point, yes. I will submit a fix for this.

Signature · 1 line
Kees Cook
author
#5 lore raw

PATCH v2 3/3 exec: Move path_noexec() check earlier

In reply to Kees Cook

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 2b708629dcd6..7ac50a260df3 100644
@@ -145,10 +145,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);
@@ -871,10 +869,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 0a759b68d66e..41e6fed8ce69 100644
@@ -2849,6 +2849,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.25.1
#6 lore raw
In reply to Kees Cook
Quoted 6 lines · On Fri, 5 Jun 2020 09:00:10 -0700 Kees Cook <[email protected]> wrote:

While looking at the code paths for the proposed O_MAYEXEC flag, I saw some things that looked like they should be fixed up.

exec: Change uselib(2) IS_SREG() failure to EACCES
This just regularizes the return code on uselib(2).

Quoted 6 lines

exec: Move S_ISREG() check earlier
This moves the S_ISREG() check even earlier than it was already.

exec: Move path_noexec() check earlier
This adds the path_noexec() check to the same place as the S_ISREG() check.

Thanks.

These don't seem super-urgent and they aren't super-reviewed, so I suggest we hold them off until the next cycle?

author
#7 lore raw
Quoted 11 lines · Andrew Morton
Quoted 9 lines · On Fri, 5 Jun 2020 09:00:10 -0700 Kees Cook <[email protected]> wrote:

While looking at the code paths for the proposed O_MAYEXEC flag, I saw some things that looked like they should be fixed up.

exec: Change uselib(2) IS_SREG() failure to EACCES
This just regularizes the return code on uselib(2).

exec: Move S_ISREG() check earlier
This moves the S_ISREG() check even earlier than it was already.

Quoted 8 lines
Quoted 3 lines

exec: Move path_noexec() check earlier
This adds the path_noexec() check to the same place as the S_ISREG() check.

Thanks.

These don't seem super-urgent and they aren't super-reviewed, so I suggest we hold them off until the next cycle?

Agreed; that's fine by me. It's mostly clean up and preparation for performing future checking through the MAY_EXEC path.

And I'd love to get an Ack from Al or Aleksa, nudge nudge. :)

Signature · 1 line
Kees Cook