CVE-2026-53157: Linux Kernel Phonet Use-After-Free Privilege Escalation Risk
A memory safety flaw exists in the Linux kernel's Phonet networking subsystem. When a Phonet device is destroyed, the kernel removes it from a shared list but immediately frees the memory. Other parts of the kernel can still be accessing that same memory after it's freed, causing a crash or potential code execution. The fix ensures the kernel waits for all readers to finish before reclaiming the memory.
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
- 8 configuration(s)
- Published / Modified
- 2026-06-25 / 2026-07-07
NVD description (verbatim)
In the Linux kernel, the following vulnerability has been resolved: net: phonet: free phonet_device after RCU grace period phonet_device_destroy() removes a phonet_device from the per-net device list with list_del_rcu(), but frees it immediately. RCU readers walking the same list can still hold a pointer to the object after it has been removed, leading to a slab-use-after-free. Use kfree_rcu(), matching the lifetime rule already used by phonet_address_del() for the same object type.
8 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
CVE-2026-53157 is a use-after-free vulnerability (CWE-416) in the Linux kernel's net/phonet module. The phonet_device_destroy() function calls list_del_rcu() to remove a phonet_device from a per-network-namespace device list, but immediately frees the object via kfree(). RCU (Read-Copy-Update) readers can still hold references to the freed memory after removal, leading to slab-use-after-free conditions. The remediation applies kfree_rcu() instead, deferring deallocation until a grace period elapses, matching the lifetime discipline already used by phonet_address_del() for the same data structure.
Business impact
A local unprivileged user can trigger this flaw to crash the kernel, causing denial of service. Depending on kernel configuration and attack timing, exploitation may also permit memory corruption or privilege escalation. The vulnerability requires local system access and does not require root, making it relevant for multi-tenant systems, containers, and shared hosting environments.
Affected systems
The Linux kernel is affected across multiple stable branches. Verify the specific kernel versions in your environment against the Linux kernel security advisory. Systems running Phonet networking support (net/phonet module) are in scope; check whether Phonet is enabled in your kernel configuration.
Exploitability
Exploitability is moderate. The vulnerability requires local code execution and does not require special privileges—any unprivileged user can trigger the race condition. No public exploit code is currently known (KEV status: not listed), but the flaw is straightforward to understand and the race window is discoverable. Active exploitation in the wild is not confirmed.
Remediation
Apply a Linux kernel update that incorporates the fix to phonet_device_destroy(). The patch replaces kfree() with kfree_rcu() to defer memory deallocation. Contact your Linux distribution vendor for the timing of availability in stable kernel releases for your supported versions.
Patch guidance
Identify the kernel version running on your systems using 'uname -r'. Check your Linux distribution's security advisories and update channels for availability of patched kernel builds. For enterprise distributions (Red Hat, SUSE, Ubuntu, Debian), updates are typically released through standard package management. Test patched kernels in a staging environment before production deployment. Kernel updates typically require a reboot.
Detection guidance
Monitor system logs for kernel crashes or warnings related to the Phonet subsystem (phonet_device_destroy, RCU stalls, use-after-free/slab errors). Enable kernel address sanitizer (KASAN) in development or test environments to catch such issues before they cause hard failures. Check if Phonet is actively in use in your environment; if not, disabling the module reduces attack surface.
Why prioritize this
This vulnerability merits high priority for systems with local users and Phonet enabled. The CVSS score of 7.8 (HIGH) reflects the confluence of local code execution, lack of privilege requirement, and availability/integrity/confidentiality impact. Systems without Phonet networking support or without untrusted local users can deprioritize. Multi-tenant platforms and shared hosting should address this promptly.
Risk score, explained
The CVSS v3.1 score of 7.8 (HIGH) is driven by: AV:L (attack vector local—requires system access), AC:L (attack complexity low—no special conditions), PR:L (privileges low—unprivileged user can trigger), UI:N (no user interaction required), and S:U/C:H/I:H/A:H (single scope, high confidentiality, integrity, and availability impact). The use-after-free can lead to memory corruption, kernel panic, and potential privilege escalation.
Frequently asked questions
Do I need to disable Phonet networking to be safe?
Disabling the module is a valid defense-in-depth measure if your workloads do not require Phonet. However, the proper fix is to apply the kernel patch. Most systems do not use Phonet (it is a niche networking protocol), so check your configuration first.
Is this vulnerability actively exploited in the wild?
No active exploitation has been confirmed (CVE is not on the CISA KEV catalog). The flaw is localized to unprivileged kernel-space use-after-free and does not affect remote attack surface. Nevertheless, local privilege escalation research often targets such issues, so timely patching is prudent.
Can an unprivileged user really trigger this crash?
Yes. The vulnerability does not require root privileges. Any local user or container can potentially trigger the race condition between list removal and deallocation, making it relevant for shared systems.
What is RCU and why does the fix use kfree_rcu()?
RCU (Read-Copy-Update) is a Linux synchronization mechanism that allows readers to traverse data structures without locks. kfree_rcu() defers freeing memory until all in-flight RCU readers have exited their critical sections, preventing use-after-free in concurrent scenarios.
This analysis is for informational purposes and reflects the ground-truth CVE record as of the publication date. Verify all patch versions, affected kernel branches, and availability timelines against the official Linux kernel security advisory and your distribution vendor. No exploit code is provided. Organizations should assess their specific configurations and risk tolerance when prioritizing remediation efforts. This summary does not constitute professional security advice; consult with your security team for deployment decisions. 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