Re: [RFC PATCH] security: Allow dropping bounding set process-wide

From
sashiko-bot@kernel.org
Date
2026-09-22 10:06:15
Reply to
Jinjie Ruan, 2026-09-22
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Critical] security: PR_CAPBSET_DROP_MASK fails open on memory allocation failure
- [High] security: unbounded GFP_ATOMIC allocations in cap_bset_drop_process
--

commit 4012a62a02d93ede388203c8691ecc0410b4a911
Author: Jinjie Ruan [off-list ref]

security: Allow dropping bounding set process-wide

This commit adds a new prctl, PR_CAPBSET_DROP_MASK, to drop capabilities from
the bounding set of all threads in a thread group simultaneously. It achieves
this synchronously for the calling thread and queues a task_work item for each
sibling thread.
quoted hunk ↗ jump to hunk
diff --git a/security/commoncap.c b/security/commoncap.c
index 3399535808fec..ae7ce50a81518 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
[ ... ]
quoted hunk ↗ jump to hunk
@@ -1283,6 +1290,123 @@ static int cap_prctl_drop(unsigned long cap)
 	return commit_creds(new);
 }
 
+/*
+ * Structure used to queue process-wide bounding set drops via task_work.
+ */
+struct cap_bset_drop_work {
+	struct callback_head work;
+	struct task_struct *task;
+	kernel_cap_t mask;
+	struct cap_bset_drop_work *next;
+};
+
+static void cap_bset_drop_work_fn(struct callback_head *work)
+{
+	struct cap_bset_drop_work *w = container_of(work, struct cap_bset_drop_work, work);
+	struct cred *new = prepare_creds();
+
+	if (!new) {
+		/* Out of memory: bounding set drop failed silently for this thread. */
+		pr_warn_ratelimited("capability bounding set drop failed for pid %d (%s)\n",
+				    task_pid_nr(current), current->comm);
+		goto out;
+	}
[Severity: Critical]
Does this handle memory allocation failures safely?

If prepare_creds() fails, the capability drop is skipped and the target thread
retains its capabilities. However, the original prctl() caller has already
received a success code and may assume the entire process is successfully
sandboxed.

Should this fail closed (for example, by forcing a SIGKILL) to prevent
bypassing the intended security boundary?
quoted hunk ↗ jump to hunk
+
+	new->cap_bset = cap_drop(new->cap_bset, w->mask);
+	commit_creds(new);
+
+out:
+	put_task_struct(w->task);
+	kfree(w);
+}
+
+/*
+ * cap_bset_drop_process - Drop capabilities from all threads in the group.
+ * @mask: Mask of capabilities to drop from the bounding set.
+ *
+ * Drops @mask from the calling thread synchronously, and queues a task_work
+ * item for each sibling thread to safely apply the drop in its own context.
+ *
+ * The caller must hold CAP_SETPCAP. Thread group must be quiescent to avoid
+ * racing with concurrent thread creation.
+ *
+ * Returns 0 on success, or -ENOMEM if allocations fail (all-or-nothing).
+ */
+static int cap_bset_drop_process(kernel_cap_t mask)
+{
+	struct cap_bset_drop_work *list = NULL, *w, *next;
+	struct task_struct *thread;
+	struct cred *new = NULL;
+	int ret = 0;
+
+	rcu_read_lock();
+	for_each_thread(current, thread) {
+		const struct cred *cred;
+
+		if (thread == current || (thread->flags & PF_EXITING))
+			continue;
+
+		cred = __task_cred(thread);
+		if (cap_isclear(cap_intersect(cred->cap_bset, mask)))
+			continue;
+
+		w = kmalloc_obj(*w, GFP_ATOMIC);
+		if (!w) {
+			ret = -ENOMEM;
+			break;
+		}
[Severity: High]
Can this loop exhaust the atomic memory pool?

An unprivileged user could create tens of thousands of threads and then call
prctl(PR_CAPBSET_DROP_MASK). This would execute an unbounded number of
GFP_ATOMIC allocations sequentially inside an RCU read-side critical section,
which could deplete emergency memory reserves and cause system instability.
quoted hunk ↗ jump to hunk
+
+		w->task = get_task_struct(thread);
+		w->mask = mask;
+		w->next = list;
+		list = w;
+	}
+	rcu_read_unlock();
-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260922095816.1191799-1-ruanjinjie@huawei.com?part=1
Thread (15 messages) 15 messages, 4 authors, last reply 2026-09-28
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help