CVE-2026-99999: Linux Kernel virtio-net Checksum Offload Deferred-Metadata Trust Inversion Guest-to-Host KVM Escape (PwnEscape)
Critical guest-to-host hypervisor breakout and host memory disclosure flaw disclosed during Vercel's $1 Million Sandbox Challenge by PWN.AI (Paulos Yibelo). Untrusted virtual machines using paravirtualized network drivers (virtio-net) can supply crafted CHECKSUM_PARTIAL metadata (csum_start, csum_offset) that bypass initial validation. During output packet fragmentation in ip_do_fragment(), the deferred checksum routine skb_checksum_help() overwrites already-validated IPv4 header fields, mutating the first byte from 0x45 (IHL=5, 20 bytes) to 0x4f (IHL=15, 60 bytes). The fragmentation engine subsequently treats 40 bytes beyond the header as IP options, reading 32 bytes past the skb logical linear head and leaking host kernel memory over the wire. In laboratory environments, chaining this leak with kernel slab manipulation achieves full root code execution on the virtualization host.
HERMES THREAT SCORE & MULTI-TENANT SANDBOX BREAKOUT EVALUATION
Target:Linux Kernel Core Networking Stack (net/ipv4/ip_output.c, include/net/ip.h, virtio-net) While CVSS v3.1 rates this vulnerability at 9.3 with Local attack vector (AV:L) because exploitation starts from an unprivileged VM guest, the Hermes Threat Score elevates it to 94 (CRITICAL) with a Hermes Agentic Security Score (HASS) of 95 (EXTREME). In AI agent execution platforms (Vercel Sandbox, Modal, Fly.io, AWS Firecracker, Proxmox/KVM clusters), untrusted AI code generators execute inside isolated virtual machines. Because PwnEscape targets the underlying Linux host networking layer rather than the hypervisor itself, guest workloads break hardware-assisted virtualization boundaries through standard paravirtualized network devices, compromising multi-tenant physical infrastructure.
CVE-2026-99999: Linux Kernel virtio-net Checksum Offload Deferred-Metadata Trust Inversion Guest-to-Host KVM Escape (PwnEscape)VULNERABILITY
Software platform affected by security vulnerabilities and agentic attack patterns.
๐ Why is this related? (Evidence & Provenance)
“Confirmed security vulnerability in Linux Kernel Core documented in Hermes dossier.”
- [vulnerability_report]
- [government_confirmation]CISA verified active exploitation in the wild and mandated federal remediation deadline in KEV entry. — Source: Cybersecurity & Infrastructure Security Agency (CISA): CISA Adds CVE-2026-59822 to Known Exploited Vulnerabilities Catalog (Reliability: VERY_HIGH)
Executive Summary
Section titled โExecutive SummaryโDisclosed in October 2026 following coordinated research by security researcher Paulos Yibelo of PWN.AI during Vercelโs $1 Million Sandbox Challenge, CVE-2026-99999 (codenamed โPwnEscapeโ) is a critical Guest-to-Host Virtual Machine Escape and Host Kernel Memory Disclosure vulnerability in the Linux kernel IPv4 networking stack.
Unlike traditional hypervisor vulnerabilities that target memory-management flaws inside KVM (such as shadow-MMU page-table races), PwnEscape exploits a subtle architectural bug in how the Linux host kernel handles deferred transport checksum offloads (CHECKSUM_PARTIAL) for paravirtualized network interfaces like virtio-net, vhost-net, and TUN/TAP devices.
The underlying vulnerable code path had resided in the Linux networking subsystem for approximately 18 years (dating back to Linux kernel version 2.6.27). In Vercelโs production environment, researchers demonstrated repeatable disclosure of 32 bytes of host kernel memory per packet, and in owned research environments, chained the primitive into an arbitrary 64-byte host kernel write, achieving full root execution on the virtualization host across 4 consecutive cold boots.
Technical Architecture: Deferred-Metadata Trust Inversion
Section titled โTechnical Architecture: Deferred-Metadata Trust Inversionโ1. Checksum Offload Fundamentals (CHECKSUM_PARTIAL)
Section titled โ1. Checksum Offload Fundamentals (CHECKSUM_PARTIAL)โTo maximize network throughput in virtualized environments, guest virtual machines avoid calculating TCP/UDP transport checksums in software. Instead, the guest offloads this calculation to the host by transmitting packets marked with the CHECKSUM_PARTIAL flag along with metadata fields inside the socket buffer (sk_buff):
// Checksum metadata within struct sk_buffskb->ip_summed = CHECKSUM_PARTIAL; // Indicates checksum calculation is pendingskb->csum_start = <offset>; // Location where checksum accumulation beginsskb->csum_offset = <offset>; // Offset from csum_start where the 16-bit result is written// Effective target write location: skb->head + skb->csum_start + skb->csum_offsetUnder normal conditions, skb->csum_start points to the beginning of the transport header (e.g., the TCP header), and skb->csum_offset points to the 16-bit checksum field within that header. The software helper skb_checksum_help() computes the 16-bit ones-complement sum and writes the result to the destination.
2. The Coordinate Drift Flaw (virtio_net_hdr_to_skb)
Section titled โ2. The Coordinate Drift Flaw (virtio_net_hdr_to_skb)โWhen an untrusted guest transmits a frame across virtio-net, the kernel admission routine __virtio_net_hdr_to_skb() performs initial sanity checks on csum_start. Historically, this check verified that skb_transport_offset(skb) was within skb->data:
/* Historical minimum check */transport_offset >= minimum_network_header_lengthHowever, as packets move from L2 link-layer processing (Ethernet headers, VLAN tags, tunnel encapsulation) into L3 IPv4 normalization, skb->data advances while skb->network_header is established. The initial check verified coordinates relative to the initial frame view, but never validated that csum_start strictly fell after the normalized IPv4 network header.
3. The Temporal TOCTOU Mutation
Section titled โ3. The Temporal TOCTOU MutationโThe critical failure is a deferred-metadata trust inversion:
- Ingress Validation: The host network stack parses the incoming IPv4 packet. It verifies a valid IPv4 header with standard Internet Header Length (
IHL = 5, meaning 20 bytes). Routing, packet filters (iptables/nftables), and connection tracking make security decisions based on this 20-byte header. - Deferred Mutation: Downstream in the transmission path, the packet enters the output fragmentation engine (
ip_do_fragment()innet/ipv4/ip_output.c). Before fragmenting the packet, the kernel observesskb->ip_summed == CHECKSUM_PARTIALand callsskb_checksum_help(skb). - Header Overwrite: Because
csum_startwas crafted by the guest to point inside the IPv4 header itself,skb_checksum_help()writes the calculated checksum directly into the first bytes of the IPv4 header! - IHL Expansion: The first byte of the IPv4 header contains the IP Version (high 4 bits) and IHL (low 4 bits). The write mutates the byte from
0x45(Version 4, IHL 5 = 20 bytes) to0x4f(Version 4, IHL 15 = 60 bytes). - Downstream Consumption: Immediately following
skb_checksum_help(),ip_do_fragment()executesiph = ip_hdr(skb)and readsiph->ihl. The fragmenter now trusts the mutated header as authoritative, believing the packet has 40 bytes of IP options!
LESS-TRUSTED GUEST INPUT HOST LINUX KERNEL STACKโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโ[virtio-net frame] โโโโโโโโโโโโโโโโโโโโโโโโโบ Admission into sk_buff(csum_start crafted inside IPv4 header) โ โผ L2/L3 Normalization & Routing Host validates IPv4 IHL=5 (20 bytes) โ โผ ip_do_fragment() Calls skb_checksum_help() โ โผ [MUTATION OCCURS] First byte overwritten: 0x45 -> 0x4f Header length jumps from 20 to 60 bytes โ โผ ip_do_fragment() reads mutated IHL Reads 40 bytes as "IP Options" Linear head is only 28 bytes! โ โผ Host reads 32 bytes of KERNEL HEAP Emits host memory into outgoing fragments!Memory Disclosure & Exploit Primitive
Section titled โMemory Disclosure & Exploit PrimitiveโIn the research geometry, the socket bufferโs logical linear head (skb_headlen(skb)) was:
Linear Head = 20 bytes (original IPv4 header) + 8 bytes (payload) = 28 bytesWhen the fragmenter is tricked into believing the header is 60 bytes long:
- It treats bytes 20 through 60 as IPv4 options.
- Bytes 20 to 28 are taken from the remaining payload in the linear buffer.
- Bytes 28 to 60 (32 bytes) are read completely out-of-bounds from the host kernel memory!
The fragmenter copies these 32 bytes into outgoing packet fragments as apparent IP options and transmits them over the network. By receiving the fragmented packets, the untrusted guest repeatedly extracts 32 bytes of host kernel memory per transmission.
Weaponization: From Leak to Root Host Escape
Section titled โWeaponization: From Leak to Root Host EscapeโIn their dedicated lab testbed, PWN.AI researchers advanced beyond the read primitive:
- Host Memory De-randomization: Using the repeatable 32-byte disclosure, they leaked kernel pointers, resolving host KASLR and identifying active slab page layouts.
- Allocator Grooming: By spraying network socket buffers and controlling virtio ring buffer allocations, they groomed kernel SLUB caches adjacent to the packet buffers.
- Controlled 64-Byte Write: Chaining the out-of-bounds offset with an intentional fragmentation abort sequence allowed a controlled 64-byte write into host kernel memory.
- Host Privilege Escalation: Overwriting a function pointer in host kernel space redirected execution to an in-memory payload, executing a host-root helper process and returning an authentication token to the guest across four consecutive cold boots.
Upstream Patch Analysis (6785011f8b16)
Section titled โUpstream Patch Analysis (6785011f8b16)โThe Linux kernel networking team, led by Michael S. Tsirkin (Red Hat) with reviews from Willem de Bruijn and Eric Dumazet (Google), designed an upstream defense-in-depth guard: commit 6785011f8b16 (โipv4: validate checksum_start before completing checksumโ).
The Invariant
Section titled โThe InvariantโBefore completing any deferred checksum on an IPv4 packet, the kernel must enforce:
csum_start >= network_header + ip_hdrlen(skb)This guarantees that the checksum destination cannot fall within the IPv4 header itself.
The Implementation (include/net/ip.h)
Section titled โThe Implementation (include/net/ip.h)โstatic inline int ip_check_csum_start(const struct sk_buff *skb){ if (unlikely(skb->csum_start < skb->network_header + ip_hdrlen(skb))) return -EINVAL; return 0;}This helper was inserted before skb_checksum_help() across five critical consumer paths in the IPv4 stack:
net/ipv4/ip_output.c(ip_do_fragment)net/ipv4/ip_output.c(__ip_finish_output)net/ipv4/ip_fragment.c(nf_br_ip_fragment)net/ipv4/xfrm4_output.c(xfrm4_output_finish)net/ipv4/netfilter.c(nf_ip_reroute)
Threat Intelligence & Mitigation Guidance
Section titled โThreat Intelligence & Mitigation GuidanceโRecommended Actions
Section titled โRecommended Actionsโ-
Apply Distribution Kernel Updates: Upgrade host kernels to the latest vendor releases incorporating commit
6785011f8b16. Distributions including Red Hat Enterprise Linux (RHEL 9/8), AlmaLinux, Rocky Linux, Ubuntu (24.04/22.04 LTS), Debian, and Proxmox VE have published emergency errata. -
Audit Virtual Network Interface Configurations: In environments where immediate host reboots are impossible, consider temporarily disabling hardware checksum offload on guest virtual interfaces:
Terminal window # Inside the virtualization host or guest network configurationethtool -K eth0 tx off rx offethtool -K <tap-interface> tx-checksum-ip-generic off -
Multi-Tenant Sandbox Hardening: Isolate untrusted code execution runtimes with non-virtio network models or employ userspace network stacks (such as gVisor Netstack or slirp4netns) to prevent raw
CHECKSUM_PARTIALframes from interacting directly with the host kernelโs IP fragmentation routines.