Skip to contentSkip to conversation

fs/pidfs: Add permission check to pidfd_info()

RFC PATCH In review [email protected] 2 participants 6 messages Feb 6 – Feb 24

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

RFC PATCH 1/1 fs/pidfs: Add permission check to pidfd_info()

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

I have also noticed that it is possible to use pidfds to poll on any process regardless of whether the process is a child of the caller, has a different UID, or has a different security context. Is this also worth addressing? If so, what exactly should the DAC checks be?

---
 fs/pidfs.c | 7 +++++++
 1 file changed, 7 insertions(+)
fs/pidfs.c +7 -0
index dba703d4ce4a..058a7d798bca 100644
@@ -365,6 +365,13 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)
 		goto copy_out;
 	}
 
+	/*
+	 * Do a filesystem cred ptrace check to verify access
+	 * to the task's info.
+	 */
+	if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
+		return -EACCES;
+
 	c = get_task_cred(task);
 	if (!c)
 		return -ESRCH;
Signature · 1 line
2.52.0
#1 lore raw
Quoted 8 lines · On Fri, Feb 06, 2026 at 06:02:48PM +0000, [email protected] wrote:

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

Quoted 4 lines

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

This isn't really workable since this would regress userspace quite a bit. I think we need a different approach. I've given it some thought and everything's kinda ugly but this might work.

In struct pid_namespace record whether anyone ever mounted a procfs with hidepid turned on for this pidns. In pidfd_info() we check whether hidepid was ever turned on. If it wasn't we're done and can just return the info. This will be the common case. If hidepid was ever turned on use kern_path("/proc") to lookup procfs. If not found check ptrace_may_access() to decide whether to return the info or not. If /proc is found check it's hidepid settings and make a decision based on that.

You can probably reorder this to call ptrace_may_access() first and then do the procfs lookup dance. Thoughts?

Quoted 4 lines

I have also noticed that it is possible to use pidfds to poll on any process regardless of whether the process is a child of the caller, has a different UID, or has a different security context. Is this also worth addressing? If so, what exactly should the DAC checks be?

Oleg and I had discusses this and decided that such polling isn't sensitive information so by default this should just work and it's relied upon in Android and in a bunch of other workloads. An LSM can of course restrict access via security_file_ioctl().

Fwiw, pidfds now support persistent trusted extended attributes so if the LSM folks wanted we can add security.* extended attribute support and they can mark pidfds with persistent security labels - persistent as in for the lifetime of the task.

Quoted 26 lines
---
 fs/pidfs.c | 7 +++++++
 1 file changed, 7 insertions(+)
fs/pidfs.c +7 -0
index dba703d4ce4a..058a7d798bca 100644
@@ -365,6 +365,13 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)
 		goto copy_out;
 	}
 
+	/*
+	 * Do a filesystem cred ptrace check to verify access
+	 * to the task's info.
+	 */
+	if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
+		return -EACCES;
+
 	c = get_task_cred(task);
 	if (!c)
 		return -ESRCH;
Signature · 1 line
2.52.0
#2 lore raw
Quoted 28 lines · Christian Brauner
Quoted 8 lines · On Fri, Feb 06, 2026 at 06:02:48PM +0000, [email protected] wrote:

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

Quoted 4 lines

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

This isn't really workable since this would regress userspace quite a bit. I think we need a different approach. I've given it some thought and everything's kinda ugly but this might work.

In struct pid_namespace record whether anyone ever mounted a procfs with hidepid turned on for this pidns. In pidfd_info() we check whether hidepid was ever turned on. If it wasn't we're done and can just return the info. This will be the common case. If hidepid was ever turned on use kern_path("/proc") to lookup procfs. If not found check ptrace_may_access() to decide whether to return the info or not. If /proc is found check it's hidepid settings and make a decision based on that.

Quoted 2 lines

You can probably reorder this to call ptrace_may_access() first and then do the procfs lookup dance. Thoughts?

Thanks for the feedback. I think your solution makes sense.

