CVE-2026-53264: Linux Kernel Use-After-Free in Traffic Control Actions
A use-after-free vulnerability exists in the Linux kernel's traffic control action subsystem. When network filter operations are added and removed at the same time on different CPU cores, a race condition can allow one operation to access memory that has already been freed by another. This occurs because the code freed action objects immediately rather than deferring cleanup until it was safe to do so. The fix restores deferred freeing using RCU (Read-Copy-Update) synchronization, ensuring memory is only reclaimed after all concurrent readers have completed.
Source data · NVD / CISA · public domain
- CVSS
- 3.1 · 7.8 HIGH · CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
- Weaknesses (CWE)
- CWE-416
- Affected products
- 7 configuration(s)
- Published / Modified
- 2026-06-25 / 2026-07-29
NVD description (verbatim)
In the Linux kernel, the following vulnerability has been resolved: net/sched: act_api: use RCU with deferred freeing for action lifecycle When NEWTFILTER and DELFILTER are run concurrently it is possible to create a race with an associated action. Let's illustrate with CPU0 running NEWTFILTER and CPU1 running DELFILTER: 0: mutex_lock() <-- holds the idr lock 0: rcu_read_lock() 0: p = idr_find(idr, index) <-- action p is valid (RCU protects IDR) 0: mutex_unlock() <-- releases the idr lock 1: refcount_dec_and_mutex_lock() <-- refcnt 1->0, mutex held 1: idr_remove(idr, index) <-- Action removed from IDR 1: mutex_unlock() <-- mutex released allowing us to delete the action 1: tcf_action_cleanup(p); kfree(p) <-- Kfrees p immediately, no deferral 0: refcount_inc_not_zero(&p->tcfa_refcnt) <-- ouch, UAF p points to freed memory This patch fixes the race condition between NEWTFILTER and DELFILTER by adding struct rcu_head to tc_action used in the deferral and introducing a call_rcu() in the delete path to defer the final kfree(). Note: this is a revert of commit d7fb60b9cafb ("net_sched: get rid of tcfa_rcu") but also modernization/simplification to directly use kfree_rcu(). Let's illustrate the new restored code path: 0: rcu_read_lock() 1: refcount_dec_and_mutex_lock() <-- refcnt 1->0, mutex held 1: idr_remove(idr, index) 1: mutex_unlock() 1: call_rcu(&p->tcfa_rcu, tcf_action_rcu_free) <-- defer kfree after grace period 0: p = idr_find(idr, index) 0: refcount_inc_not_zero(&p->tcfa_refcnt) <-- fails, refcnt already 0 1: rcu_read_unlock() <-- release so freeing can run after grace period After CPU1 calls idr_remove(), the object is no longer reachable through the IDR. CPU0's subsequent idr_find() will return NULL, and even if it still held a stale pointer, the immediate kfree() is now deferred until after the RCU grace period, so no UAF can occur.
9 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
CVE-2026-53264 is a use-after-free (CWE-416) in net/sched/act_api.c triggered by concurrent NEWTFILTER and DELFILTER netlink operations. The vulnerability arises from a missing synchronization mechanism between action object lifecycle and RCU read-side critical sections. Specifically: (1) CPU0 holds an RCU read lock and retrieves an action via idr_find(), (2) CPU1 decrements the action's refcount to zero, removes it from the IDR tree, and immediately calls kfree(), (3) CPU0 attempts refcount_inc_not_zero() on the freed object, causing UAF. The patch reintroduces deferred freeing via call_rcu() and kfree_rcu(), ensuring the object remains valid until the RCU grace period expires, after which idr_find() on other CPUs will safely return NULL. This is a functional revert of commit d7fb60b9cafb combined with modern RCU primitives.
Business impact
Successful exploitation requires local access and the ability to execute network configuration commands with standard user privileges. An attacker could trigger kernel memory corruption, potentially leading to denial of service, information disclosure of kernel memory, or privilege escalation. The impact is primarily relevant to multi-user systems and containerized environments where unprivileged users can modify network filters. Systems with network namespace isolation or strict AppArmor/SELinux policies limiting unprivileged tc(8) access face reduced risk.
Affected systems
The Linux kernel is affected, specifically versions with active traffic control action management. The vulnerability requires that the kernel be built with network traffic control (netfilter/tc) support enabled. Embedded systems, cloud VMs, and traditional servers running Linux distributions are in scope. The provided CVE references show the impact spans multiple kernel releases. Verify your specific kernel version against the vendor advisory to confirm inclusion of the vulnerable code path and availability of patched releases.
Exploitability
Exploitation is classified HIGH due to low attack complexity and low privilege requirement (standard user can call tc commands). An attacker must: (1) have local login access, (2) be able to execute netlink traffic control operations (not restricted by capabilities or policies), and (3) successfully trigger the race condition, which may require multiple attempts or specific timing. No public exploit code is known at this time, and the vulnerability is not tracked as actively exploited. Practical exploitation is feasible but non-trivial; the race window is small and timing-dependent.
Remediation
Apply the kernel patch that restores RCU-based deferred freeing in the action cleanup path. This involves adding an rcu_head structure to the tc_action object and replacing immediate kfree() calls with call_rcu() or kfree_rcu() in the action deletion handler. Verify the patched kernel version against your vendor's security advisory to confirm the fix is included. Until patching is complete, restrict unprivileged access to tc(8) and netlink TC operations via Linux capabilities, AppArmor, or SELinux policies if your deployment allows it.
Patch guidance
Contact your Linux distribution's security team or kernel maintainers for backported patches targeting your specific kernel version series. Upstream patches are typically merged into -rc and stable kernels shortly after disclosure. For distributions with extended support (RHEL, Ubuntu LTS, Debian), expect security advisory releases with patched kernel packages. Test patches in non-production environments first, as kernel updates require reboot. If your distribution has not yet released a patch, consider disabling unprivileged network filter operations as a temporary mitigation.
Detection guidance
Monitor system logs for unusual traffic control configuration changes (tc commands) issued by unprivileged users. Look for patterns of rapid NEWTFILTER and DELFILTER operations on the same interface. Kernel oops or UAF-related messages ("BUG: unable to handle page fault for address" with act_api.c in the call stack) may indicate exploitation attempts. Runtime kernel address sanitizer (KASAN) builds will reliably catch UAF at runtime. Security tools like audit(8) can log netlink TC_QDISC_NEW and TC_QDISC_DEL events; correlate these with user context to identify suspicious activity.
Why prioritize this
This vulnerability merits prompt patching due to the combination of: (1) HIGH CVSS (7.8) reflecting local privilege escalation potential, (2) straightforward attack surface (standard unprivileged user can trigger the race), and (3) kernel-level impact (memory corruption leading to DoS or privilege escalation). It is not currently exploited in the wild (KEV status: false), providing a window for proactive patching before threat actors develop reliable weaponized exploits. Prioritize systems where unprivileged users have direct access and network configuration privileges.
Risk score, explained
CVSS 7.8 (HIGH) derives from: AV:L (local attack vector—requires login access), AC:L (low complexity—race condition is deterministic with effort), PR:L (low privilege—standard unprivileged user can execute tc commands), UI:N (no user interaction required), S:U (impact limited to the host), and C:H/I:H/A:H (high confidentiality, integrity, and availability impact via kernel memory corruption). The score appropriately reflects the serious but localized threat; the vulnerability does not remotely compromise systems or affect confidentiality of data in transit.
Frequently asked questions
What does use-after-free mean in this context?
Use-after-free (UAF) occurs when code reads or writes memory that has already been freed back to the kernel. In this case, CPU0 holds a pointer to an action object while CPU1 frees that same object. When CPU0 tries to increment the refcount on the freed memory, it accesses invalid kernel memory, potentially causing a crash or allowing an attacker to influence the freed memory's content.
Do I need local login to exploit this?
Yes. The vulnerability requires the ability to execute netlink traffic control commands (tc commands) on the affected system. This typically requires local login or container access. However, in multi-user or shared hosting environments, any unprivileged user who can run tc commands is a potential attacker.
Is this vulnerability actively being exploited?
Not at this time. The CVE is not listed in the CISA Known Exploited Vulnerabilities catalog, indicating no confirmed public or in-the-wild exploitation. However, given the straightforward nature of the vulnerability, prompt patching is still advisable before weaponized exploits are developed.
Can disabling network traffic control stop this vulnerability?
If your system does not rely on network traffic control (tc qdisc, traffic shaping, or filter rules), building or running a kernel compiled without net/sched support would eliminate the attack surface entirely. However, this is not practical for most production systems. A more practical mitigation is to restrict unprivileged access to tc commands using Linux capabilities (CAP_SYS_ADMIN) or SELinux/AppArmor policies.
This analysis is based on CVE-2026-53264 as disclosed by the Linux kernel security team. CVSS score, CWE classification, and KEV status are derived from official sources. Readers should verify patch availability and version applicability with their Linux distribution vendor before deploying fixes. This is a local vulnerability requiring pre-existing system access; it does not affect systems without network traffic control enabled or those with strict unprivileged user restrictions. No exploit code or detailed proof-of-concept is provided. Consult your vendor's security advisory for version-specific guidance. Source: NVD (public-domain), retrieved 2026-08-03. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-10001HIGHChrome Sandbox Escape via PerformanceManager Use-After-Free
- CVE-2026-10002HIGHGoogle Chrome PDFium Use-After-Free Vulnerability (CVSS 8.8)
- CVE-2026-10003HIGHChrome Use-After-Free Code Execution Vulnerability Analysis
- CVE-2026-10007HIGHChrome Use-After-Free in SVG Arbitrary Code Execution (CVSS 8.8)
- CVE-2026-10012HIGHChrome Skia Use-After-Free Sandbox Escape (v148.0.7778.216)
- CVE-2026-10013HIGHUse-After-Free in Chrome WebCodecs – Patch Guide & Risk Assessment
- CVE-2026-10016HIGHUse-After-Free in Chrome DOM – Sandbox Code Execution Vulnerability
- CVE-2026-10882HIGHCritical Chrome Use-After-Free RCE Vulnerability – Exploit Details & Patch Guidance