Skip to content

CVE-2026-99999: Linux Kernel virtio-net Checksum Offload Deferred-Metadata Trust Inversion Guest-to-Host KVM Escape (PwnEscape)

Density:
C-Level Executive Briefing CVE-2026-99999 CRITICAL SCORE 94/100

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.

HYBRID

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)
Confidence: 99%
94 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 18 / 20
Weaponization 19 / 20
Exposure 18 / 20
Prevalence 20 / 20
Impact 20 / 20
Exploit Maturity 19 / 20
Attack Chain Potential 20 / 20
โš–๏ธ Divergence & Operational Rationale

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.

๐Ÿ•ธ๏ธ Connected Knowledge Graph & Provenance

CVE-2026-99999: Linux Kernel virtio-net Checksum Offload Deferred-Metadata Trust Inversion Guest-to-Host KVM Escape (PwnEscape)VULNERABILITY

Connected Nodes: 1
Active Relationships (Outgoing)
→ affectsPRODUCTLinux Kernel Core
98% VERY_HIGH

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.”

Supporting Verified Evidence:

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.


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_buff
skb->ip_summed = CHECKSUM_PARTIAL; // Indicates checksum calculation is pending
skb->csum_start = <offset>; // Location where checksum accumulation begins
skb->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_offset

Under 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.

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_length

However, 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.

The critical failure is a deferred-metadata trust inversion:

  1. 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.
  2. Deferred Mutation: Downstream in the transmission path, the packet enters the output fragmentation engine (ip_do_fragment() in net/ipv4/ip_output.c). Before fragmenting the packet, the kernel observes skb->ip_summed == CHECKSUM_PARTIAL and calls skb_checksum_help(skb).
  3. Header Overwrite: Because csum_start was 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!
  4. 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) to 0x4f (Version 4, IHL 15 = 60 bytes).
  5. Downstream Consumption: Immediately following skb_checksum_help(), ip_do_fragment() executes iph = ip_hdr(skb) and reads iph->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!

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 bytes

When 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.

In their dedicated lab testbed, PWN.AI researchers advanced beyond the read primitive:

  1. Host Memory De-randomization: Using the repeatable 32-byte disclosure, they leaked kernel pointers, resolving host KASLR and identifying active slab page layouts.
  2. Allocator Grooming: By spraying network socket buffers and controlling virtio ring buffer allocations, they groomed kernel SLUB caches adjacent to the packet buffers.
  3. 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.
  4. 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.

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โ€).

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.

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:

  1. net/ipv4/ip_output.c (ip_do_fragment)
  2. net/ipv4/ip_output.c (__ip_finish_output)
  3. net/ipv4/ip_fragment.c (nf_br_ip_fragment)
  4. net/ipv4/xfrm4_output.c (xfrm4_output_finish)
  5. net/ipv4/netfilter.c (nf_ip_reroute)

  1. 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.

  2. 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 configuration
    ethtool -K eth0 tx off rx off
    ethtool -K <tap-interface> tx-checksum-ip-generic off
  3. 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_PARTIAL frames from interacting directly with the host kernelโ€™s IP fragmentation routines.