A 15-byte accounting error in the kernel's IPv6 plumbing hands any pod tenant the keys to the entire host
CVE-2026-53362 is an out-of-bounds write in the Linux kernel's __ip6_append_data() function, where the paged-allocation path fails to account for fraggap bytes when sizing the linear portion of a new socket buffer. The result: 15 bytes overflow into skb_shared_info, flipping the nr_frags field and activating a stale page descriptor. From there, the chain progresses through dangling-page creation, PTE-page reallocation for arbitrary physical memory read/write, and finally a core_pattern overwrite that yields a root shell. The bug was introduced by commit 773ba4fe9104 (July 2022, kernel 6.0) and became reliably exploitable after commit ce650a166335 (August 2023). Affected stable branches include 6.1.x (before 6.1.177), 6.6.x (before 6.6.144), 6.12.x (before 6.12.95), 6.18.x (before 6.18.38), and 7.1.x (before 7.1.3). Any unprivileged user who can open a UDPv6 socket and create a network namespace — the default on RHEL 10 and most modern distros with user namespaces enabled — can trigger it.
The vendor CVSS of 7.8 HIGH is technically correct for the AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H vector, but it materially undersells the real-world impact. The CVSS Scope metric is scored as *Unchanged*, yet the documented exploit chain escapes container boundaries and bypasses SELinux — that is a scope change by any operational definition. CISA agreed: they added this to the KEV catalog on August 27, 2026 under BOD 26-04 with a 3-day remediation window for federal agencies. A reliable, weaponized exploit exists via Google's kernelCTF program (3,525 lines across 31 files by researcher qwerty-po), and Red Hat elevated the flaw to security bulletin RHSB-2026-009 — a designation they reserve for their most operationally significant vulnerabilities. The vendor score belongs in a textbook; the real score belongs in your change-management escalation ticket.
6 steps from start to impact.
Attain local code execution on target host
- Local code execution on a Linux host running kernel ≥ 6.0 and < fixed version
- Ability to run user-space binaries
- Requires prior access — either a foothold from a separate initial-access vector, or a malicious/compromised container workload
- EDR or host-based IDS may detect the initial intrusion step
Create network namespace and configure loopback
unshare(CLONE_NEWUSER | CLONE_NEWNET) syscall accomplishes this without any privileges.- Unprivileged user namespaces enabled (
user.max_user_namespaces > 0) - UDPv6 socket creation permitted (default on all distros)
- Hosts with
user.max_user_namespaces=0or seccomp policies blockingunshare()are not reachable via this path - Hardened container runtimes (gVisor, Kata) intercept namespace syscalls
unshare() and clone() with CLONE_NEWUSER flag; Falco rules for unexpected namespace creation inside containersTrigger 15-byte OOB write via UDPv6 MSG_MORE + splice
splice() calls into a UDPv6 socket using MSG_MORE and MSG_SPLICE_PAGES cause the kernel's __ip6_append_data() to allocate an undersized linear skb buffer. The fraggap bytes (15 in the documented PoC) overflow past skb->end into the adjacent skb_shared_info structure. This is the core memory corruption primitive. The write is deterministic and does not require any heap spraying or race conditions.- Kernel takes the paged-allocation path in
__ip6_append_data() - MTU, routing header size, and payload sizes precisely calculated
- The 15-byte write window is narrow but the PoC demonstrates it is 100% reliable
- No KASLR bypass needed at this stage
splice, sendmsg) with legal flag combinationsActivate stale page descriptor via nr_frags flip
nr_frags field in skb_shared_info from 0 to 1. The kernel now believes the skb has one fragment, and reads the uninitialized frags[0] descriptor — which contains stale data from a previous allocation. When the skb is freed, the kernel calls put_page() on this stale page reference, creating a dangling page that remains referenced by the attacker's pipe buffers.- Successful OOB write from step 3
- Stale frags[0] data points to a valid page
- Memory layout must be groomed so frags[0] contains a usable stale reference — the kernelCTF exploit handles this reliably
Achieve arbitrary physical memory R/W
- Dangling page from step 4
- Ability to trigger page-table allocation (standard memory pressure techniques)
- This is a well-known exploitation pattern in kernelCTF; the exploit is mature
CONFIG_CFI_CLANG) does not cover PTE corruptionOverwrite core_pattern → root shell / container escape
/proc/sys/kernel/core_pattern to point to an attacker-controlled script. Triggering a segfault in a child process causes the kernel to execute the script as root (PID 1's namespace on the host). In container environments, this escapes the container boundary entirely — the script runs in the host's mount and PID namespace, bypassing SELinux, AppArmor, and seccomp. The attacker now has full root on the underlying host.- Arbitrary kernel write from step 5
- Ability to trigger a coredump (trivial:
kill -SIGSEGV $$)
- None — once step 5 succeeds, this is deterministic
/proc/sys/kernel/core_pattern; SIGMA rule for root shells spawned from unusual parent processessysctl -w user.max_user_namespaces=0 and persist in /etc/sysctl.d/99-cve-2026-53362.conf. This prevents unprivileged users from creating network namespaces, which the exploit requires to control loopback MTU and routing header configuration. Warning: this breaks rootless Podman/Docker and some application sandboxes (Chromium, Flatpak). Deploy within 3 days per the noisgate mitigation SLA for CRITICAL.ipv6.disable=1 to the kernel boot parameters via GRUB or equivalent. This eliminates the UDPv6 attack surface entirely — no IPv6 socket, no trigger path. Effective on hosts that are IPv4-only or dual-stack with IPv4 as the operational dependency. Deploy within 3 days per the noisgate mitigation SLA for CRITICAL.splice and unshare syscalls in container seccomp profiles. The exploit chain requires splice() to trigger MSG_SPLICE_PAGES and unshare() to create namespaces. Kubernetes RuntimeDefault seccomp already blocks unshare; verify it is enforced on all pods. This mitigates the container-escape angle specifically.core_pattern payload typically drops an executable in a world-writable directory. Mounting these with noexec forces the attacker to find an alternative writable+executable location, adding friction to the post-exploitation step. This is defense-in-depth, not a standalone fix.- SELinux — the documented exploit chain explicitly bypasses SELinux enforcement via kernel memory corruption. SELinux policy is a userspace construct; once the attacker has arbitrary kernel write, they can disable SELinux from ring 0.
- AppArmor profiles alone — same rationale as SELinux: kernel-level memory corruption operates below the MAC enforcement layer. AppArmor cannot prevent PTE manipulation.
- Network firewalls and segmentation — this is a local privilege escalation. The exploit does not traverse the network; it operates entirely within the host kernel via local syscalls. Firewall rules and VLANs are irrelevant.
- Disabling IPv6 at the network layer only (router/firewall ACLs) — the exploit uses a loopback socket inside a network namespace. External IPv6 filtering does not affect loopback traffic within a namespace. You must disable IPv6 at the *kernel* level (
ipv6.disable=1) to be effective.
The supporting signals.
| In-the-Wild Exploitation | Confirmed active. CISA added CVE-2026-53362 to the KEV catalog on 2026-08-27 citing evidence of real-world exploitation for privilege escalation. Red Hat issued security bulletin RHSB-2026-009 — a tier reserved for operationally critical flaws. |
|---|---|
| Proof-of-Concept | Weaponized exploit public. Researcher qwerty-po submitted a full kernelCTF exploit (3,525 lines, 31 files) to google/security-research PR #410. Detailed writeup at blog.qwerty.or.kr. Co-discovered with @physicube; IPv4 variant confirmed exploitable by Sultan Alsawaf (CIQ). |
| EPSS | 0.00709 (0.71%) — 30-day exploitation probability per FIRST. This score has *not yet caught up* with the KEV listing and active exploitation evidence; treat EPSS as lagging for this CVE. |
| KEV Status | Listed 2026-08-27. BOD 26-04 requires federal agencies to remediate immediately. Due date set to 2026-08-30 (3-day window). Ransomware use listed as *unknown*. |
| CVSS Vector | CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 7.8 HIGH. The *Scope:Unchanged* metric is the key undercount — the documented exploit escapes container boundaries, which is operationally a scope change. Attack complexity is genuinely Low: the exploit is deterministic with no race conditions. |
| Affected Versions | Linux kernel ≥ 6.0 (commit 773ba4fe9104, 2022-07-12). Reliably exploitable after commit ce650a166335 (2023-08-02). All stable branches in this range prior to fix are affected. RHEL 9 and earlier are not affected (kernel 5.14). RHEL 10 is affected. |
| Fixed Versions | Upstream: 6.1.177, 6.6.144, 6.12.95, 6.18.38, 7.1.3. Fix commit 736b380e28d0 merged 2026-06-25. Distro backports: RHEL 10 fixed 2026-07-14, Amazon Linux 2023 fixed 2026-07-07, Debian Bookworm 6.1.180-1+, Trixie 6.12.105-1+, Forky 7.1.8-2+. |
| Researchers | @qwerty-po and @physicube (kernelCTF). IPv4 variant confirmed by Sultan Alsawaf (team CIQ). Red Hat Bugzilla 2495904 ("ipv6 frag escape"). |
| Exposure Data | No GreyNoise or Shodan scanning signatures — this is a *local* privilege escalation, not remotely scannable. Exposure is determined by kernel version inventory. Every Linux host running 6.0+ with user namespaces enabled is a potential target. |
| Disclosure Timeline | Bug introduced 2022-07-12 → exploitable after 2023-08-02 → fix merged 2026-06-25 → disclosed 2026-07-04 → distro patches July 2026 → KEV listed 2026-08-27. The bug lived in the kernel for ~4 years before the fix. |
Sources.
Why this verdict
- Active exploitation overrides CVSS baseline. CISA added this to the KEV catalog on 2026-08-27 with a 3-day remediation window, confirming real-world attacks. A weaponized, reliable exploit (kernelCTF, 3,525 lines) is publicly available. The EPSS score of 0.71% has not caught up — weight the KEV signal over the lagging EPSS.
- Container escape turns a local bug into fleet-scale impact. The documented exploit chain escapes container boundaries, bypasses SELinux, and achieves host-level root. In any Kubernetes cluster or Docker host running a vulnerable kernel, a single compromised pod becomes full host compromise. The CVSS *Scope:Unchanged* metric is factually incorrect for this attack path — the exploit crosses security boundaries by design.
- Minimal friction on the documented chain. The exploit requires only an unprivileged user with a UDPv6 socket and user namespaces enabled (the default on RHEL 10, Ubuntu 24.04+, Debian Trixie+). No KASLR bypass is needed. No race conditions. No heap spray. Attack complexity is genuinely Low: the PoC is deterministic and 100% reliable per the researcher's writeup.
- Role multiplier: the Linux kernel is THE canonical high-value component. The affected component is the kernel itself — not an application, not a library. Every Linux server is a kernel host by definition. On container orchestration nodes (Kubernetes workers, Docker hosts, CI/CD runners), exploitation yields host root with lateral-movement capability across the cluster. On database servers, it yields full data access. On hypervisors (KVM), it threatens VM isolation. On identity infrastructure (FreeIPA, LDAP servers), it threatens domain-scale compromise. ≥50% of Linux kernel deployments occupy high-value roles (containers, databases, infrastructure). The verdict floor is CRITICAL per the deployment-role blast radius rule.
- Exploit maturity is at weaponized grade. The kernelCTF submission is not a crash PoC or a theoretical writeup — it is a fully engineered privilege-escalation-to-root exploit spanning 31 files and 3,525 lines, submitted by researchers who demonstrated it against Google's hardened kernelCTF targets. This is the highest tier of exploit maturity.
Why not higher?
A score of 9.0 rather than 10.0 reflects the local attack vector requirement: the attacker must first obtain code execution on the target host (or inside a container on it). This is not a wormable, unauthenticated remote code execution flaw. The initial-access step is a genuine precondition that limits opportunistic mass exploitation, even though in container environments the precondition is trivially satisfied by any workload.
Why not lower?
KEV listing with confirmed active exploitation sets an absolute floor — this is not theoretical. The kernel is the most canonical high-value component in computing, and the documented exploit achieves container escape and SELinux bypass deterministically. Downgrading below CRITICAL would require evidence that the exploit chain fails in a significant fraction of real deployments (e.g., user namespaces disabled fleet-wide), but the default configuration of every major enterprise distro shipping kernel 6.0+ enables the preconditions. The 4-year dwell time of this bug means the vulnerable code is deeply embedded in production fleets.
Crowdsourced verification payload.
Run this script on each target Linux host as any user (no root required). It checks the running kernel version against known fixed versions. Usage: bash cve-2026-53362-check.sh. Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN. For fleet-wide scanning, push via Ansible/Salt and collect exit codes.
#!/bin/bash
# CVE-2026-53362 Vulnerability Checker
# Checks running kernel against known fixed versions for the IPv6 fraggap OOB write
# No privileges required. Run on each target Linux host.
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN
set -euo pipefail
KERNEL_RELEASE=$(uname -r)
echo "[*] CVE-2026-53362 check on kernel: $KERNEL_RELEASE"
# Extract major.minor.patch
VERSION=$(echo "$KERNEL_RELEASE" | grep -oP '^\d+\.\d+\.\d+' || true)
if [ -z "$VERSION" ]; then
echo "UNKNOWN - Could not parse kernel version from: $KERNEL_RELEASE"
exit 2
fi
MAJOR=$(echo "$VERSION" | cut -d. -f1)
MINOR=$(echo "$VERSION" | cut -d. -f2)
PATCH=$(echo "$VERSION" | cut -d. -f3)
# Also check if user namespaces are enabled (exploit precondition)
USERNS="unknown"
if [ -r /proc/sys/user/max_user_namespaces ]; then
MAX_USERNS=$(cat /proc/sys/user/max_user_namespaces)
if [ "$MAX_USERNS" -eq 0 ] 2>/dev/null; then
USERNS="disabled (mitigated)"
else
USERNS="enabled ($MAX_USERNS) — exploit precondition MET"
fi
fi
# Check IPv6 status
IPV6="unknown"
if [ -f /proc/net/if_inet6 ]; then
IPV6="enabled — attack surface present"
else
IPV6="disabled — attack surface eliminated"
fi
check_vulnerable() {
echo "VULNERABLE - Kernel $VERSION is affected (fix not applied)"
echo " User namespaces: $USERNS"
echo " IPv6 status: $IPV6"
echo " Fixed versions: 6.1.177, 6.6.144, 6.12.95, 6.18.38, 7.1.3"
exit 1
}
check_patched() {
echo "PATCHED - Kernel $VERSION contains the fix"
echo " User namespaces: $USERNS"
echo " IPv6 status: $IPV6"
exit 0
}
# Vuln introduced in 6.0 (commit 773ba4fe9104, 2022-07-12)
# Not affected: < 6.0
if [ "$MAJOR" -lt 6 ]; then
echo "PATCHED - Kernel $VERSION predates vulnerable code (introduced in 6.0)"
exit 0
fi
if [ "$MAJOR" -eq 6 ]; then
case "$MINOR" in
0) check_vulnerable ;; # 6.0.x — EOL, no backport
1)
if [ "$PATCH" -ge 177 ]; then check_patched; else check_vulnerable; fi ;;
2|3|4|5) check_vulnerable ;; # EOL branches
6)
if [ "$PATCH" -ge 144 ]; then check_patched; else check_vulnerable; fi ;;
7|8|9|10|11) check_vulnerable ;; # EOL branches
12)
if [ "$PATCH" -ge 95 ]; then check_patched; else check_vulnerable; fi ;;
13|14|15|16|17) check_vulnerable ;; # EOL branches
18)
if [ "$PATCH" -ge 38 ]; then check_patched; else check_vulnerable; fi ;;
*)
echo "UNKNOWN - Kernel 6.$MINOR.x not in known fixed-version list; verify manually"
exit 2 ;;
esac
elif [ "$MAJOR" -eq 7 ]; then
case "$MINOR" in
0) check_vulnerable ;; # EOL
1)
if [ "$PATCH" -ge 3 ]; then check_patched; else check_vulnerable; fi ;;
*)
echo "UNKNOWN - Kernel 7.$MINOR.x not in known fixed-version list; verify manually"
exit 2 ;;
esac
else
echo "UNKNOWN - Kernel $MAJOR.x not in known affected/fixed range; verify manually"
exit 2
fi