
Lab Podman e PoC che riproduce la scrittura fuori dai limiti MQTT PUBACK di libwebsockets (ZDI-CAN-31039), con un broker malevolo, una matrice di test ASan e primitive di heap unlink/dirottamento del flusso di controllo.
ZDI-CAN-31039, ZDI-26-792, CWE-787, CVSS 8.1
(AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H). Corretto upstream da
c9e8e1834d7f13038c82963086b90e2ee9c5b44c ("ZDI-CAN-31039: enter wrong
state").
Lab Podman che riproduce il bug end to end e mostra cosa consente la corruzione: un broker MQTT controllato dall'attaccante riscrive i puntatori delle liste e una tabella di puntatori a funzione all'interno di un client MQTT libwebsockets usando soltanto pacchetti PUBACK. Nessuna misconfigurazione lato client necessaria; chiunque esegua il broker controlla il parsing (è il "authentication is not required" nell'advisory).
d0d1c796 (parent della correzione)c9e8e1834 (merged 2026-07-21), v5.0.0 e successiveÈ interessato solo il ruolo client MQTT (-DLWS_ROLE_MQTT=1 o
secure-streams MQTT). libwebsockets non ha un listener server MQTT, quindi il
target è il client: stack IoT che si connettono a un broker.
In _lws_mqtt_rx_parser() (lib/roles/mqtt/mqtt.c), quando la
VBI della lunghezza delle proprietà di un PUBACK termina con un valore diverso da zero, il
parser entra nello stato errato:
case LMQCPP_PUBACK_PROPERTIES_LEN_VBI:
...
par->props_len = par->vbit.value;
if (!par->props_len)
goto cmd_completion;
lws_mqtt_vbi_init(&par->vbit);
par->state = LMQCPP_PUBACK_VH_PKT_ID; /* WRONG */
La correzione modifica quell'ultima riga in
par->state = LMQCPP_EAT_PROPERTIES_AND_COMPLETE;.
par->fixed (il contatore degli slot fixed_seen[], ancora 3) non viene reimpostato, quindi
lo stato rientrato continua a eseguire
par->fixed_seen[par->fixed++] = *buf++;: un byte controllato dall'attaccante
per ogni byte ricevuto, in sequenza oltre fixed_seen[4] nel resto di
struct lws_mqtt_parser_t e poi nel chunk heap racchiudente
struct _lws_mqtt_related (lws_zalloc(sizeof(*wsi->mqtt))).
Poiché fixed_seen[] si trova a metà della struct, la scansione sovrascrive i campi
del parser stesso. Agli offset 16-19 (rel. a fixed_seen) si trova cpkt_remlen,
che decide il controllo di completamento remlen == fixed; agli offset 44-47 si trova n,
operando del controllo dei limiti len < par->cpkt_remlen - par->n; all'offset 84
si trova fixed, il contatore stesso. Il generatore di payload in
evil_broker.py rispecchia byte per byte il parser vulnerabile e governa
questi campi: cpkt_remlen=256 non è mai uguale al contatore uint8_t
che va in wrap-around (nessun completamento spurio) e n=0 mantiene soddisfatto
il controllo dei limiti, così la scrittura si sostiene da sola per tutti i byte che il broker
decide di inviare. Il contatore uint8_t confina la scansione in una finestra di 256 byte
che spazza i byte del chunk 32-287, il che copre il bookkeeping del parser,
la coda di lws_mqttc_t (puntatori heap
id/username/password/will.*, e la tabella di puntatori a funzione qos2_state_ops
sugli alberi post-v4.5.8), e i primi
nodi timer lws_sorted_usec_list_t.
Le primitive che questo fornisce, e cosa ne fa il PoC:
sul_qos_puback_pubrec_wait.dll2.prev/next: il teardown chiama
lws_dll2_remove() ed esegue *(prev+8) = next; *(next) = prev
con valori controllati dall'attaccante, il solito unlink write-what-whereqos2_state_ops: un successivo PUBLISH QoS2 fa sì che lws chiami
qos2_state_ops->rx_add(wsi, cid, pkt_id), una chiamata indiretta attraverso
memoria controllata dall'attaccante.cb dei timer (non dimostrato
qui)Per mantenere viva la connessione attraverso due fasi, il broker legge il packet-id del publish QoS1 della vittima dal filo e lo inserisce nel PUBACK costruito ad hoc, così il parsing si completa attraverso il normale percorso ACK invece di incorrere nella chiusura per "PUBACK non sollecitato".
lab/Containerfile self-contained build, clones upstream at pinned commits
lab/build.sh builds vuln/fixed/release trees (ASan and plain)
lab/offsets_probe.c offsetof() map, compiled with each tree's CC flags
lab/victim_client.c lws MQTT client victim (QoS1 publish + subscribe)
lab/evil_broker.py malicious broker + FSM-mirror payload generator
lab/run_poc.sh 6-test matrix with PASS/FAIL verdicts
Makefile podman build/run (--cpus 2 --memory 4g)
make poc
# or manually:
podman build -t cve-2026-114550:lab lab/
podman run --rm --cpus 2 --memory 4g --network none -v $PWD/output:/output \
cve-2026-114550:lab
| test | build vittima | modalità broker | atteso |
|---|---|---|---|
| T1 controllo benigno | vuln+ASan | props_len=0 | chiusura pulita |
| T2 scrittura OOB / unlink | vuln+ASan | avvelena dll2.prev/next = 0x4141414141414141 | dereferenziazione del puntatore dell'attaccante durante il teardown |
| T3 controllo fisso A/B | commit di fix+ASan | come T2 | chiusura pulita |
| T4 dirottamento del flusso di controllo | vuln+ASan+NDEBUG | avvelena qos2_state_ops = 0x0000424242424242 + PUBLISH QoS2 | SEGV alla dereferenziazione di ->rx_add (mqtt.c:952) |
| T5 crash naturale | vuln, NDEBUG, senza ASan | avvelena client.id = 0x4141414141414141 | core dump SIGSEGV |
| T6 release affetta | v4.5.8+ASan | come T2 | puntatore dell'attaccante nel nodo della lista |
Risultati ed estratti dei log: RESULTS.md. ASan non vede le scritture stesse (restano all'interno di una singola allocazione), quindi l'evidenza è la dereferenziazione dei valori dell'attaccante invece di un hit sulla redzone.
P1 è una write-what-where e P2 è una chiamata con registri degli argomenti scelti da lws. Trasformarla in esecuzione di codice richiede un heap leak/groom e l'assenza di ASan; la walk è deterministica, quindi il payload necessita solo degli offset del build vittima, che la probe stampa per ogni build.
LMQCPP_PROP_ID_VBI: if (vbit.value > LWS_ARRAY_SIZE(property_valid)) accetta prop_id == ARRAY_SIZE,
leggendo un elemento oltre property_valid[] e raggiungendo uno stato di proprietà
che non dovrebbe. Impatto basso, ma è un semplice bug di bounds (presente in
v4.5.8; verificare il main attuale).qos2_rx_list cresce senza un limite: ogni packet-id PUBLISH QoS2 univoco
alloca un lws_mqtt_qos2_rx_t liberato solo su PUBCOMP o
chiusura. Un broker può far crescere la memoria del client a piacimento.pub->payload_len è la lunghezza dichiarata (cpkt_remlen - overhead),
mai limitata ai byte consegnati. Il minimal-mqtt-client fornito
esegue l'hexdump di payload_len e legge oltre; un payload dichiarato enorme
inghiotte anche i pacchetti successivi (parser bloccato in LMQCPP_PAYLOAD).LMQCPP_SUBACK_VH_PKT_ID / LMQCPP_UNSUBACK_VH_PKT_ID restituiscono -1
(scartando la connessione) quando sono bufferizzati meno di 2 byte, quindi quei
tipi di pacchetto non tollerano la frammentazione nonostante il commento sopra
il parser.python3 exploit/exploit.py esegue la catena completa (exit 1 sfruttato, 0 sicuro).