← Back to Feed CACHED · 2026-10-09 03:04:35 · CACHE_KEY CVE-2026-53362
CVE-2026-53362 · CWE-787 · Disclosed 2026-07-04

Linux Kernel IPv6 __ip6_append_data() Fraggap Out-of-Bounds Write

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

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.

"KEV-listed kernel LPE with reliable container escape — patch or disable user namespaces now"
02 · The Attack Path

6 steps from start to impact.

STEP 01

Attain local code execution on target host

The attacker needs unprivileged shell access on a Linux host running a vulnerable kernel (6.0+). In container environments, this is any workload — a compromised web app, a CI runner job, a data-pipeline container. On bare-metal or VM servers, it could be an SSH session from a compromised service account, a webshell, or post-exploitation from an initial network intrusion.
Conditions required:
  • Local code execution on a Linux host running kernel ≥ 6.0 and < fixed version
  • Ability to run user-space binaries
Where this breaks in practice:
  • 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
Detection/coverage: Standard EDR process-tree monitoring; initial-access detection is orthogonal to this CVE
STEP 02

Create network namespace and configure loopback

The attacker creates a user namespace (unprivileged on RHEL 10, Ubuntu 24.04+, Debian Trixie+ by default) and within it a network namespace. Inside the netns, they configure the loopback interface with a specific MTU (1287 bytes) and set up a 320-byte IPv6 routing header. This precise configuration controls the fraggap value needed to trigger the bug. The unshare(CLONE_NEWUSER | CLONE_NEWNET) syscall accomplishes this without any privileges.
Conditions required:
  • Unprivileged user namespaces enabled (user.max_user_namespaces > 0)
  • UDPv6 socket creation permitted (default on all distros)
Where this breaks in practice:
  • Hosts with user.max_user_namespaces=0 or seccomp policies blocking unshare() are not reachable via this path
  • Hardened container runtimes (gVisor, Kata) intercept namespace syscalls
Detection/coverage: Audit rules on unshare() and clone() with CLONE_NEWUSER flag; Falco rules for unexpected namespace creation inside containers
STEP 03

Trigger 15-byte OOB write via UDPv6 MSG_MORE + splice

Two 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.
Conditions required:
  • Kernel takes the paged-allocation path in __ip6_append_data()
  • MTU, routing header size, and payload sizes precisely calculated
Where this breaks in practice:
  • The 15-byte write window is narrow but the PoC demonstrates it is 100% reliable
  • No KASLR bypass needed at this stage
Detection/coverage: No known runtime detection; the operation uses legitimate syscalls (splice, sendmsg) with legal flag combinations
STEP 04

Activate stale page descriptor via nr_frags flip

The 15-byte OOB write overwrites the 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.
Conditions required:
  • Successful OOB write from step 3
  • Stale frags[0] data points to a valid page
Where this breaks in practice:
  • Memory layout must be groomed so frags[0] contains a usable stale reference — the kernelCTF exploit handles this reliably
Detection/coverage: Kernel memory corruption detection (KASAN) would catch this in debug builds; production kernels do not run KASAN
STEP 05

Achieve arbitrary physical memory R/W

The attacker reallocates the freed (but still pipe-referenced) page as a PTE page via page-table manipulation. Since the attacker still holds a pipe buffer reference to the page, they can read and write arbitrary PTE entries through the pipe, granting arbitrary physical memory access. This is a god-mode primitive: full kernel memory read/write without any KASLR bypass needed.
Conditions required:
  • Dangling page from step 4
  • Ability to trigger page-table allocation (standard memory pressure techniques)
Where this breaks in practice:
  • This is a well-known exploitation pattern in kernelCTF; the exploit is mature
Detection/coverage: No practical runtime detection; kernel integrity monitoring (e.g., CONFIG_CFI_CLANG) does not cover PTE corruption
STEP 06

Overwrite core_pattern → root shell / container escape

With arbitrary kernel memory write, the attacker overwrites /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.
Conditions required:
  • Arbitrary kernel write from step 5
  • Ability to trigger a coredump (trivial: kill -SIGSEGV $$)
Where this breaks in practice:
  • None — once step 5 succeeds, this is deterministic
Detection/coverage: Monitor for unexpected changes to /proc/sys/kernel/core_pattern; SIGMA rule for root shells spawned from unusual parent processes
03 · Compensating Control

1
CRITICAL 9.0→MEDIUM 4.5
SEVERITY REDUCED
Disable unprivileged user namespaces immediately — Set sysctl -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.
2
CRITICAL 9.0→IGNORE 0.0
SEVERITY REDUCED
Disable IPv6 on hosts where not operationally required — Add 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.
3
CRITICAL 9.0→HIGH 6.0
SEVERITY REDUCED
Apply restrictive seccomp profiles to all containers — Block the 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.
4
CRITICAL 9.0→IGNORE 0.0
SEVERITY REDUCED
Deploy kernel live-patches where available — SUSE kGraft and Red Hat kpatch support live-patching for this CVE on supported kernel versions, avoiding the reboot window. Verify live-patch availability for your specific kernel version and distro. This is a full fix without downtime. Apply within the noisgate remediation SLA of 90 days for CRITICAL, but target immediately given KEV status.
5
CRITICAL 9.0→HIGH 7.0
SEVERITY REDUCED
Mount noexec on /tmp, /dev/shm, /var/tmp — The exploit's 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.
What doesn't work
  • 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.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationConfirmed 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-ConceptWeaponized 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).
EPSS0.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 StatusListed 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 VectorCVSS: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 VersionsLinux 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 VersionsUpstream: 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 DataNo 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 TimelineBug 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.

  1. NVD CVE-2026-53362
  2. Red Hat Security Bulletin RHSB-2026-009
  3. CISA KEV Catalog Entry
  4. Researcher Writeup — qwerty-po (Frag Gap)
  5. kernelCTF Exploit Submission (google/security-research PR #410)
  6. CISA Alert — Three KEV Additions (2026-08-27)
  7. Red Hat CVE Page
  8. Container Escape Analysis — aicybr
05 · The Call

Final Verdict
↑ UPGRADED to CRITICAL (9.0/10)

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.

06 · Verification

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.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/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