01luyicheng/cve-2026-99999-analysisCVE-2026-99999 Analisi didattica — simulazione della catena di attacco della vulnerabilità csum_start del kernel Linux (CVSS 9.3). Vedi anche: CVE-2026-99999-exploit (PoC funzionante).
⚠️ Questo è il repository didattico/di analisi. Dimostra la catena di attacco CVE-2026-99999 localmente (nessuna rete, nessun root, nessun exploit reale).
🔴 Vuoi un exploit funzionante? → Vedi CVE-2026-99999-exploit (PoC reale di VM escape, richiede un ambiente lab KVM/QEMU).
Bug di validazione di csum_start nell'IPv4 del kernel Linux — Memory Leak da Guest a Host
CVSS 9.3 CRITICAL | CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Scoperto da Paulos | CNA: kernel.org | Pubblicato: 2026-10-15
Questo è un progetto didattico/analitico. Dimostra la catena di attacco CVE-2026-99999 localmente (nessuna rete, nessun root, nessun exploit reale). Per un exploit funzionante che attiva la vulnerabilità reale in un ambiente live, vedi il repository interno dell'exploit.
⚠️ Solo per ricerca di sicurezza autorizzata in ambienti lab isolati.
Una VM guest può inviare un frame virtio-net il cui virtio_net_hdr contiene
csum_start == 0 — puntando nell'header IPv4 invece che nell'header
di trasporto. Durante la segmentazione GSO sull'host, skb_checksum_help() ricalcola
il checksum sulla regione che inizia da csum_start e scrive il risultato
in csum_start + csum_offset.
Con csum_start = 0 e csum_offset = 0, la scrittura finisce sul byte IHL
(offset IP 0), corrompendolo da 0x45 (IHL 5 → 20 byte) a 0x4F
(IHL 15 → 60 byte). La funzione ip_do_fragment() del kernel legge quindi 60 byte di
header IP quando ne esistono solo 20 — prelevando ~32–64 byte di memoria heap
adiacente del kernel host in ogni frammento in uscita.
Impatto: Divulgazione continua di memoria heap del kernel da guest a host.
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
};
| Impostazione | csum_start | csum_offset | Destinazione scrittura | Risultato |
|---|---|---|---|---|
| Normale (offload csum UDP) | 34 (Eth+IP) | 6 (cksum UDP) | Byte 40 (campo checksum UDP) | ✅ Sicuro |
| Exploit (corruzione IHL) | 0 (header IP) | 0 (byte IHL) | Byte 0 (byte IHL) | 🔴 IHL corrotto |
| Exploit (FragOffset) | 0 (header IP) | 6 (Flag) | Byte 6 (Flag/FragOffset) | 🟡 Riassemblaggio interrotto |
skb_checksum_help(skb, csum_start=0, csum_offset=0):
1. Read skb data at offset csum_start (0) = start of IP header
2. Compute one's complement sum over [0, csum_offset+2) = [0, 2) = first 2 bytes
3. Write 16-bit result to offset csum_start + csum_offset = byte 0
4. Result: IHL byte 0x45 → 0x4F (IHL 5→15)
5. ip_do_fragment() called with corrupted iph:
→ reads 60 bytes of "IP header" (iph + 40 bytes of HEAP DATA)
→ includes that heap data in each outbound fragment
┌──────────────────────────────────────────────────────────────────────────┐
│ ATTACK CHAIN OVERVIEW │
└──────────────────────────────────────────────────────────────────────────┘
Guest VM (attacker)
│
│ ① build_crafted_packet()
│ [virtio_net_hdr(csum_start=0)]
│ [Eth header]
│ [IPv4 header: 0x45 = IHL 5]
│ [UDP header]
│ [payload: "CVE-2026-99999-POC"]
│
▼
QEMU / vhost-user backend
│
│ ② Frame passes through virtio-net
│ virtio_net_hdr is stored in skb->data
│ csum_start=0 stored in skb->csum_start
│
▼
Host Linux Kernel — GSO Segmentation Path
│
│ ③ skb_checksum_help() called
│ Reads: csum_start=0 (IP header start)
│ Computes: checksum over first 2 bytes
│ Writes: result to byte 0 (IHL byte)
│ IHL: 0x45 → 0x4F (IHL 5 → 15)
│
│ ④ ip_do_fragment() called with corrupted header
│ Reads: 60 bytes of "IP header"
│ Actually reads: 20B real header + 40B HEAP DATA
│ Includes heap data in each fragment payload
│
▼
Outbound Network Frames
│
│ ⑤ Each fragment contains:
│ [Eth (14B)] [IP (60B — IHL says 60, only 20 exist)]
│ [Fragment payload]
│ [+ ~32-64 bytes of HOST KERNEL HEAP MEMORY]
│
▼
Evidence captured on host bridge
│
│ ⑥ tcpdump / receive_and_dump.py
│ Captures frames with IHL=0x4F
│ Frames larger than expected by ~32-64 bytes
│ Extra bytes = host kernel heap memory!
| Offset | Campo | Valore normale | csum_offset=0 corrompe | csum_offset=6 corrompe |
|---|---|---|---|---|
| 0 | Version(4) + IHL(4) | 0x45 | ✅ IHL → 0x4F | |
| 1 | TOS | 0x00 | ||
| 2–3 | Total Length | variabile | ||
| 4–5 | Identification | variabile | ||
| 6–7 | Flags + Fragment Offset | 0x20.. | ✅ Flags/FragOffset lo | |
| 8 | TTL | 0x40 | ||
| 9 | Protocol | 0x11 (UDP) | ||
| 10–11 | Header Checksum | calcolato | ||
| 12–15 | Source IP | variabile | ||
| 16–19 | Destination IP | variabile |
In un pacchetto normale virtio-net con offload del checksum UDP:
Packet layout:
[Eth (14B)] [IP (20B)] [UDP (8B)] [payload]
virtio_net_hdr:
csum_start = 34 ← points at UDP header (Eth+IP = 14+20)
csum_offset = 6 ← UDP checksum field is 6 bytes into UDP header
skb_checksum_help():
Write target = 34 + 6 = 40 ← byte 40 is the UDP checksum field ✓ SAFE
Con exploit CVE-2026-99999:
Packet layout:
[virtio_net_hdr (10B)] [Eth (14B)] [IP (20B)] [UDP (8B)] [payload]
virtio_net_hdr (MALICIOUS):
csum_start = 0 ← points at start of IP header!
csum_offset = 0 ← write lands on byte 0 = IHL byte!
skb_checksum_help():
Write target = 0 + 0 = 0 ← byte 0 is the IHL byte ← CORRUPTED!
IHL: 0x45 (0100 0101) → 0x4F (0100 1111)
IHL: 5 (5×4=20 bytes) → 15 (15×4=60 bytes)
ip_do_fragment():
Reads 60 bytes as "IP header"
Only 20 bytes exist → 40 bytes of ADJACENT HEAP MEMORY read!
Requisiti: solo Python 3.6+. Nessuna rete, nessun root, nessuna dipendenza.
# Clone
git clone https://github.com/01luyicheng/CVE-2026-99999-analysis.git
cd CVE-2026-99999-analysis/poc
# Run — IHL corruption / heap-leak simulation (CVSS 9.3 path, default)
python3 cve_2026_99999.py --simulate
# Flags/FragOffset corruption path (fragment reassembly disruption)
python3 cve_2026_99999.py --simulate -c 6
# More packets / fragments
python3 cve_2026_99999.py --simulate -n 5 -f 8