open-flaw/cve-2026-56848Exploit-PoC für CVE-2026-56848, ein Node.js-HTTP/2-Heap-Use-After-Free, der einen nicht authentifizierten Remote-DoS ermöglicht. Enthält Raw-Socket-Trigger, ASan-Build-Anweisungen und ein Docker-basiertes Ziel.
Ein Fehler in der HTTP/2-Verarbeitung von Node.js ermöglicht es,
nghttp2_session_mem_send()reentrant aufzurufen, währendnghttp2_session_mem_recv()ausgeführt wird, was zu einem Heap-Use-after-Free führt.Diese Schwachstelle betrifft Node.js 26.x, 24.x und 22.x.
(Hinweis: Die in der Beschreibung genannten Versionen gelten nur für das Upstream-Nodejs-Paket und nicht für das von Alpine vertriebene Nodejs-Paket.
| Release-Linie | Verwundbar | Behoben |
|---|---|---|
| 22.x (LTS) | ≤ 22.23.1 | 22.23.2 |
| 24.x (LTS) | ≤ 24.18.0 | 24.18.1 |
| 26.x | ≤ 26.5.0 | 26.5.1 |
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H — Remote, nicht authentifizierter DoS durch Heap-Korruption)daa6d25e3dce — "http2: defer rst stream while in scope" (nodejs-private/node-private#921)Http2Stream::SubmitRstStream() in src/node_http2.cc erzwingt eine Bereinigung ausstehender ausgehender Daten, bevor der RST_STREAM in die Warteschlange gestellt wird:```cpp
void Http2Stream::SubmitRstStream(const uint32_t code) {
CHECK(!this->is_destroyed());
code_ = code;
// (NGHTTP2_CANCEL is deferred — fix for an older double-free) if (session_->is_in_scope() && is_stream_cancel(code)) { session_->AddPendingRstStream(id_); return; }
// If possible, force a purge of any currently pending data here to make // sure it is sent before closing the stream. ... if (session_->SendPendingData() != 0) { // ← RE-ENTRANT mem_send() session_->AddPendingRstStream(id_); return; }
FlushRstStream(); }
`SendPendingData()` ruft `nghttp2_session_mem_send()` auf ([node_http2.cc:1970](https://github.com/nodejs/node/blob/v22.23.1/src/node_http2.cc#L1970)). Der einzige Reentranzschutz ist `is_sending()`, der gegen *Senden-während-Senden* (einen bereits laufenden Schreibvorgang) schützt — **nicht gegen Senden-während-Empfangen**. Wenn `SubmitRstStream()` aus einer `nghttp2_session_mem_recv()`-Callbackkette heraus ausgeführt wird („im Gültigkeitsbereich“), führt die Bereinigung `mem_send()` reentrant aus.
Das reentrante `mem_send()` spült Frames aus, deren sendeseitige Verarbeitung Streams abbaut (`nghttp2_session_close_stream_on_goaway()` → `on_stream_close` → `Http2Stream::Destroy()` → Freigabe des C++-`Http2Stream`). Der freigegebene Stream wird von der laufenden Empfangsoperation weiterhin referenziert: `SubmitRstStream()` selbst läuft auf dem freigegebenen `this` weiter (seine abschließende `FlushRstStream()` liest `is_destroyed()`), und das äußere `mem_recv()` arbeitet weiterhin den Frame-/Header-Zustand des geschlossenen Streams ab → **heap-use-after-free**.
### Trigger-Kette (alles innerhalb eines einzigen `nghttp2_session_mem_recv()`-Aufrufs)
1. Der Angreifer sendet `GOAWAY(lastStreamID=0, NO_ERROR)` unmittelbar gefolgt von `HEADERS`-Frames für neue Streams (3, 5, 7, …) in einem einzigen TCP-Segment.
2. Das `mem_recv()` des Servers verarbeitet GOAWAY → JS `session.close()` → `session.closed = true`, und ein ausgehendes GOAWAY wird **übergeben, aber noch nicht gesendet**.
3. nghttp2 lehnt neue eingehende Streams erst ab, wenn GOAWAY tatsächlich *gesendet* wurde (`session_allow_incoming_new_stream()` prüft `TERM_ON_SEND | SENT`, nicht `SUBMITTED`), daher wird `HEADERS(3)` weiterhin akzeptiert.
4. JS `onSessionHeaders()` erkennt einen neuen Stream auf einer geschlossenen Sitzung und lehnt ihn ab: `handle.rstStream(NGHTTP2_REFUSED_STREAM)` (lib/internal/http2/core.js).
5. C++ `SubmitRstStream(NGHTTP2_REFUSED_STREAM)` läuft im Gültigkeitsbereich (innerhalb von `mem_recv`), `REFUSED_STREAM ≠ CANCEL` → fällt durch zu `SendPendingData()` → **reentrantes `nghttp2_session_mem_send()`**.
6. Der reentrante Sendevorgang sendet das ausgehende GOAWAY aus; die sendeseitige GOAWAY-Verarbeitung von nghttp2 schließt eingehende Streams mit id > 1 (`session_close_stream_on_goaway(..., NGHTTP2_REFUSED_STREAM)`), löst `on_stream_close` aus → `Http2Stream::Destroy()` gibt das C++-Streamobjekt für Stream 3 frei.
7. Die Ausführung kehrt in `SubmitRstStream()` auf dem freigegebenen Objekt zurück (`FlushRstStream()`), und das äußere `mem_recv()` wird auf dem beschädigten Sitzungs-/Stream-Zustand fortgesetzt → UAF.
Beleg von `NODE_DEBUG_NATIVE=http2` auf einem verwundbaren Server (ein einzelner 86-Byte-Lesevorgang):```
receiving 86 bytes, offset 0
complete frame received: type: 7 ← GOAWAY
submitting goaway ← GOAWAY submitted, NOT yet sent
beginning headers for stream 3 ← still accepted (only SUBMITTED)
handle headers frame for stream 3 ← JS: session.closed → refuse
sending rst_stream with code 7 ← SubmitRstStream(REFUSED_STREAM), in scope
sending pending data ← RE-ENTRANT mem_send()
stream 3 closed with code: 7 ← GOAWAY send closes stream 3
Removing stream: 3 / destroying stream ← Http2Stream freed mid-recv
Die Ausgabe auf Wire-Ebene ist bei verwundbaren und gepatchten Builds identisch (beide senden letztendlich nur das ausgehende GOAWAY — bei verwundbaren Builds wird das RST gegen einen bereits geschlossenen Stream übermittelt, bei gepatchten Builds verwirft nghttp2 die in der Warteschlange befindlichen RSTs, sobald das GOAWAY zuerst gesendet wird). Der Unterschied ist intern und sichtbar mit NODE_DEBUG_NATIVE=http2:
sending pending data erscheint zwischen sending rst_stream with code 7 und stream 3 closed with code: 7 — der reentrante mem_send() läuft mitten im Empfang und schließt/zerstört Stream 3, während mem_recv() noch in Bearbeitung ist (Absturz unter ASan).sending pending data dazwischen — das RST wird lediglich in die Warteschlange gestellt; Stream 3 wird erst während des normalen Flush nach dem Empfang geschlossen.server.js # minimal http2.createServer() target (no handler needed) exploit.js # raw-socket HTTP/2 client that drives the trigger
### Schnellstart```bash
# Terminal 1: the target (any vulnerable node: 22.23.1 / 24.18.0 / 26.5.0 or older in their lines)
node server.js 8000 # NODE_BIN=/path/to/node for a specific binary
# Terminal 2: the attack — a crash shows up in terminal 1 (ASan report / segfault)
node exploit.js --port 8000 --iterations 200
./bin/node (der lokale ASan-Build, der unten verwendet wird) ist nicht in git versioniert — erstelle ihn mit den Anweisungen unter „Building an ASan-instrumented vulnerable Node.js" oder nutze den Docker-Weg.
Das Exploit meldet den Status pro Verbindung; SKIPPED (no handshake) nach der ersten Verbindung bedeutet, dass das Ziel bereits durch den Angriff gestorben ist.
Das Dockerfile baut ein verwundbares v22.23.1-Ziel mit ASan in einem Container (keine lokale Toolchain erforderlich — nur der Docker-Daemon):```bash
docker build -t cve-2026-56848 .
docker run --rm -p 8000:8000 --name cve-target cve-2026-56848
node exploit.js --port 8000 --iterations 10