
Laboratório Podman e PoC que reproduz a gravação fora dos limites do MQTT PUBACK do libwebsockets (ZDI-CAN-31039), com um broker malicioso, matriz de testes ASan e primitivas de heap unlink/sequestro de fluxo de controle.
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). Corrigido upstream por
c9e8e1834d7f13038c82963086b90e2ee9c5b44c ("ZDI-CAN-31039: enter wrong
state").
Laboratório Podman que reproduz o bug de ponta a ponta e mostra o que a corrupção proporciona: um broker MQTT controlado pelo atacante reescreve ponteiros de lista e uma tabela de ponteiros de função dentro de um cliente MQTT libwebsockets usando nada além de pacotes PUBACK. Nenhuma configuração incorreta do lado do cliente é necessária; quem executa o broker controla o parse (é isso que significa "authentication is not required" no aviso).
d0d1c796 (pai da correção)c9e8e1834 (mesclado em 2026-07-21), v5.0.0 e posterioresApenas o papel de cliente MQTT é afetado (-DLWS_ROLE_MQTT=1 ou
secure-streams MQTT). O libwebsockets não possui listener de servidor MQTT, portanto o
alvo é o cliente: stacks de IoT que se conectam a um broker.
Em _lws_mqtt_rx_parser() (lib/roles/mqtt/mqtt.c), quando o
VBI de comprimento de propriedades de um PUBACK é concluído com um valor diferente de zero, o
parser entra em um estado incorreto:
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 */
A correção altera essa última linha para
par->state = LMQCPP_EAT_PROPERTIES_AND_COMPLETE;.
par->fixed (o contador de slots fixed_seen[], ainda 3) não é reiniciado, então
o estado reentrado continua executando
par->fixed_seen[par->fixed++] = *buf++;: um byte controlado pelo atacante
por byte recebido, sequencialmente além de fixed_seen[4] para o resto de
struct lws_mqtt_parser_t e depois para o chunk de heap
struct _lws_mqtt_related que o contém (lws_zalloc(sizeof(*wsi->mqtt))).
Como fixed_seen[] fica no meio da struct, a caminhada sobrescreve os
próprios campos do parser. Nos offsets 16-19 (rel. a fixed_seen) fica cpkt_remlen,
que decide a verificação de conclusão remlen == fixed; nos 44-47 fica n,
operando da verificação de limites len < par->cpkt_remlen - par->n; no 84
fica fixed, o próprio contador. O gerador de payload em
evil_broker.py espelha o parser vulnerável byte a byte e direciona
esses campos: cpkt_remlen=256 nunca é igual ao contador uint8_t que sofre wrap
(sem conclusão espúria) e n=0 mantém a verificação de limites
satisfeita, então a escrita se sustenta por quantos bytes o broker
quiser enviar. O contador uint8_t confina a caminhada a uma janela de 256 bytes
que varre os bytes 32-287 do chunk, o que cobre o bookkeeping do parser,
a cauda de lws_mqttc_t (ponteiros de heap
id/username/password/will.*, e a tabela de ponteiros de função qos2_state_ops
em árvores pós-v4.5.8), e os primeiros
nós de timer lws_sorted_usec_list_t.
Primitivas que isso fornece, e o que o PoC faz com elas:
sul_qos_puback_pubrec_wait.dll2.prev/next: o teardown chama
lws_dll2_remove() e executa *(prev+8) = next; *(next) = prev
com valores do atacante, o habitual unlink write-what-whereqos2_state_ops: um PUBLISH QoS2 subsequente faz o lws chamar
qos2_state_ops->rx_add(wsi, cid, pkt_id), uma chamada indireta através
de memória do atacante.cb do timer (não demonstrado
aqui)Para manter a conexão viva entre dois estágios, o broker lê o packet-id do publish QoS1 da vítima do fio e o coloca no PUBACK forjado, para que o parse seja concluído pelo caminho normal de ACK em vez de atingir o fechamento por "unsolicited PUBACK".
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
| teste | build da vítima | modo do broker | esperado |
|---|---|---|---|
| T1 controle benigno | vuln+ASan | props_len=0 | fechamento limpo |
| T2 escrita OOB / unlink | vuln+ASan | envenenar dll2.prev/next = 0x4141414141414141 | desreferência do ponteiro do atacante no teardown |
| T3 controle corrigido A/B | commit de correção+ASan | igual a T2 | fechamento limpo |
| T4 sequestro de fluxo de controle | vuln+ASan+NDEBUG | envenenar qos2_state_ops = 0x0000424242424242 + PUBLISH QoS2 | SEGV na desreferência de ->rx_add (mqtt.c:952) |
| T5 crash natural | vuln, NDEBUG, sem ASan | envenenar client.id = 0x4141414141414141 | core dump por SIGSEGV |
| T6 versão afetada | v4.5.8+ASan | igual a T2 | ponteiro do atacante no nó da lista |
Resultados e trechos de log: RESULTS.md. O ASan não vê as próprias escritas (elas permanecem dentro de uma única alocação), então a evidência é a desreferência de valores do atacante em vez de um acerto de redzone.
P1 é um write-what-where e P2 é uma chamada com registradores de argumento escolhidos pelo lws. Transformar isso em execução de código exige um heap leak/groom e ausência de ASan; a travessia é determinística, então o payload só precisa dos offsets do build da vítima, que a sonda imprime por build.
LMQCPP_PROP_ID_VBI: if (vbit.value > LWS_ARRAY_SIZE(property_valid)) aceita prop_id == ARRAY_SIZE,
lendo um elemento além de property_valid[] e alcançando um estado de propriedade
que não deveria. Impacto baixo, mas é um bug de limites simples (presente na
v4.5.8; verifique a main atual).qos2_rx_list cresce sem limite: cada packet-id de PUBLISH QoS2 único
aloca um lws_mqtt_qos2_rx_t liberado apenas em PUBCOMP ou
no fechamento. Um broker pode aumentar a memória do cliente à vontade.pub->payload_len é o comprimento declarado (cpkt_remlen - overhead),
nunca limitado aos bytes entregues. O minimal-mqtt-client fornecido
faz hexdump de payload_len e lê além do limite; um payload declarado enorme também
engole pacotes subsequentes (parser preso em LMQCPP_PAYLOAD).LMQCPP_SUBACK_VH_PKT_ID / LMQCPP_UNSUBACK_VH_PKT_ID retornam -1
(descartam a conexão) quando há menos de 2 bytes em buffer, então esses
tipos de pacote não são tolerantes a fragmentação, apesar do comentário acima
do parser.python3 exploit/exploit.py executa a cadeia completa (saída 1 explorado, 0 seguro).