Unfortunately, it seems like systemd mounts procfs with hidepid enabled on boot for services with the ProtectProc option enabled. This means that procfs will always have been mounted with hidepid in the init pid namespace. Do you think it would be viable to record whether or not procfs was mounted with hidepid enabled in the mount namespace instead?

Quoted 41 lines
Quoted 4 lines

I have also noticed that it is possible to use pidfds to poll on any process regardless of whether the process is a child of the caller, has a different UID, or has a different security context. Is this also worth addressing? If so, what exactly should the DAC checks be?

Oleg and I had discusses this and decided that such polling isn't sensitive information so by default this should just work and it's relied upon in Android and in a bunch of other workloads. An LSM can of course restrict access via security_file_ioctl().

Fwiw, pidfds now support persistent trusted extended attributes so if the LSM folks wanted we can add security.* extended attribute support and they can mark pidfds with persistent security labels - persistent as in for the lifetime of the task.

Quoted 26 lines
---
 fs/pidfs.c | 7 +++++++
 1 file changed, 7 insertions(+)
fs/pidfs.c +7 -1
index dba703d4ce4a..058a7d798bca 100644
@@ -365,6 +365,13 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)
              goto copy_out;
      }
 
+     /*
+      * Do a filesystem cred ptrace check to verify access
+      * to the task's info.
+      */
+     if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
+             return -EACCES;
+
      c = get_task_cred(task);
      if (!c)
              return -ESRCH;
--

2.52.0

#3 lore raw
Quoted 32 lines · Daniel Durning
Quoted 28 lines · Christian Brauner
Quoted 8 lines · On Fri, Feb 06, 2026 at 06:02:48PM +0000, [email protected] wrote:

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

Quoted 4 lines

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

This isn't really workable since this would regress userspace quite a bit. I think we need a different approach. I've given it some thought and everything's kinda ugly but this might work.

In struct pid_namespace record whether anyone ever mounted a procfs with hidepid turned on for this pidns. In pidfd_info() we check whether hidepid was ever turned on. If it wasn't we're done and can just return the info. This will be the common case. If hidepid was ever turned on use kern_path("/proc") to lookup procfs. If not found check ptrace_may_access() to decide whether to return the info or not. If /proc is found check it's hidepid settings and make a decision based on that.

Quoted 2 lines

You can probably reorder this to call ptrace_may_access() first and then do the procfs lookup dance. Thoughts?

Quoted 7 lines

Thanks for the feedback. I think your solution makes sense.

Unfortunately, it seems like systemd mounts procfs with hidepid enabled on boot for services with the ProtectProc option enabled. This means that procfs will always have been mounted with hidepid in the init pid namespace. Do you think it would be viable to record whether or not procfs was mounted with hidepid enabled in the mount namespace instead?

I guess we can see what it looks like.

#4 lore raw
Quoted 36 lines · Christian Brauner
Quoted 34 lines · Daniel Durning
Quoted 28 lines · Christian Brauner
Quoted 8 lines · On Fri, Feb 06, 2026 at 06:02:48PM +0000, [email protected] wrote:

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

Quoted 4 lines

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

This isn't really workable since this would regress userspace quite a bit. I think we need a different approach. I've given it some thought and everything's kinda ugly but this might work.

In struct pid_namespace record whether anyone ever mounted a procfs with hidepid turned on for this pidns. In pidfd_info() we check whether hidepid was ever turned on. If it wasn't we're done and can just return the info. This will be the common case. If hidepid was ever turned on use kern_path("/proc") to lookup procfs. If not found check ptrace_may_access() to decide whether to return the info or not. If /proc is found check it's hidepid settings and make a decision based on that.

Quoted 2 lines

You can probably reorder this to call ptrace_may_access() first and then do the procfs lookup dance. Thoughts?

Thanks for the feedback. I think your solution makes sense.

Quoted 7 lines
Quoted 5 lines

