mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
@ 2026-11-17 15:23 Jiwoo Kim
  2026-11-17 16:20 ` Bradley Morgan
  2026-11-19 13:42 ` Alexander Mikhalitsyn
  0 siblings, 2 replies; 4+ messages in thread
From: Jiwoo Kim @ 2026-11-17 15:23 UTC (permalink / raw)
  To: Christian Brauner
  Cc: Sargun Dhillon, Arnd Bergmann, Jann Horn, Chen Linxuan,
	linux-fsdevel, linux-api, linux-kernel

pidfds can cross pid namespace boundaries: a task can obtain one for a
process outside of its own pid namespace hierarchy through SO_PASSPIDFD
or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
inheritance.

Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the caller's
pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
unless the target is visible in the caller's active pid namespace, as
PIDFD_GET_INFO already does, following the rule that operations which
grant access to additional resources of the target require this [1].

pidfd_getfd() grants access to the target's open files, but it only
performs the ptrace access check, which does not take the pid namespace
relationship between the caller and the target into account. With the
caller in a child pid namespace and in the same user namespace as the
target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
for such a pidfd, while pidfd_getfd() on the same pidfd returns a
duplicate of the target's file descriptor.

Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless the
target is visible in the caller's active pid namespace. Callers in
ancestor pid namespaces are unaffected.

This was found with an AI coding assistant, which also drafted this
patch and its changelog. The problem was reproduced in a QEMU guest,
and the fix was tested there.

Link: https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/ [1]
Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
Cc: stable@vger.kernel.org
Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
---
-EREMOTE is a new error for pidfd_getfd(). The check is done before the
task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of the
caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH, and
the check comes before the ptrace access check.

setns() also accepts such pidfds without this check, but it requires
CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
here.

A reproducer is available on request.

 kernel/pid.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/kernel/pid.c b/kernel/pid.c
index adf721606768..4f9a29eb29de 100644
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
 	struct file *file;
 	int ret;
 
+	/*
+	 * Require the target to be visible in the caller's pid namespace,
+	 * like the pidfs ioctls that grant access to its resources.
+	 */
+	if (!pid_vnr(pid))
+		return -EREMOTE;
+
 	task = get_pid_task(pid, PIDTYPE_PID);
 	if (!task)
 		return -ESRCH;
@@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
  *
  * This syscall gets a copy of a file descriptor from another process
  * based on the pidfd, and file descriptor number. It requires that
- * the calling process has the ability to ptrace the process represented
- * by the pidfd. The process which is having its file descriptor copied
- * is otherwise unaffected.
+ * the process represented by the pidfd is visible in the caller's pid
+ * namespace and that the calling process has the ability to ptrace it.
+ * The process which is having its file descriptor copied is otherwise
+ * unaffected.
  *
  * Return: On success, a cloexec file descriptor is returned.
  *         On error, a negative errno number will be returned.

base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f
-- 
2.43.0


^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
@ 2026-11-17 16:20 ` Bradley Morgan
  2026-11-19 13:42 ` Alexander Mikhalitsyn
  1 sibling, 0 replies; 4+ messages in thread
From: Bradley Morgan @ 2026-11-17 16:20 UTC (permalink / raw)
  To: arpe1618
  Cc: arnd, brauner, jannh, linux-api, linux-fsdevel, linux-kernel, me, sargun

On 17 November 2026 15:23:32 GMT, Jiwoo Kim <arpe1618@gmail.com> wrote:
>pidfds can cross pid namespace boundaries: a task can obtain one for a
>process outside of its own pid namespace hierarchy through SO_PASSPIDFD
>or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
>inheritance.
>
>Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the caller's
>pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
>unless the target is visible in the caller's active pid namespace, as
>PIDFD_GET_INFO already does, following the rule that operations which
>grant access to additional resources of the target require this [1].
>
>pidfd_getfd() grants access to the target's open files, but it only
>performs the ptrace access check, which does not take the pid namespace
>relationship between the caller and the target into account. With the
>caller in a child pid namespace and in the same user namespace as the
>target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
>for such a pidfd, while pidfd_getfd() on the same pidfd returns a
>duplicate of the target's file descriptor.
>
>Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless the
>target is visible in the caller's active pid namespace. Callers in
>ancestor pid namespaces are unaffected.
>
>This was found with an AI coding assistant, which also drafted this
>patch and its changelog. The problem was reproduced in a QEMU guest,
>and the fix was tested there.
>
>Link: https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/ [1]
>Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
>Cc: stable@vger.kernel.org

Reviewed-by: Bradley Morgan <bradley.morgan@linux.dev>

>Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
>---
>-EREMOTE is a new error for pidfd_getfd(). The check is done before the
>task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of the
>caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH, and
>the check comes before the ptrace access check.
>
>setns() also accepts such pidfds without this check, but it requires
>CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
>here.
>
>A reproducer is available on request.
>
> kernel/pid.c | 14 +++++++++++---
> 1 file changed, 11 insertions(+), 3 deletions(-)
>
>diff --git a/kernel/pid.c b/kernel/pid.c
>index adf721606768..4f9a29eb29de 100644
>--- a/kernel/pid.c
>+++ b/kernel/pid.c
>@@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
> 	struct file *file;
> 	int ret;
> 
>+	/*
>+	 * Require the target to be visible in the caller's pid namespace,
>+	 * like the pidfs ioctls that grant access to its resources.
>+	 */
>+	if (!pid_vnr(pid))
>+		return -EREMOTE;
>+
> 	task = get_pid_task(pid, PIDTYPE_PID);
> 	if (!task)
> 		return -ESRCH;
>@@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
>  *
>  * This syscall gets a copy of a file descriptor from another process
>  * based on the pidfd, and file descriptor number. It requires that
>- * the calling process has the ability to ptrace the process represented
>- * by the pidfd. The process which is having its file descriptor copied
>- * is otherwise unaffected.
>+ * the process represented by the pidfd is visible in the caller's pid
>+ * namespace and that the calling process has the ability to ptrace it.
>+ * The process which is having its file descriptor copied is otherwise
>+ * unaffected.
>  *
>  * Return: On success, a cloexec file descriptor is returned.
>  *         On error, a negative errno number will be returned.
>
>base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f
>


