CVE-2024-56556: binder: fix node UAF in binder_add_freeze_work()
In the Linux kernel, the following vulnerability has been resolved:
binder: fix node UAF in binder_add_freeze_work()
In binder_add_freeze_work() we iterate over the proc->nodes with the
proc->inner_lock held. However, this lock is temporarily dropped in
order to acquire the node->lock first (lock nesting order). This can
race with binder_node_release() and trigger a use-after-free:
==================================================================
BUG: KASAN: slab-use-after-free in _raw_spin_lock+0xe4/0x19c
Write of size 4 at addr ffff53c04c29dd04 by task freeze/640
CPU: 5 UID: 0 PID: 640 Comm: freeze Not tainted 6.11.0-07343-ga727812a8d45 #17
Hardware name: linux,dummy-virt (DT)
Call trace:
_raw_spin_lock+0xe4/0x19c
binder_add_freeze_work+0x148/0x478
binder_ioctl+0x1e70/0x25ac
__arm64_sys_ioctl+0x124/0x190
Allocated by task 637:
__kmalloc_cache_noprof+0x12c/0x27c
binder_new_node+0x50/0x700
binder_transaction+0x35ac/0x6f74
binder_thread_write+0xfb8/0x42a0
binder_ioctl+0x18f0/0x25ac
__arm64_sys_ioctl+0x124/0x190
Freed by task 637:
kfree+0xf0/0x330
binder_thread_read+0x1e88/0x3a68
binder_ioctl+0x16d8/0x25ac
__arm64_sys_ioctl+0x124/0x190
==================================================================
Fix the race by taking a temporary reference on the node before
releasing the proc->inner lock. This ensures the node remains alive
while in use.
Security readout for executives and security teams
Plain-English summary
A race condition in the Linux kernel Binder subsystem can access memory after it has been freed. A low-privileged local user could potentially crash the system or compromise kernel confidentiality and integrity. The issue is rated high severity, but the supplied sources do not establish active exploitation.
Executive priority
Treat this as a high-priority kernel update for systems exposing Binder to untrusted local users. It is less urgent for systems without Binder or without realistic local access, subject to vendor confirmation. There is no supplied evidence of active exploitation, so prioritize based on exposure rather than assuming an ongoing campaign.
Technical view
binder_add_freeze_work() temporarily releases proc->inner_lock while changing lock order. binder_node_release() can then free the current node before its lock is acquired, causing a CWE-416 use-after-free. The fix retains a temporary node reference across the unlocked interval. CVSS 3.1 is 7.8 with local, low-privilege access and no user interaction.
Likely exposure
Exposure requires an affected Linux kernel with the Binder functionality available to a low-privileged local user. Network-only attackers are not directly covered by the supplied CVSS vector. The supplied version data points to Linux 6.12-era builds, but its exact range boundaries are insufficiently clear; confirm applicability with the kernel or distribution vendor.
Exploitation context
The supplied record is not listed in CISA KEV and provides no evidence of exploitation in the wild. Successful abuse requires local low-privileged access and interaction with the vulnerable Binder path. The demonstrated failure was a KASAN-detected slab use-after-free; reliable security impact beyond that is not documented in the bundle.
Researcher notes
The central condition is a lifetime race caused by releasing proc->inner_lock before acquiring node->lock. The remediation adds a temporary reference so the node remains alive. The source bundle contains ambiguous affected-version formatting, so commit ancestry or vendor advisories should determine exposure. A crash signature alone would not establish malicious exploitation.
Mitigation direction
Install a vendor kernel update that incorporates the cited Binder fixes.
Confirm the applicable fixed release or backport with your Linux distribution vendor.
Prioritize systems where untrusted local users can access Binder functionality.
Restrict unnecessary local access as a temporary compensating control.
Validation and detection
Inventory kernel versions and vendor patch levels on systems using Binder.
Confirm whether vendor kernels contain either cited fixing commit or an equivalent backport.
Determine whether Binder is enabled and accessible to low-privileged local users.
Review kernel logs for crashes or memory errors involving Binder paths.
Run vendor-supported regression testing after updating the kernel.
Generated from the cited source records. This long-tail analysis has not been individually reviewed by a named human.
Potential ATT&CK relevance
Conservative CVE-to-ATT&CK context
These mappings and lookup hints may be relevant to the vulnerability behavior, CWE, affected product, or exposure path. Glexia-inferred context is not an official MITRE, ATT&CK, CWE, or CVE Program mapping.
ATT&CK lookup starting points
Use these exact CWE pages and searches to review the Glexia ATT&CK library from this CVE's weakness and description context.
cwe · low confidence lookup
CWE-416: Exact CWE lookup
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
These fields come from the CVE record and ADP containers, not from Glexia's Take. They preserve time-varying source decisions such as CISA SSVC, KEV status, CVSS metrics, and provider references.
2CVSS vectors
3Timeline events
1ADP providers
3Source links
SSVC decision data
CISA-ADPCISA Coordinator
Timestamp
Version
2.0.3
Exploitation: noneAutomatable: noTechnical Impact: total
CVSS vector scores
2 official scores
We collect every scored CVSS vector available in the official CNA and ADP containers. When more than one version is present, the table keeps the source vectors side by side instead of collapsing them into the highest score.
CWE links open Glexia weakness intelligence pages with official CWE context, developer remediation guidance, and related CVE mappings.
CWE-416 · source CWE mapping
Use After Free
Use After Free represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.