CVE-2026-53005: Linux Kernel AF_UNIX SOCKMAP Use-After-Free (CVSS 7.8)
A memory safety flaw in the Linux kernel's AF_UNIX socket implementation can allow a local attacker with limited privileges to crash the system or potentially gain elevated access. The vulnerability arises from how the kernel handles socket redirects through SOCKMAP when file descriptors (critical system resource handles) are being transferred between sockets. The kernel's garbage collection mechanism fails to properly track these redirected sockets, leading to a use-after-free condition—accessing memory that has already been freed. This is particularly dangerous because it undermines the kernel's ability to safely manage file descriptor lifecycle.
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
- 1 configuration(s)
- Published / Modified
- 2026-06-24 / 2026-07-24
NVD description (verbatim)
In the Linux kernel, the following vulnerability has been resolved: af_unix: Drop all SCM attributes for SOCKMAP. SOCKMAP can hide inflight fd from AF_UNIX GC. When a socket in SOCKMAP receives skb with inflight fd, sk_psock_verdict_data_ready() looks up the mapped socket and enqueue skb to its psock->ingress_skb. Since neither the old nor the new GC can inspect the psock queue, the hidden skb leaks the inflight sockets. Note that this cannot be detected via kmemleak because inflight sockets are linked to a global list. In addition, SOCKMAP redirect breaks the Tarjan-based GC's assumption that unix_edge.successor is always alive, which is no longer true once skb is redirected, resulting in use-after-free below. [0] Moreover, SOCKMAP does not call scm_stat_del() properly, so unix_show_fdinfo() could report an incorrect fd count. sk_msg_recvmsg() does not support any SCM attributes in the first place. Let's drop all SCM attributes before passing skb to the SOCKMAP layer. [0]: BUG: KASAN: slab-use-after-free in unix_del_edges (net/unix/garbage.c:118 net/unix/garbage.c:181 net/unix/garbage.c:251) Read of size 8 at addr ffff888125362670 by task kworker/56:1/496 CPU: 56 UID: 0 PID: 496 Comm: kworker/56:1 Not tainted 7.0.0-rc7-00263-gb9d8b856689d #3 PREEMPT(lazy) Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-debian-1.17.0-1 04/01/2014 Workqueue: events sk_psock_backlog Call Trace: <TASK> dump_stack_lvl (lib/dump_stack.c:122) print_report (mm/kasan/report.c:379) kasan_report (mm/kasan/report.c:597) unix_del_edges (net/unix/garbage.c:118 net/unix/garbage.c:181 net/unix/garbage.c:251) unix_destroy_fpl (net/unix/garbage.c:317) unix_destruct_scm (./include/net/scm.h:80 ./include/net/scm.h:86 net/unix/af_unix.c:1976) sk_psock_backlog (./include/linux/skbuff.h:?) process_scheduled_works (kernel/workqueue.c:?) worker_thread (kernel/workqueue.c:?) kthread (kernel/kthread.c:438) ret_from_fork (arch/x86/kernel/process.c:164) ret_from_fork_asm (arch/x86/entry/entry_64.S:258) </TASK> Allocated by task 955: kasan_save_track (mm/kasan/common.c:58 mm/kasan/common.c:78) __kasan_slab_alloc (mm/kasan/common.c:369) kmem_cache_alloc_noprof (mm/slub.c:4539) sk_prot_alloc (net/core/sock.c:2240) sk_alloc (net/core/sock.c:2301) unix_create1 (net/unix/af_unix.c:1099) unix_create (net/unix/af_unix.c:1169) __sock_create (net/socket.c:1606) __sys_socketpair (net/socket.c:1811) __x64_sys_socketpair (net/socket.c:1863 net/socket.c:1860 net/socket.c:1860) do_syscall_64 (arch/x86/entry/syscall_64.c:?) entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:130) Freed by task 496: kasan_save_track (mm/kasan/common.c:58 mm/kasan/common.c:78) kasan_save_free_info (mm/kasan/generic.c:587) __kasan_slab_free (mm/kasan/common.c:287) kmem_cache_free (mm/slub.c:6165) __sk_destruct (net/core/sock.c:2282 net/core/sock.c:2384) sk_psock_destroy (./include/net/sock.h:?) process_scheduled_works (kernel/workqueue.c:?) worker_thread (kernel/workqueue.c:?) kthread (kernel/kthread.c:438) ret_from_fork (arch/x86/kernel/process.c:164) ret_from_fork_asm (arch/x86/entry/entry_64.S:258)
4 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
CVE-2026-53005 addresses a use-after-free vulnerability in the Linux kernel's unix domain socket garbage collection logic, triggered by improper interaction with SOCKMAP (a eBPF-based socket redirection mechanism). When sk_psock_verdict_data_ready() redirects socket buffers (skbs) containing in-flight file descriptors to a SOCKMAP-mapped socket, the redirected skbs are enqueued to psock->ingress_queue where they bypass both the old and new garbage collector inspection mechanisms. This causes inflight socket references to leak and violates the Tarjan-based garbage collector's invariant that unix_edge.successor pointers remain valid. Additionally, the kernel fails to properly invoke scm_stat_del() for redirected SCM attributes, leading to incorrect file descriptor accounting in fdinfo reporting. The fix drops all SCM (Socket Control Message) attributes before passing skbs to SOCKMAP, preventing the garbage collection inconsistency and the resulting use-after-free in unix_del_edges().
Business impact
Organizations running Linux kernel-based infrastructure face potential denial-of-service exposure. An attacker with local user privileges (such as an unprivileged container process or standard user account) can trigger a kernel panic via the use-after-free condition, disrupting availability. While the vector is local and requires moderate privilege, the impact is severe: a crashed kernel cannot be remotely remedied without intervention, affecting hosted services, containerized workloads, and multi-tenant systems. The vulnerability also erodes the integrity of resource accounting, potentially allowing subtle resource exhaustion or privilege boundary violations in complex deployments using eBPF-based networking.
Affected systems
Linux kernel versions are affected. The vulnerability is present in the AF_UNIX and SOCKMAP subsystems; it affects any system running a vulnerable kernel version where both unix domain sockets and eBPF-based socket redirection (SOCKMAP) are active. This is most prevalent in container orchestration platforms, cloud instances with eBPF-enabled networking (including Cilium, Calico, and similar CNI plugins), and systems using modern BPF-based security or observability tools. Verify affected kernel versions against the official Linux kernel security advisory and your distribution's patch tracking.
Exploitability
Exploitation requires local access with at least unprivileged user privileges (PR:L in the CVSS vector). No special capabilities or elevated rights are necessary for a local user to trigger the flaw—they need only to interact with unix sockets and SOCKMAP-enabled redirects, which are increasingly common in containerized and BPF-instrumented environments. The attack surface is present on any system where eBPF programs can redirect socket traffic, a standard practice in modern cloud-native stacks. The lack of user interaction (UI:N) and the straightforward nature of socket operations mean exploitation can be automated, though public exploit code is not widely documented.
Remediation
Patch the Linux kernel to a version that includes the fix for CVE-2026-53005. The remedy involves applying the kernel commit that drops all SCM attributes before passing skbs to SOCKMAP, restoring proper garbage collection invariants. Verify the patched kernel version against your distribution's security advisory. For environments unable to immediately reboot, isolation strategies such as restricting unprivileged user access to socket operations or disabling eBPF-based networking features may reduce exposure, though a kernel update is the definitive remediation.
Patch guidance
Consult your Linux distribution's security advisory for the specific patched kernel version (verify against the vendor advisory for exact version numbers). Once a patched kernel is available for your distribution, apply it and reboot at your earliest maintenance window. Prioritize systems in multi-tenant environments, container hosts, and those running eBPF-based security or observability tools, as they have higher exposure. Test patches in a staging environment before production deployment, particularly if you rely on SOCKMAP-based networking (e.g., Cilium with eBPF datapath, BPF-based load balancing).
Detection guidance
Monitor system logs (dmesg, audit logs) for kernel panics, KASAN (Kernel Address Sanitizer) warnings, or use-after-free signatures, particularly any mentioning unix_del_edges, unix_destruct_scm, or sk_psock_backlog. If KASAN is enabled on your systems, it will report the slab-use-after-free condition. Detection of exploitation attempts is difficult without kernel instrumentation; focus on patch application and validated testing rather than behavioral detection. For forensic purposes, kernel logs showing scheduler events and socket-related workqueue crashes may indicate an attempted or successful exploit.
Why prioritize this
This vulnerability merits immediate attention due to its HIGH CVSS score (7.8), local exploitability by unprivileged users, and direct availability impact. While it requires local access, the prevalence of multi-tenant container environments and the ubiquity of eBPF-based networking in modern cloud stacks dramatically broaden the threat surface. The use-after-free nature is particularly hazardous and often precedes privilege escalation in kernel exploitation chains. Organizations with container platforms, Kubernetes clusters, or BPF-instrumented networking should prioritize patching within days, not weeks.
Risk score, explained
The CVSS 3.1 score of 7.8 (HIGH) reflects: Local Attack Vector (AV:L) – only reachable by users on the system; Low Attack Complexity (AC:L) – no special conditions or race conditions needed; Low Privilege (PR:L) – standard unprivileged user can trigger it; No User Interaction (UI:N) – fully automated; Unchanged Scope (S:U) – impacts only the kernel's own privilege boundary; and High impact across Confidentiality, Integrity, and Availability (C:H/I:H/A:H) – the use-after-free can leak kernel memory, corrupt state, and crash the system. The score does not yet reflect CISA KEV listing; however, the vulnerability is technically straightforward to exploit in environments where SOCKMAP is active.
Frequently asked questions
What is SOCKMAP and why does it matter?
SOCKMAP is a Linux kernel BPF feature that enables socket redirection and transformation at the kernel level, used by modern container networking (Cilium, Calico) and observability tools to efficiently redirect traffic without context switching to user space. This vulnerability affects systems that actively use SOCKMAP for networking or security policies, making it relevant to cloud-native and Kubernetes deployments.
Do I need unprivileged user access to exploit this?
Yes. The vulnerability requires at least unprivileged local user privileges (PR:L in CVSS). An attacker cannot exploit it remotely; however, in container environments, each pod often runs as a local user context, making exploitation feasible in multi-tenant scenarios.
What's a use-after-free and why is it critical?
A use-after-free occurs when code accesses memory after it has been freed back to the allocator. In kernel context, this can leak sensitive data (confidentiality), corrupt memory structures (integrity), or crash the system (availability). The KASAN trace in this advisory shows a direct kernel panic, but use-after-free bugs are historically a common vector for privilege escalation.
Will this affect my system if I don't use eBPF or SOCKMAP?
Only if your kernel has SOCKMAP compiled in and the feature is enabled in your configuration. Traditional socket applications without eBPF-based redirection are not affected. However, many modern distributions enable eBPF by default, and container platforms often rely on it, so most affected systems will have the vulnerability present even if they do not actively use SOCKMAP themselves.
This analysis is based on publicly disclosed vulnerability data and the kernel patch description. Specific vulnerable kernel versions and patched releases vary by distribution; refer to your Linux vendor's official security advisory for definitive version information. CVSS scores and KEV status are current as of the advisory publication date and may change. No exploit code is provided or endorsed. Testing and deployment of patches should follow your organization's change management procedures. This vulnerability requires local access and cannot be exploited remotely. Source: NVD (public-domain), retrieved 2026-07-31. 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