--- Thanks!

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
  2026-11-17 16:20 ` Bradley Morgan
@ 2026-11-19 13:42 ` Alexander Mikhalitsyn
  2026-11-19 13:54   ` Jiwoo Kim
  1 sibling, 1 reply; 4+ messages in thread
From: Alexander Mikhalitsyn @ 2026-11-19 13:42 UTC (permalink / raw)
  To: Jiwoo Kim, Christian Brauner
  Cc: Sargun Dhillon, Arnd Bergmann, Jann Horn, Chen Linxuan,
	linux-fsdevel, linux-api, linux-kernel

On Wed, 2026-11-18 at 00:23 +0900, Jiwoo Kim wrote:
> pidfds can cross pid namespace boundaries: a task can obtain one for
> a
> process outside of its own pid namespace hierarchy through
> SO_PASSPIDFD
> or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
> inheritance.
> 
> Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the
> caller's
> pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
> unless the target is visible in the caller's active pid namespace, as
> PIDFD_GET_INFO already does, following the rule that operations which
> grant access to additional resources of the target require this [1].
> 

Hi Jiwoo,

> pidfd_getfd() grants access to the target's open files, but it only
> performs the ptrace access check, which does not take the pid
> namespace
> relationship between the caller and the target into account. With the
> caller in a child pid namespace and in the same user namespace as the
> target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
> for such a pidfd, while pidfd_getfd() on the same pidfd returns a
> duplicate of the target's file descriptor.

It it an interesting point, because pid namespace itself it not a
security boundary. While user namespace and capabilities are mechanisms
to manage permissions.

Currently, you can do something like this on your machine:

# Terminal 0

echo $$ # note this PID we will use it in "Terminal 1"

# Terminal 1

sudo unshare -f -p 
echo hello > /proc/<PID>/fd/0

and this will actually print hello in the Terminal 0, while the process
doing that lives in nested pid namespace. But this is not a problem
because this guy is a root:

# Terminal 1
cat /proc/self/status | grep CapEff

So please understand me right, I'm not saying that your point is not
valid, but I'm not sure what was the intention behind pid_getfd() API
in the first place and we might want to have semantics and model close
to the one procfs has.

Speaking about other cases, where we *do* have this check:
- for exportfs operations it completely makes sense, because filehandle
  contains an inode number and user space may accidentally (due to the
memory corruption or purposefully craft it). When I call
open_by_handle_at I *do* expect to get something from my own PID
namespace.

- pidfd_ioctl since ee8323fdc827c580425644db605a4be776cace57 ("pidfd:
restrict task access ioctls to the caller's pid namespace") doesn't
allow to open namespace files, while procfs has no problem with this
(it works you can try)

- pidfd_info() also forbids cross pidns information retrieval and for
part of it functionallity we can do it through procfs, but for exit
info or coredump we can't

To conclude, it looks like we have a little bit of inconsistencies
around here :-) [ But please, don't go and change anything in procfs as
we might break some tricky use-cases like CRIU and SCM_RIGHTS users. ]

IMHO.

Kind regards,
Alex

> 
> Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless
> the
> target is visible in the caller's active pid namespace. Callers in
> ancestor pid namespaces are unaffected.
> 
> This was found with an AI coding assistant, which also drafted this
> patch and its changelog. The problem was reproduced in a QEMU guest,
> and the fix was tested there.
> 
> Link:
> https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/
>  [1]
> Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
> Cc: stable@vger.kernel.org
> Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
> ---
> -EREMOTE is a new error for pidfd_getfd(). The check is done before
> the
> task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of
> the
> caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH,
> and
> the check comes before the ptrace access check.
> 
> setns() also accepts such pidfds without this check, but it requires
> CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
> here.
> 
> A reproducer is available on request.
> 
>  kernel/pid.c | 14 +++++++++++---
>  1 file changed, 11 insertions(+), 3 deletions(-)
> 
> diff --git a/kernel/pid.c b/kernel/pid.c
> index adf721606768..4f9a29eb29de 100644
> --- a/kernel/pid.c
> +++ b/kernel/pid.c
> @@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
>  	struct file *file;
>  	int ret;
>  
> +	/*
> +	 * Require the target to be visible in the caller's pid
> namespace,
> +	 * like the pidfs ioctls that grant access to its resources.
> +	 */
> +	if (!pid_vnr(pid))
> +		return -EREMOTE;
> +
>  	task = get_pid_task(pid, PIDTYPE_PID);
>  	if (!task)
>  		return -ESRCH;
> @@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
>   *
>   * This syscall gets a copy of a file descriptor from another
> process
>   * based on the pidfd, and file descriptor number. It requires that
> - * the calling process has the ability to ptrace the process
> represented
> - * by the pidfd. The process which is having its file descriptor
> copied
> - * is otherwise unaffected.
> + * the process represented by the pidfd is visible in the caller's
> pid
> + * namespace and that the calling process has the ability to ptrace
> it.
> + * The process which is having its file descriptor copied is
> otherwise
> + * unaffected.
>   *
>   * Return: On success, a cloexec file descriptor is returned.
>   *         On error, a negative errno number will be returned.
> 
> base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-19 13:42 ` Alexander Mikhalitsyn
@ 2026-11-19 13:54   ` Jiwoo Kim
  0 siblings, 0 replies; 4+ messages in thread
From: Jiwoo Kim @ 2026-11-19 13:54 UTC (permalink / raw)
  To: Alexander Mikhalitsyn
  Cc: Christian Brauner, Sargun Dhillon, Arnd Bergmann, Jann Horn,
	Chen Linxuan, linux-fsdevel, linux-api, linux-kernel

On Thu, 2026-11-19 at 14:42 +0100, Alexander Mikhalitsyn wrote:
> It it an interesting point, because pid namespace itself it not a
> security boundary. While user namespace and capabilities are mechanisms
> to manage permissions.

Hi Alex,

thanks for looking at this.

Agreed, and the patch does not try to make it one. I followed the rule
Christian suggested in [1], requiring pid_vnr(pid) != 0 for operations
that grant access to additional resources of the target, which
ee8323fdc827 then applied to the namespace ioctls. pidfd_getfd() hands
out one of the target's open files, so it looked like it belongs to the
same group.

> Currently, you can do something like this on your machine:
[...]
> and this will actually print hello in the Terminal 0, while the process
> doing that lives in nested pid namespace. But this is not a problem
> because this guy is a root:

Right. As far as I can see this also works for an unprivileged task of
the same uid, as long as it can reach the outer task through a procfs
instance of the outer pid namespace. So pidfd_getfd() currently behaves
like procfs here, and the patch would make it stricter than procfs, in
line with the pidfd ioctls and PIDFD_GET_INFO instead.

The case I had in mind is the one Jann described in [2]: a task in a
child pid namespace that gets a pidfd for an outer task over a socket.
When it has no procfs view of the outer task, as in a container with its
own procfs, that pidfd is its only handle to it. There, the ioctls refuse
the pidfd with -EREMOTE, while pidfd_getfd() returns the target's file.

> So please understand me right, I'm not saying that your point is not
> valid, but I'm not sure what was the intention behind pid_getfd() API
> in the first place and we might want to have semantics and model close
> to the one procfs has.

Understood. If pidfd_getfd() should keep following the procfs model, I'm
fine with dropping this patch; the inconsistency would then be on the
ioctl side. I'll leave that to Christian.

> To conclude, it looks like we have a little bit of inconsistencies
> around here :-) [ But please, don't go and change anything in procfs as
> we might break some tricky use-cases like CRIU and SCM_RIGHTS users. ]

No plans to touch procfs.

[1] https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/
[2] https://lore.kernel.org/all/CAG48ez1T5-tUHVK_iHsgUtWa-inVdrZxA3E-ZCW0iENJvasKfg@mail.gmail.com/

Thanks,
Jiwoo Kim

^ permalink raw reply	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2026-11-19 13:55 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
2026-11-17 16:20 ` Bradley Morgan
2026-11-19 13:42 ` Alexander Mikhalitsyn
2026-11-19 13:54   ` Jiwoo Kim

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®