
Isolierte Docker-Umgebung, die die CVE-2026-119618 mod_http2-Race-Condition in Apache httpd 2.4.55–2.4.70 reproduziert, mit Crash-PoC, Heap-Corruption-Primitiven, Core-Analyse und einer 2.4.71-A/B-Kontrolle.
assign_headers() Race (CWE-362)Edukatives Proof-of-Concept-Lab für CVE-2026-119618 (kritisch; veröffentlicht am 2026-11-11), eine
Race Condition in Apache HTTP Servers mod_http2, die httpd 2.4.55–2.4.70 betrifft und in
2.4.71 behoben wurde. Alles hier läuft gegen host-lokale Docker-Container, die an
127.0.0.1 in einem isolierten Netzwerk gebunden sind — richten Sie diese Tools niemals auf einen anderen Host.
Ergebnisse in einem Absatz: Der Bug reproduziert sich als zuverlässiger Heap-Corruption-Crash-PoC auf
2.4.70 (Core Dumps in apr_table/Allocator/Pool-Destroy-Pfaden, 6+ verschiedene Crash-Modi), und
zwei Corruption-Primitives wurden erreicht: Angreifer-Header-Bytes, die einen dereferenzierten
Datenzeiger überschreiben, und ein Pool-Cleanup-Function-Pointer-Hijack, der die Kontrolle auf eine
korrumpierte plain_cleanup_fn überträgt (Schritt-4-Primitive B). End-to-End-Codeausführung wurde NICHT
erreicht — die Schritte 5, 6 und 8 endeten jeweils mit einem präzisen, evidenzbasierten strukturellen Blocker
(siehe Ergebnisse). Die A/B-Kontrolle auf 2.4.71 ist sauber: 189.524 Streams über alle
Payload-Familien hinweg, null Resets/GOAWAYs/Cores.
Der gesamte Upstream-Fix (Commit 824beab9) ist eine Zeile in
modules/http2/h2_request.c, Funktion assign_headers():
// when: !is_connect && no_body && Content-Type present && Content-Length absent
- apr_table_setn(req->headers, "Content-Length", "0"); // writes SHARED session-side table
+ apr_table_setn(r->headers_in, "Content-Length", "0"); // writes per-request clone (2.4.71)
assign_headers() läuft in einem mod_http2 Worker-Thread (c2), aber req->headers ist eine
apr_table, die im Stream-Pool lebt, der dem nghttp2 Session-Thread (c1) gehört.
apr_table ist nicht thread-sicher, und APR-Pools synchronisieren keine Allokationen im selben Pool:
c1 session thread (nghttp2) c2 worker thread (mod_http2)
──────────────────────────── ────────────────────────────
h2_request_clone / push collect assign_headers()
iterate/copy req->headers ──────┐ apr_table_setn(req->headers,
apr_palloc from stream pool ──┐ │ "Content-Length", "0")
│ │ └─ realloc entry array (80 entries
shared session allocator ◄────┴─┴──────────── == capacity) + apr_palloc race
(lock-free on this path) ⇒ heap corruption / double-pop
Das setn des Workers kann das Entry-Array der Tabelle neu allokieren oder Einträge überschreiben, während der Session-Thread dieselbe Tabelle klont/iteriert, und sein apr_palloc konkurriert mit Allokationen des Session-Threads vom selben lock-freien Allocator-Knoten. 2.4.71 entfernt den gemeinsamen Schreibzugriff (verwendet den per-Request-Klon r->headers_in) und fügt pool_lock hinzu.
Eine HTTP/2-Anfrage, deren HEADERS-Frame END_STREAM trägt (kein Body), mit einem Content-Type-Header, keinem Content-Length und einer Nicht-CONNECT-Methode. Die Race-Condition besteht zwischen Session-Thread und Worker-Thread auf dem selben Stream, daher öffnet der PoC viele solcher Streams gleichzeitig und verstärkt dies durch RST-/Push-/Burst-Timing.
| Pfad | Zweck |
|---|---|
docker-compose.yaml | target = httpd:2.4.70 (verwundbar), target-fixed = httpd:2.4.71 (A/B), dev = dieser Container |
target/httpd-lab.conf | h2c-Konfiguration, injiziert via -c Include (Listen 8080, Protocols h2c http/1.1, Event-MPM, CoreDumpDirectory /tmp, CGI aktiviert) |
target/htdocs/ | push.cgi (gibt Link: </style.css>; rel=preload aus, um das Klonen im Session-Thread anzutreiben), diag.cgi (Core-/Proc-Diagnose, ?savecore bewahrt /tmp/core auf), fetch.cgi (lädt Dateien/Cores/Marker per gzip vom Target herunter) |
poc.py | h2-Race-Client (Crash-PoC + Grooming-Flags) |
exploit.py | Schritt-5/6-RCE-Treiber + wiederverwendbare Helfer (run_poc, save_and_fetch_core, gdb_batch, feste Adressen) |
cve2poc/ | Schritt-8-Dual-Loop-Harness (Cve2PoC-Architektur: Spec → statische Gates → Synthese → Ausführung → Oracle → Dual-Axis-Scoring → Verfeinerung/Replan) |
evidence/ | Schritt-Dokumentationen (STEP4_RCE.md, STEP5_RCE.md, STEP6_RCE.md, STEP8_CVE2POC.md), aufgelöste Backtraces, analyze_core.sh (Offline-Core-Resolver), archivierte Cores in target-bin/ |
src/ | schreibgeschützte Referenzquelle (httpd 2.4.70, apr 1.7.5) — wird nie gebaut |
Umgebungshinweise: Der Agent-/Dev-Container hat keine Docker-CLI — starte die Targets auf dem Host mit docker compose up -d target target-fixed. ASLR ist in diesem Lab aus, daher sind alle aufgezeichneten Adressen (system = 0xffff924292c0, mod_http2-Basis 0xffff91e60000, Header-Spray-Bereich 0xffff91600000–0xffff91650000, …) über alle Läufe hinweg stabil. kernel.core_pattern=core und core_uses_pid=0: Jeder Crash überschreibt das Target-/tmp/core — führe curl 'http://target:8080/diag.cgi?savecore' vor dem nächsten Race aus.
python3 -m venv .venv && .venv/bin/pip install h2 # once
# Crash PoC (reliable on 2 CPUs; expect exit 1 + a fresh ~1.1 GB core in target /tmp):
.venv/bin/python poc.py --host target --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 15 --persist
# Preserve + fetch + resolve the core (sleep ~15 s first — diag.cgi is unresponsive
# while the core flushes):
curl -s 'http://target:8080/diag.cgi?savecore'
curl -s 'http://target:8080/fetch.cgi?f=core' -o /tmp/c.gz && gunzip -f /tmp/c.gz
bash evidence/analyze_core.sh /tmp/c # offline gdb vs archived target binaries
# A/B control — identical run vs the patched image; expect 0 resets/GOAWAYs/cores:
.venv/bin/python poc.py --host target-fixed --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 30 --persist
# Step-8 dual-loop harness (strategy registry, dead-veto, dual-axis scoring, stall→replan):
.venv/bin/python -m cve2poc selftest # offline proof, green before any race
.venv/bin/python -m cve2poc run --strategy S2 --budget 4 --duration 20
.venv/bin/python -m cve2poc status # reconstruct state from the JSONL reward store
Wichtige poc.py-Grooming-Flags: --fill 78 (78 Filler + Content-Type + Host = 80 Einträge ==
Tabellenkapazität ⇒ erzwingt das verwundbare Realloc; --fill 0 ist die No-Race-Kontrolle), --pad N
(steuert den Stream-Pool-Verbrauch gegen die 8-KB-Allocator-Node-Grenze; 16 = Cleanup-Crash-
Fenster), --mode {race,rst,push,flood,burst}-Verstärker, --pattern (erkennbarer Header-
Spray), --payload-hex / --body-hex / --body-every (Binär-Payloads; nghttp2-Header-
Werte sind nur field-vchar, daher müssen NUL-haltige Bytes über DATA-Bodies transportiert werden).
poc.py bringt den 2.4.70-Worker reproduzierbar zum Absturz (conn 16 zuverlässiger als 32 auf 2 CPUs).
Offline aufgelöste Cores lassen sich in 6+ verschiedene Modi klassifizieren: Allocator-Free-List-Korruption
(apr_allocator_free mit einem checksummen-korrupten Pointer), apr_table-Eintrags-Races, Stream-
Datenpointer-Korruption, Bucket/Brigade-Korruption, Pool-Destroy-Cleanup-Crashes und APR-
Asserts. Jeder Core wird vor der Attribution auf seine Provenienz verifiziert (Apache/2.4.70, pool_lock-String fehlt).
Siehe evidence/EVIDENCE.md und BACKTRACE_*.txt.