Re: [PATCH v11 2/3] capabilities: don't let ptrace borrow CAP_SETFCAP
From: Serge E. Hallyn
Date: Fri Nov 20 2026 - 12:31:45 EST
On Tue, Nov 17, 2026 at 07:54:25PM +0000, Josef Bacik wrote:
> A uid 0 task that gave up CAP_SETFCAP and CAP_SYS_PTRACE can still
> attach to a task in a user namespace that another root task created,
> and have it write file capabilities for its root user. For a target in
> a child namespace cap_ptrace_access_check() asks for CAP_SYS_PTRACE over
> that namespace, and cap_capable() grants every capability there to a
> task whose euid owns it, whatever it gave up:
>
> task A: uid 0, full caps task B: uid 0, no CAP_SETFCAP,
> unshare(CLONE_NEWUSER) no CAP_SYS_PTRACE
> ptrace(PTRACE_ATTACH, A)
> euid == ns->owner -> allowed
> make A write "0 0 1" to its uid_map,
> or set file capabilities
>
> The same goes for /proc/<pid>/mem, process_vm_writev() and
> pidfd_getfd(). setns() refuses B now, so ptrace is the way left into
> the namespace.
>
> The target's own capabilities are no guide. A target that gave up
> CAP_SETFCAP can still get it back from its inheritable set on execve(),
> take it from another task of its namespace if it kept CAP_SYS_PTRACE, or
> write "0 0 1" to its namespace's uid_map while there is none yet.
>
> Every PTRACE_MODE_ATTACH check is refused, so reading /proc/<pid>/mem,
> /proc/<pid>/stack and process_vm_readv() of such a target go too.
> PTRACE_MODE_READ, a tracer and target in the same namespace, and targets
> in namespaces that setns() lets the tracer into are not affected.
> Within one namespace the usual rules apply, as for every other
> capability. A tracer with CAP_SYS_PTRACE but not CAP_SETFCAP is refused
> as well: whether CAP_SYS_PTRACE lets it take CAP_SETFCAP from a task of
> its own namespace depends on LSMs such as Yama.
>
> Fix by refusing PTRACE_MODE_ATTACH and PTRACE_TRACEME across user
> namespaces when the tracer doesn't have CAP_SETFCAP and setns() would
> refuse it the target's namespace.
>
> Suggested-by: Serge Hallyn <serge@xxxxxxxxxx>
> Link: https://lore.kernel.org/all/fd159e68-c613-4c7d-bfba-8af0a3f3a96e@xxxxxxxxxx/
> Fixes: db2e718a4798 ("capabilities: require CAP_SETFCAP to map uid 0")
> Signed-off-by: Josef Bacik <josef@xxxxxxxxxxxxxx>
Thanks!
Reviewed-by: Serge Hallyn <serge@xxxxxxxxxx>
> ---
> security/commoncap.c | 34 ++++++++++++++++++++++++++++++----
> 1 file changed, 30 insertions(+), 4 deletions(-)
>
> diff --git a/security/commoncap.c b/security/commoncap.c
> index 96ac039fddad..4a78939d149b 100644
> --- a/security/commoncap.c
> +++ b/security/commoncap.c
> @@ -195,14 +195,31 @@ int cap_settime(const struct timespec64 *ts, const struct timezone *tz)
> return 0;
> }
>
> +/*
> + * A tracer that setns() keeps out of a namespace mustn't take control of a
> + * task there either, whatever that task holds itself: it can get CAP_SETFCAP
> + * back on execve(), from another task of its namespace it traces, or by
> + * writing the uid_map of a namespace that doesn't have one yet. Within one
> + * namespace the usual rules apply, as for every other capability.
> + */
> +static bool cap_ptrace_borrows_setfcap(const struct cred *cred,
> + const struct cred *child_cred)
> +{
> + return cred->user_ns != child_cred->user_ns &&
> + cred_borrows_setfcap(cred, child_cred->user_ns);
> +}
> +
> /**
> * cap_ptrace_access_check - Determine whether the current process may access
> * another
> * @child: The process to be accessed
> * @mode: The mode of attachment.
> *
> - * If we are in the same or an ancestor user_ns and have all the target
> - * task's capabilities, then ptrace access is allowed.
> + * For PTRACE_MODE_ATTACH, if we don't have CAP_SETFCAP and the target task
> + * is in another user_ns that setns() would keep us out of, then ptrace
> + * access is denied.
> + * Otherwise, if we are in the same or an ancestor user_ns and have all the
> + * target task's capabilities, then ptrace access is allowed.
> * If we have the ptrace capability to the target user_ns, then ptrace
> * access is allowed.
> * Else denied.
> @@ -223,11 +240,15 @@ int cap_ptrace_access_check(struct task_struct *child, unsigned int mode)
> caller_caps = &cred->cap_effective;
> else
> caller_caps = &cred->cap_permitted;
> + if ((mode & PTRACE_MODE_ATTACH) &&
> + cap_ptrace_borrows_setfcap(cred, child_cred))
> + goto deny;
> if (cred->user_ns == child_cred->user_ns &&
> cap_issubset(child_cred->cap_permitted, *caller_caps))
> goto out;
> if (ns_capable(child_cred->user_ns, CAP_SYS_PTRACE))
> goto out;
> +deny:
> ret = -EPERM;
> out:
> rcu_read_unlock();
> @@ -238,8 +259,10 @@ int cap_ptrace_access_check(struct task_struct *child, unsigned int mode)
> * cap_ptrace_traceme - Determine whether another process may trace the current
> * @parent: The task proposed to be the tracer
> *
> - * If parent is in the same or an ancestor user_ns and has all current's
> - * capabilities, then ptrace access is allowed.
> + * If parent doesn't have CAP_SETFCAP and current is in another user_ns
> + * that setns() would keep parent out of, then ptrace access is denied.
> + * Otherwise, if parent is in the same or an ancestor user_ns and has all
> + * current's capabilities, then ptrace access is allowed.
> * If parent has the ptrace capability to current's user_ns, then ptrace
> * access is allowed.
> * Else denied.
> @@ -255,11 +278,14 @@ int cap_ptrace_traceme(struct task_struct *parent)
> rcu_read_lock();
> cred = __task_cred(parent);
> child_cred = current_cred();
> + if (cap_ptrace_borrows_setfcap(cred, child_cred))
> + goto deny;
> if (cred->user_ns == child_cred->user_ns &&
> cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
> goto out;
> if (has_ns_capability(parent, child_cred->user_ns, CAP_SYS_PTRACE))
> goto out;
> +deny:
> ret = -EPERM;
> out:
> rcu_read_unlock();
>
> --
> 2.55.0