Unfortunately, it seems like systemd mounts procfs with hidepid enabled on boot for services with the ProtectProc option enabled. This means that procfs will always have been mounted with hidepid in the init pid namespace. Do you think it would be viable to record whether or not procfs was mounted with hidepid enabled in the mount namespace instead?

I guess we can see what it looks like.

Having looked into this some more I am not sure if the mount namespace is viable either since a single proc instance could be in multiple mount namespaces. In addition the mount namespace does not seem to be easily accessible in the function where proc mount options are applied. I also considered adding an option similar to hidepid to pidfs, but since pidfs is not userspace-mounted I do not think that is possible without some significant changes.

Doing a proc lookup with kern_path() does work, but it does not seem practical in terms of performance unless we had some other way to skip it in the common case.

Curious if anyone else has any ideas or suggestions on how this could be implemented.

#5 lore raw
Quoted 53 lines · Daniel Durning
Quoted 36 lines · Christian Brauner
Quoted 34 lines · Daniel Durning
Quoted 28 lines · Christian Brauner
Quoted 8 lines · On Fri, Feb 06, 2026 at 06:02:48PM +0000, [email protected] wrote:

From: Daniel Durning <[email protected]>

Added a permission check to pidfd_info(). Originally, process info could be retrieved with a pidfd even if proc was mounted with hidepid enabled, allowing pidfds to be used to bypass those protections. We now call ptrace_may_access() to perform some DAC checking as well as call the appropriate LSM hook.

Quoted 4 lines

The downside to this approach is that there are now more restrictions on accessing this info from a pidfd than when just using proc (without hidepid). I am open to suggestions if anyone can think of a better way to handle this.

This isn't really workable since this would regress userspace quite a bit. I think we need a different approach. I've given it some thought and everything's kinda ugly but this might work.

In struct pid_namespace record whether anyone ever mounted a procfs with hidepid turned on for this pidns. In pidfd_info() we check whether hidepid was ever turned on. If it wasn't we're done and can just return the info. This will be the common case. If hidepid was ever turned on use kern_path("/proc") to lookup procfs. If not found check ptrace_may_access() to decide whether to return the info or not. If /proc is found check it's hidepid settings and make a decision based on that.

Quoted 2 lines

You can probably reorder this to call ptrace_may_access() first and then do the procfs lookup dance. Thoughts?

Thanks for the feedback. I think your solution makes sense.

Quoted 7 lines
Quoted 5 lines

Unfortunately, it seems like systemd mounts procfs with hidepid enabled on boot for services with the ProtectProc option enabled. This means that procfs will always have been mounted with hidepid in the init pid namespace. Do you think it would be viable to record whether or not procfs was mounted with hidepid enabled in the mount namespace instead?

I guess we can see what it looks like.

Having looked into this some more I am not sure if the mount namespace is viable either since a single proc instance could be in multiple mount namespaces. In addition the mount namespace does not seem to be easily accessible in the function where proc mount options are applied. I also considered adding an option similar to hidepid to pidfs, but since pidfs is not userspace-mounted I do not think that is possible without some significant changes.

Quoted 6 lines

Doing a proc lookup with kern_path() does work, but it does not seem practical in terms of performance unless we had some other way to skip it in the common case.

Curious if anyone else has any ideas or suggestions on how this could be implemented.

Ok, so there's another series that adds support for allowing to mount procfs with subset=pid. That series currently uses an arcane mechanism where it walks all mounts in the caller mounts namespace to find procfs mounts and check its mount options (mount_too_revealing()). To get away from this barbaric hack I proposed recording all fully visible procfs mounts in a separate list on struct mnt_namespace that it can walk whenever a new procfs mount gets plugged in. Once we've done that work we effectively track whenever a procfs mount comes and goes from a given mount namespace. When we plug in that mount we simply remember the option used for the least restrictive procfs mount in that namespace in a per-mntns "proc_visiblity" field or something.

Then in pidfs we simply do a:

visibility_restricted = READ_ONCE(current->ns_proxy->mnt_ns);

and be done with it. No locks, no lookup, no perf hit. Thoughts?