From: Eric W. Biederman <hidden> Date: 2020-03-10 19:30:02
Jann Horn [off-list ref] writes:
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
Please don't. Just use the new exec_update_mutex like everywhere else.
quoted
Cc: Sargun Dhillon <redacted>
Cc: Christian Brauner <redacted>
Cc: Arnd Bergmann <arnd@arndb.de>
Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
Signed-off-by: "Eric W. Biederman" <redacted>
---
kernel/pid.c | 6 ------
1 file changed, 6 deletions(-)
Christian if you don't have any objections I will take this one through
my tree.
I tried to figure out why this code path takes the cred_guard_mutex and
the archive on lore.kernel.org was not helpful in finding that part of
the conversation.
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
Wouldn't it be sufficient to simply test ptrace_may_access after
we get a copy of the file?
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Eric
On Tue, Mar 10, 2020 at 8:29 PM Eric W. Biederman [off-list ref] wrote:
Jann Horn [off-list ref] writes:
quoted
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
Please don't. Just use the new exec_update_mutex like everywhere else.
quoted
Cc: Sargun Dhillon <redacted>
Cc: Christian Brauner <redacted>
Cc: Arnd Bergmann <arnd@arndb.de>
Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
Signed-off-by: "Eric W. Biederman" <redacted>
---
kernel/pid.c | 6 ------
1 file changed, 6 deletions(-)
Christian if you don't have any objections I will take this one through
my tree.
I tried to figure out why this code path takes the cred_guard_mutex and
the archive on lore.kernel.org was not helpful in finding that part of
the conversation.
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
Hmm, I guess so? Normally, a task that's changing credentials becomes
nondumpable at the same time (and there are explicit memory barriers
in commit_creds() and __ptrace_may_access() to enforce the ordering
for this); so you normally don't see tasks becoming ptrace-accessible
via anything other than execve(). But I guess if someone opens a
root-only file, closes it, drops privileges, and then explicitly does
prctl(PR_SET_DUMPABLE, 1), we should probably protect that, too.
Wouldn't it be sufficient to simply test ptrace_may_access after
we get a copy of the file?
There are also setuid helpers that can, after having done privileged
stuff, drop privileges and call execve(); after that,
ptrace_may_access() succeeds again. In particular, polkit has a helper
that does this.
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Hmm... what benefits do we get from making it a separate lock? I guess
it would allow us to make it a per-task lock instead of a
signal_struct-wide one? That might be helpful...
On Tue, Mar 10, 2020 at 9:00 PM Jann Horn [off-list ref] wrote:
On Tue, Mar 10, 2020 at 8:29 PM Eric W. Biederman [off-list ref] wrote:
quoted
Jann Horn [off-list ref] writes:
quoted
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
[...]
quoted
quoted
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
[...]
quoted
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Hmm... what benefits do we get from making it a separate lock? I guess
it would allow us to make it a per-task lock instead of a
signal_struct-wide one? That might be helpful...
But actually, isn't the core purpose of the cred_guard_mutex to guard
against concurrent credential changes anyway? That's what almost
everyone uses it for, and it's in the name...
On Tue, Mar 10, 2020 at 9:00 PM Jann Horn [off-list ref] wrote:
quoted
On Tue, Mar 10, 2020 at 8:29 PM Eric W. Biederman [off-list ref] wrote:
quoted
Jann Horn [off-list ref] writes:
quoted
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
[...]
quoted
quoted
quoted
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
[...]
quoted
quoted
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Hmm... what benefits do we get from making it a separate lock? I guess
it would allow us to make it a per-task lock instead of a
signal_struct-wide one? That might be helpful...
But actually, isn't the core purpose of the cred_guard_mutex to guard
against concurrent credential changes anyway? That's what almost
everyone uses it for, and it's in the name...
The main reason d'etre of exec_update_mutex is to get a consitent
view of task->mm and task credentials.
The reason why you want the cred_guard_mutex, is that some action
is changing the resulting credentials that the execve is about
to install, and that is the data flow in the opposite direction.
Bernd.
On Tue, Mar 10, 2020 at 9:00 PM Jann Horn [off-list ref] wrote:
quoted
On Tue, Mar 10, 2020 at 8:29 PM Eric W. Biederman [off-list ref] wrote:
quoted
Jann Horn [off-list ref] writes:
quoted
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
[...]
quoted
quoted
quoted
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
[...]
quoted
quoted
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Hmm... what benefits do we get from making it a separate lock? I guess
it would allow us to make it a per-task lock instead of a
signal_struct-wide one? That might be helpful...
But actually, isn't the core purpose of the cred_guard_mutex to guard
against concurrent credential changes anyway? That's what almost
everyone uses it for, and it's in the name...
The main reason d'etre of exec_update_mutex is to get a consitent
view of task->mm and task credentials.
quoted
The reason why you want the cred_guard_mutex, is that some action
is changing the resulting credentials that the execve is about
to install, and that is the data flow in the opposite direction.
So in other words, you need the exec_update_mutex when you
access another thread's credentials and possibly the mmap at the
same time.
You need the cred_guard_mutex when you *change* the credentials
of another thread. (Where you cannot be sure that the other thread
just started to execve something)
You need no mutex at all when you are just accessing or
even changing the credentials of the current thread. (If another
thread is doing execve, your task will be killed, and wether
or not the credentials were changed does not matter any more)
On Wed, Mar 11, 2020 at 7:12 AM Bernd Edlinger
[off-list ref] wrote:
On 3/10/20 9:22 PM, Bernd Edlinger wrote:
quoted
On 3/10/20 9:10 PM, Jann Horn wrote:
quoted
On Tue, Mar 10, 2020 at 9:00 PM Jann Horn [off-list ref] wrote:
quoted
On Tue, Mar 10, 2020 at 8:29 PM Eric W. Biederman [off-list ref] wrote:
quoted
Jann Horn [off-list ref] writes:
quoted
On Tue, Mar 10, 2020 at 7:54 PM Eric W. Biederman [off-list ref] wrote:
quoted
During exec some file descriptors are closed and the files struct is
unshared. But all of that can happen at other times and it has the
same protections during exec as at ordinary times. So stop taking the
cred_guard_mutex as it is useless.
Furthermore he cred_guard_mutex is a bad idea because it is deadlock
prone, as it is held in serveral while waiting possibly indefinitely
for userspace to do something.
[...]
quoted
quoted
quoted
If you make this change, then if this races with execution of a setuid
program that afterwards e.g. opens a unix domain socket, an attacker
will be able to steal that socket and inject messages into
communication with things like DBus. procfs currently has the same
race, and that still needs to be fixed, but at least procfs doesn't
let you open things like sockets because they don't have a working
->open handler, and it enforces the normal permission check for
opening files.
It isn't only exec that can change credentials. Do we need a lock for
changing credentials?
[...]
quoted
quoted
If we need a lock around credential change let's design and build that.
Having a mismatch between what a lock is designed to do, and what
people use it for can only result in other bugs as people get confused.
Hmm... what benefits do we get from making it a separate lock? I guess
it would allow us to make it a per-task lock instead of a
signal_struct-wide one? That might be helpful...
But actually, isn't the core purpose of the cred_guard_mutex to guard
against concurrent credential changes anyway? That's what almost
everyone uses it for, and it's in the name...
The main reason d'etre of exec_update_mutex is to get a consitent
view of task->mm and task credentials.
quoted
The reason why you want the cred_guard_mutex, is that some action
is changing the resulting credentials that the execve is about
to install, and that is the data flow in the opposite direction.
So in other words, you need the exec_update_mutex when you
access another thread's credentials and possibly the mmap at the
same time.
Or the file descriptor table, or register state, ...
You need no mutex at all when you are just accessing or
even changing the credentials of the current thread. (If another
thread is doing execve, your task will be killed, and wether
or not the credentials were changed does not matter any more)
Only if the only access checks you care about are those related to mm access.