
Simulation-only proof of concept for CVE-2026-99999, a Linux kernel virtio-net IPv4 csum_start validation bug enabling guest-to-host heap memory disclosure.
Linux kernel IPv4 header corruption via malformed virtio-net checksum metadata.
CVSS 9.3 CRITICAL | CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Discovered by Paulos | CNA: kernel.org | Published: 2026-10-15
⚠️ This is an educational / validation PoC. It runs in --simulate mode only
(no network I/O, no root required). It demonstrates the attack chain locally
without exploiting any live system.
A frame injected through TUN/TAP (or sent by a guest over virtio-net) carries a
virtio_net_hdr whose csum_start is an offset from the start of the frame.
The ingress check (__virtio_net_hdr_to_skb()) only requires
skb_transport_offset >= 20, so a value that does not point at the transport
header is still accepted. After VLAN decapsulation the skb->data pointer moves
forward while the stored csum_start does not, so the offset is re-interpreted
against a different base.
In the IPv4 output path, skb_checksum_help() sums the data from csum_start
to the end, folds it, and writes the 16-bit result back to
csum_start + csum_offset. With a two-VLAN frame (csum_start = 22) that
write lands on IPv4 bytes 0–1: byte 0 becomes the folded checksum's high byte
and, when it is 0x4F, IHL becomes 15 (60 bytes).
ip_do_fragment() then copies a 60-byte header. On the measured geometry
(skb_headlen = 28) that reads 32 bytes past the linear region — but in our
runs those bytes were zero, so no host memory was disclosed.
Impact (verified): attacker-influenced IPv4 header length in forwarded
fragments (demonstrated value: 0x4F, IHL=15; other values require re-tuning
the payload) plus a 40-byte IP-payload shift, with a valid IP checksum.
Not verified: guest-to-host memory disclosure or escape.
Attack surface: KVM/QEMU hosts with virtio-net or TAP devices that feed frames into an IPv4 forwarding path, where checksum completion happens in software on the egress device.
| Offset | Field | csum_offset=0 corrupts | csum_offset=6 corrupts |
|---|---|---|---|
| 0 | Version + IHL | ✅ IHL byte | |
| 1 | TOS | ||
| 2–3 | Total Length | ||
| 4–5 | Identification | ||
| 6–7 | Flags / Fragment Offset | ✅ Flags/FragOffset (lo) | |
| 8 | TTL | ||
| 9 | Protocol | ||
| 10–11 | Header Checksum | ||
| 12–15 | Source IP | ||
| 16–19 | Destination IP |
Note: with csum_offset=0 the kernel overwrites IP bytes 0–1, so byte 0 becomes
the high byte of the folded checksum (byte 1 becomes TOS). IHL is therefore
written[0] & 0x0F; it only reaches 15 when that byte is 0x4F, which depends
on the payload. The target offset is frame-relative: 0 and 14 (single
Ethernet) are rejected at ingress because skb_transport_offset < 20.
Guest VM / TAP injection
→ constructs virtio_net_hdr with csum_start=22 on a two-VLAN frame
(14, the real IPv4 start with one Ethernet header, is rejected: < 20)
→ sends frame through virtio-net / TAP to the host
Host kernel (IPv4 egress fragmentation, not GSO)
→ VLAN tags are stripped: skb->data advances 22 bytes, csum_start does not
→ skb_checksum_help() writes the folded checksum to csum_start + csum_offset
→ offset 0: writes IP bytes 0–1 (IHL) → 0x4F means IHL=15 in our runs
→ offset 6: would write Flags/FragOffset (not verified)
→ ip_do_fragment() copies hlen=60 from a 28-byte linear region
→ 32 bytes past skb_headlen are read; they were 0 in our runs
| csum_offset | Corrupted Field | Consequence | Status |
|---|---|---|---|
0 (default) | IP bytes 0–1 (IHL + TOS) | Measured: IHL 5→15, 40-byte IP-payload shift; logical read of 32B past skb_headlen (content 0) | ✅ reproduced |
6 | Flags/FragOffset (offset 6) | Fragment reassembly metadata corruption | 🟡 hypothesis, unverified |
Introduced by f43798c27684 (2008, v2.6.27). Affected: 2.6.27 ≤ version < the
matched fixed release below.
Fixed: 5.10.272+, 5.15.223+, 6.1.190+, 6.6.159+, 6.12.113+, 6.18.57+, 7.2.11+, 7.3
Check your kernel version:
uname -r
cat /proc/version
Requirements: Python 3.6+ only. No pip packages, no network, no root.
# Clone
git clone https://github.com/01luyicheng/CVE-2026-99999.git
cd CVE-2026-99999
# Run — IHL corruption simulation (educational model, default)
python3 CVE-2026-99999_pwnescape.py --simulate
# Simulate with 5 datagrams and 8 fragments each
python3 CVE-2026-99999_pwnescape.py --simulate -n 5 -f 8
# Flags/FragOffset corruption path (unverified hypothesis)
python3 CVE-2026-99999_pwnescape.py --simulate -c 6
Without --simulate, the script prints the full vulnerability description and exits:
python3 CVE-2026-99999_pwnescape.py
| Flag | Description | Default |
|---|---|---|
--simulate | Run exploit chain simulation (required) | — |
-c, --csum-offset | 0 = IP bytes 0–1 (IHL, default); 6 = Flags/FragOffset (hypothesis) | 0 |
-n, --num-packets | Number of datagrams to simulate | 3 |
-f, --fragments | Fragments per datagram (minimum 2) | 4 |
The simulation runs in 5 steps (no network required):
virtio_net_hdr with
csum_start=22 and configurable csum_offset. Values below 20 are refused,
mirroring the ingress guard.[csum_start, end] and writes it to csum_start + csum_offset,
printing the actual bytes and the resulting IHL.hlen = IHL*4 and shows which field is affected.hlen can equal the whole IP packet, so no out-of-bounds
read occurs; the measured OOB case needs a long paged payload
(skb_headlen = 28).python3 CVE-2026-99999_pwnescape.py --simulate -n 1 -c 0
csum_start=22, csum_offset=0 → write lands on IP bytes 0–1 → IHL 5→15 when
byte 0 is 0x4F → ip_do_fragment() copies 60 bytes from a 28-byte linear
region and shifts the payload by 40 bytes. The 32 bytes read past the linear
region were zero in the measured runs, so this is header corruption, not a
demonstrated memory leak.
python3 CVE-2026-99999_pwnescape.py --simulate -n 1 -c 6
csum_start=22, csum_offset=6 → would write Flags/FragOffset byte →
fragment reassembly metadata corrupted. This path has not been executed
against a live kernel.
The simulator has been reviewed internally (code quality only). Key findings:
हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।
अभी तक कोई लोकप्रियता डेटा नहीं है।