
CVE-2026-99999 Educational Analysis — attack chain simulation of Linux kernel csum_start bug (CVSS 9.3). See also: CVE-2026-99999-exploit (Working PoC).
⚠️ This is the educational/analysis repository. It demonstrates the CVE-2026-99999 attack chain locally (no network, no root, no real exploit).
🔴 Host-side PoC + harness: → CVE-2026-99999-exploit (end-to-end guest→host trigger is not verified).
Linux kernel IPv4 csum_start validation bug — IPv4 header corruption in egress fragmentation
2026-11-06 实测复核(v100,
7.0.0-38-generic):漏洞真实、分片错位可复现; 信息泄露与提权未获证实。详见~/cve-2026-99999-verify/report.md。
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/analytical project. It demonstrates the CVE-2026-99999 attack chain locally (no network, no root, no real exploit). The host-side PoC and harness live in the internal exploit repository; that harness reproduces the IPv4 header corruption, but a guest→host trigger has not been verified end-to-end.
⚠️ For authorised security research in isolated lab environments only.
A frame injected through TUN/TAP (or virtio-net) carries a virtio_net_hdr
whose csum_start is an offset from the start of the frame. The kernel's
ingress check (__virtio_net_hdr_to_skb()) only requires
skb_transport_offset(skb) >= 20, so the value is accepted even when it
does not point at the transport header. After VLAN decapsulation the skb->data
pointer moves forward but 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 from csum_start to the end of the data 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 byte 0.
The first byte of the checksum becomes the new version/IHL. When it is
0x4F, IHL becomes 15 (60 bytes) and ip_do_fragment() copies a 60-byte
header. On the measured geometry (skb_headlen = 28) that reads 32 bytes past
the linear region. In our runs those 32 bytes were zero, so no host memory
was disclosed — the header-length corruption and the resulting payload
misalignment are what we could actually reproduce.
Impact (verified): attacker-chosen IPv4 header length in forwarded fragments, with a 40-byte payload shift and a valid-looking IP header checksum. Not verified: guest-to-host memory disclosure / escape.
struct virtio_net_hdr { // 10 bytes
uint8_t flags; // VIRTIO_NET_HDR_F_NEEDS_CSUM = 0x01
uint8_t gso_type; // VIRTIO_NET_HDR_GSO_NONE = 0x00
uint16_t hdr_len; // network layer header length
uint16_t gso_size; // GSO segment size
uint16_t csum_start; // offset to transport header start
uint16_t csum_offset; // offset to checksum field within transport header
};
csum_start is relative to the frame as handed to the kernel. The ingress guard
requires skb_transport_offset >= 20, so anything below 20 never reaches the
checksum code.
| Setting | csum_start | csum_offset | Write target | Result |
|---|---|---|---|---|
| Normal (UDP csum offload) | 34 (Eth 14 + IP 20) | 6 (UDP cksum) | byte 40 (UDP checksum) | ✅ Safe |
| Single Ethernet, real IPv4 start | 14 | 0 | — | ❌ -EINVAL at ingress (14 < 20), never reaches the kernel path |
| Single Ethernet, above the guard | 20 | 0 | IP byte 6 (Flags/FragOffset) | 🟡 accepted; measured as corrupted frag_off (40, 5496, …) |
| Two VLAN tags | 22 | 0 | IP byte 0 (IHL) | 🔴 accepted; measured IHL 5→15 on every fragment |
| Two VLAN tags | 22 | 6 | IP byte 6 (Flags) | 🟡 hypothesis only, not verified |
skb_checksum_help(skb, csum_start=22 on a two-VLAN frame):
1. offset = csum_start - skb_headroom(skb); after both VLAN tags are stripped
that is 22 - 22 = 0, i.e. the start of the IPv4 header
2. compute the one's complement sum from that offset to the end of the data
3. write the 16-bit result to offset + csum_offset (IPv4 bytes 0–1 for offset 0)
4. if the written first byte is 0x4F → version 4, IHL 15 (60 bytes)
5. ip_do_fragment() then copies a 60-byte header although skb_headlen is 28
→ 32 bytes read past the linear data (all zero in the measured runs)
┌──────────────────────────────────────────────────────────────────────────┐
│ ATTACK CHAIN OVERVIEW │
└──────────────────────────────────────────────────────────────────────────┘
Guest VM (attacker) / TAP injection
│
│ ① build_crafted_packet()
│ [virtio_net_hdr(csum_start=22, csum_offset=0)]
│ [Eth header]
│ [VLAN 1] [VLAN 2] ← IPv4 starts at frame offset 22
│ [IPv4 header: 0x45 = IHL 5]
│ [UDP header]
│ [payload]
│
▼
virtio-net / TAP ingress
│
│ ② __virtio_net_hdr_to_skb()
│ guard: skb_transport_offset < 20 → -EINVAL
│ 22 passes (14 would be rejected)
│ csum_start=22 stored in skb->csum_start
│
▼
Host Linux Kernel — IPv4 egress path (not GSO)
│
│ ③ VLAN tags are stripped: skb->data advances 22 bytes
│ headroom becomes 22 → write offset = 22 - 22 = 0
│ skb_checksum_help() sums from offset 0 to the end of the data
│ Writes the 16-bit result to IP bytes 0–1
│ If the first byte is 0x4F → IHL 5 → 15 (measured)
│
│ ④ ip_do_fragment() called with corrupted header
│ Copies hlen = 60 bytes, but skb_headlen = 28
│ 32 bytes read past the linear data — all zero in our runs
│ Payload starts at original payload[32] (40-byte shift)
│
▼
Outbound fragments
│
│ ⑤ Each fragment carries a 60-byte header whose IHL is attacker-chosen
│ and whose IP checksum is recomputed by the fragmenter (looks valid)
│
▼
Evidence on host egress interface
│
│ ⑥ tcpdump / bpftrace
│ 30/30 fragments with ver_ihl = 0x4F
│ CSUM_HELP target_b0 = 0x45 (the byte about to be overwritten)
| Offset | Field | Normal value | csum_offset=0 corrupts | csum_offset=6 corrupts |
|---|---|---|---|---|
| 0 | Version(4) + IHL(4) | 0x45 | ✅ overwritten (0x4F in tuned runs) | |
| 1 | TOS | 0x00 | ||
| 2–3 | Total Length | varies | ||
| 4–5 | Identification | varies | ||
| 6–7 | Flags + Fragment Offset | 0x20.. | ✅ Flags/FragOffset lo | |
| 8 | TTL | 0x40 | ||
| 9 | Protocol | 0x11 (UDP) | ||
| 10–11 | Header Checksum | computed | ||
| 12–15 | Source IP | varies | ||
| 16–19 | Destination IP | varies |
Découvrez les outils les plus utilisés par notre communauté.
Pas encore de données de popularité.