FAILED: patch "[PATCH] binder: fix UAF in binder_free_transaction()" failed to apply to 5.10-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 5.10-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.10.y
git checkout FETCH_HEAD
git cherry-pick -x f223d27a546c1e1f48d38fd67760e78f068fe8c4
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026071359-voyage-hassle-bb34@gregkh' --subject-prefix 'PATCH 5.10.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From f223d27a546c1e1f48d38fd67760e78f068fe8c4 Mon Sep 17 00:00:00 2001
From: Carlos Llamas <[email protected]>
Date: Fri, 19 Jun 2026 18:52:31 +0000
Subject: [PATCH] binder: fix UAF in binder_free_transaction()
In binder_free_transaction(), the t->to_proc is read under the t->lock. However, once the t->lock is dropped, the to_proc can die in parallel. This leads to a use-after-free error when we attempt to acquire its inner lock right afterwards:
==================================================================
BUG: KASAN: slab-use-after-free in _raw_spin_lock+0xe4/0x1a0 Write of size 4 at addr ffff00001125da70 by task B/672 CPU: 20 UID: 0 PID: 672 Comm: B Not tainted 7.1.0-rc6-00284-g8e65320d91cd #4 PREEMPT Hardware name: linux,dummy-virt (DT) Call trace: _raw_spin_lock+0xe4/0x1a0 binder_free_transaction+0x8c/0x320 binder_send_failed_reply+0x21c/0x2f8 binder_thread_release+0x488/0x7e0 binder_ioctl+0x12c0/0x29a0 [...] Allocated by task 675: __kmalloc_cache_noprof+0x174/0x444 binder_open+0x118/0xb70 do_dentry_open+0x374/0x1040 vfs_open+0x58/0x3bc [...] Freed by task 212: __kasan_slab_free+0x58/0x80 kfree+0x1a0/0x4a4 binder_proc_dec_tmpref+0x32c/0x5e0 binder_deferred_func+0xc48/0x104c process_one_work+0x53c/0xbc0 [...] ==================================================================
To prevent this, pin the target thread (t->to_thread) to guarantee the target process remains alive. Undelivered transactions without a target thread are already safe, as the target process can only be the current context in those paths.
drivers/android/binder.c +13 -0
@@ -1658,10 +1658,19 @@ static void binder_txn_latency_free(struct binder_transaction *t)static void binder_free_transaction (struct binder_transaction *t) { +struct binder_thread *target_thread;struct binder_proc *target_proc;spin_lock (&t->lock); target_proc = t->to_proc; + target_thread = t->to_thread; +/* +* Pin target_thread to keep target_proc alive. Undelivered +* transactions with !target_thread are safe, as target_proc +* can only be the current context there. +*/ +if (target_thread) +atomic_inc (&target_thread->tmp_ref);spin_unlock (&t->lock);if (target_proc) {
@@ -1676,6 +1685,10 @@ static void binder_free_transaction(struct binder_transaction *t) t->buffer->transaction =NULL ;binder_inner_proc_unlock (target_proc); } + +if (target_thread) +binder_thread_dec_tmpref (target_thread); +if (trace_binder_txn_latency_free_enabled ())binder_txn_latency_free (t);/*
Sasha Levin
maintainerPATCH 1/2 binder: fix UAF in binder_thread_release()
From: Carlos Llamas <[email protected]>
[ Upstream commit 114a116aaa5f0295376cdf12da743c5bce3b20ce ]
When a thread exits, binder_thread_release() walks its transaction stack to clear the t->from and t->to_proc that correspond with the exiting thread. However, a process dying in parallel might attempt to kfree some of these transactions. And if one of them has no associated t->to_proc, the t->to_proc->inner_lock will not be acquired.
This means that transaction accesses in binder_thread_release() after t->to_proc has been cleared might race with binder_free_transaction() and cause a use-after-free error as reported by KASAN:
==================================================================
BUG: KASAN: slab-use-after-free in binder_thread_release+0x5d0/0x798 Write of size 8 at addr ffff000016627500 by task X/715 CPU: 17 UID: 0 PID: 715 Comm: X Not tainted 7.1.0-rc5-00149-g8fde5d1d47f6 #30 PREEMPT Hardware name: linux,dummy-virt (DT) Call trace: binder_thread_release+0x5d0/0x798 binder_ioctl+0x12c0/0x299c [...] Allocated by task 717 on cpu 18 at 67.267803s: __kasan_kmalloc+0xa0/0xbc __kmalloc_cache_noprof+0x174/0x444 binder_transaction+0x554/0x8150 binder_thread_write+0xa30/0x4354 binder_ioctl+0x20f0/0x299c [...] Freed by task 202 on cpu 18 at 90.416221s: __kasan_slab_free+0x58/0x80 kfree+0x1a0/0x4a4 binder_free_transaction+0x150/0x294 binder_send_failed_reply+0x398/0x6d8 binder_release_work+0x3e4/0x4ec binder_deferred_func+0xbd8/0x104c [...] ==================================================================
In order to avoid this, make sure that binder_free_transaction() reads the t->to_proc under the transaction lock. This will serialize the transaction release with the accesses in binder_thread_release(). Plus, it matches the documented locking rules for @to_proc.
Stable-dep-of: f223d27a546c ("binder: fix UAF in binder_free_transaction()")
--- drivers/android/binder.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/android/binder.c +5 -1
@@ -1909,7 +1909,11 @@ static void binder_free_txn_fixups(struct binder_transaction *t)static void binder_free_transaction (struct binder_transaction *t) { -struct binder_proc *target_proc = t->to_proc; +struct binder_proc *target_proc; + +spin_lock (&t->lock); + target_proc = t->to_proc; +spin_unlock (&t->lock);if (target_proc) {binder_inner_proc_lock (target_proc);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 binder: fix UAF in binder_free_transaction()
From: Carlos Llamas <[email protected]>
[ Upstream commit f223d27a546c1e1f48d38fd67760e78f068fe8c4 ]
In binder_free_transaction(), the t->to_proc is read under the t->lock. However, once the t->lock is dropped, the to_proc can die in parallel. This leads to a use-after-free error when we attempt to acquire its inner lock right afterwards:
==================================================================
BUG: KASAN: slab-use-after-free in _raw_spin_lock+0xe4/0x1a0 Write of size 4 at addr ffff00001125da70 by task B/672 CPU: 20 UID: 0 PID: 672 Comm: B Not tainted 7.1.0-rc6-00284-g8e65320d91cd #4 PREEMPT Hardware name: linux,dummy-virt (DT) Call trace: _raw_spin_lock+0xe4/0x1a0 binder_free_transaction+0x8c/0x320 binder_send_failed_reply+0x21c/0x2f8 binder_thread_release+0x488/0x7e0 binder_ioctl+0x12c0/0x29a0 [...] Allocated by task 675: __kmalloc_cache_noprof+0x174/0x444 binder_open+0x118/0xb70 do_dentry_open+0x374/0x1040 vfs_open+0x58/0x3bc [...] Freed by task 212: __kasan_slab_free+0x58/0x80 kfree+0x1a0/0x4a4 binder_proc_dec_tmpref+0x32c/0x5e0 binder_deferred_func+0xc48/0x104c process_one_work+0x53c/0xbc0 [...] ==================================================================
To prevent this, pin the target thread (t->to_thread) to guarantee the target process remains alive. Undelivered transactions without a target thread are already safe, as the target process can only be the current context in those paths.
--- drivers/android/binder.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
drivers/android/binder.c +13 -0
@@ -1909,10 +1909,19 @@ static void binder_free_txn_fixups(struct binder_transaction *t)static void binder_free_transaction (struct binder_transaction *t) { +struct binder_thread *target_thread;struct binder_proc *target_proc;spin_lock (&t->lock); target_proc = t->to_proc; + target_thread = t->to_thread; +/* +* Pin target_thread to keep target_proc alive. Undelivered +* transactions with !target_thread are safe, as target_proc +* can only be the current context there. +*/ +if (target_thread) +atomic_inc (&target_thread->tmp_ref);spin_unlock (&t->lock);if (target_proc) {
@@ -1921,6 +1930,10 @@ static void binder_free_transaction(struct binder_transaction *t) t->buffer->transaction =NULL ;binder_inner_proc_unlock (target_proc); } + +if (target_thread) +binder_thread_dec_tmpref (target_thread); +/* * If the transaction has no target_proc, then * t->buffer->transaction has already been cleared.
Signature · 1 line
2.53.0