quantumworld-dpdns-io/cve-2026-42945Vollständiges Forschungs-Repository zu CVE-2026-42945 mit Heap-Buffer-Overflow-Analyse, RCE-Exploit (Heap-Spray + Feng Shui), Erkennungsskripten und Patch-Anleitungen für die Schwachstelle im NGINX-Rewrite-Modul.
Heap-Pufferüberlauf in NGINX ngx_http_rewrite_module
| Metrik | Wert |
|---|---|
| CVSS v4.0 | 9.2 (Kritisch) |
| CVSS v3.1 | 8.1 (Hoch) — AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H |
| CWE | 122 — Heap-basierter Pufferüberlauf |
| Eingeführt | Juni 2008 — v0.6.27 |
| Entdeckt | April 2026 — DepthFirst Research |
| Behoben | 13. Mai 2026 — v1.30.1, v1.31.0 |
| CVE veröffentlicht | 21. Mai 2026 |
| Lebensdauer | ~18 Jahre (unerkannt) |
| Fix-Commit | 524977e7c534e87e5b55739fa74601c9f1102686 |
Ein nicht authentifizierter, entfernter Angreifer kann einen deterministischen Heap-Pufferüberlauf in NGINX-Worker-Prozessen auslösen, indem er eine konstruierte HTTP-Anfrage an einen Server mit einem bestimmten Konfigurationsmuster aus rewrite + set/if/rewrite sendet. Der Überlauf beschädigt Heap-Metadaten (ngx_pool_cleanup_t-Zeiger) und ermöglicht so Remote Code Execution (RCE) durch Heap-Spray- und Feng-Shui-Techniken.
server { listen 19321;
location ~ ^/api/(.*)$ {
rewrite ^/api/(.*)$ /internal?migrated=true;
set $original_endpoint $1;
}
}
**Wichtigste Anforderungen:**
- Eine `rewrite`-Direktive, deren Ersetzung `?` (Query-String-Trennzeichen) enthält
- Eine anschließende `set`-, `if`- oder `rewrite`-Direktive, die auf einen **unbenannten PCRE-Capture** (`$1`, `$2`, usw.) verweist
- Das `?` in der Rewrite-Ersetzung löst `ngx_http_script_start_args_code` aus, das `e->is_args = 1` setzt
### Was ein Angreifer erreichen kann
| Fähigkeit | Beschreibung |
|-----------|-------------|
| **Denial of Service** | Deterministisches Abstürzenlassen von Worker-Prozessen, was Respawn-Schleifen verursacht (funktioniert unabhängig von ASLR) |
| **Remote Code Execution** | Bei deaktiviertem ASLR (oder umgangen per Partiellem Überschreiben) vollständige RCE als der Nginx-Benutzer erreichen |
| **Datendiebstahl** | Durch Memory-Read-Primitives sensible Daten aus dem Worker-Heap extrahieren |
| **Persistenz** | Hintertüren per Codeausführung im Speicher des Worker-Prozesses platzieren |
---
## 2. Root-Cause-Analyse
### Die Zwei-Pass-Script-Engine
Die `ngx_http_rewrite_module` von NGINX verwendet eine **Zwei-Pass-Script-Engine** in `src/http/ngx_http_script.c`:
1. **Längen-Pass** (`ngx_http_script_run`): iteriert über alle Script-Codes, um die benötigte Gesamtpuffergröße zu berechnen. Schreibt Längen nach `le.ip` und `le.pos`.
2. **Kopier-Pass** (`ngx_http_script_copy_len`/`_code`): iteriert erneut und schreibt die tatsächlichen Bytes in den vorab zugewiesenen Puffer an `e->ip` und `e->pos`.
Jeder Script-Code hat zwei Handler: einen für jeden Pass. Zum Beispiel:
- `ngx_http_script_copy_len` → `ngx_http_script_copy_code`
- `ngx_http_script_start_args_len` → `ngx_http_script_start_args_code`
### Das `is_args`-Flag
Das Flag `e->is_args` auf der **Engine-Struktur** (`ngx_http_script_engine_t`) steuert, wie der Kopier-Pass bestimmte Zeichen behandelt:```c
typedef struct {
u_char *ip;
u_char *pos;
ngx_http_variable_value_t *sp;
ngx_str_t buf;
int flushed;
unsigned is_args:1; // <-- THE BUG
unsigned ncaptures:1;
ngx_uint_t captures_size;
// ...
} ngx_http_script_engine_t;
Wenn e->is_args = 1 ist, ruft der Kopiercode für die $N-Capture-Referenzen ngx_escape_uri() mit NGX_ESCAPE_ARGS auf, was Folgendes expandiert:
+ → %2B (1 Byte → 3 Bytes, +200%)% → %25 (1 Byte → 3 Bytes, +200%)& → %26 (1 Byte → 3 Bytes, +200%)Der Ausführungsablauf für das anfällige Muster:``` rewrite ^/api/(.*)$ /internal?migrated=true;
1. Während der **Rewrite-Auswertung** stößt die Engine in der Ersetzungszeichenfolge auf `?`, was `ngx_http_script_start_args_code` auslöst und `e->is_args = 1` setzt.
2. Das Rewrite ändert die Request-URI und fährt dann mit der nächsten Direktive fort.
3. **`e->is_args` wird NIE GELÖSCHT**.
Dann:```
set $original_endpoint $1;
le) wird für den Längen-Pass erstellt: ```c
ngx_memzero(&le, sizeof(ngx_http_script_engine_t));
Dies setzt le.is_args = 0 korrekt auf null, sodass der Längen-Pass die rohe, nicht maskierte Erfassungslänge zurückgibt.
e wieder, die aus Schritt 1 noch e->is_args = 1 aufweist. Der Kopier-Pass wendet URI-Escaping an und erweitert jedes maskierbare Zeichen von 1 Byte auf 3 Bytes innerhalb eines Puffers, der für die rohe Länge dimensioniert wurde — Heap-Überlauf.Pass 1 (Length — sub-engine le): le.is_args = 0 capture $1 = "A+++++B" → length = 7
Buffer allocated: 7 bytes
Pass 2 (Copy — main engine e): e.is_args = 1 ← LEAKED from rewrite capture $1 = "A+++++B" ngx_escape_uri("A+++++B", NGX_ESCAPE_ARGS): A → A (1 byte) + → %2B (3 bytes) ← EXPANSION + → %2B (3 bytes) + → %2B (3 bytes) + → %2B (3 bytes) + → %2B (3 bytes) B → B (1 byte) total written: 17 bytes buffer size: 7 bytes OVERFLOW: 10 bytes
Das Expansionsverhältnis ist `7 + (n_escapable * 2)`, wobei `n_escapable` die Anzahl von `+`, `%` und `&` im Capture ist.
---
## 3. Exploit-Mechanik
### Übersicht
| Schritt | Technik | Beschreibung |
|------|-----------|-------------|
| 1 | Overflow | Sende eine präparierte URI mit `+`-Padding, um den Heap-Puffer zum Überlaufen zu bringen |
| 2 | Heap Spray | Sende große Bodies per POST an `/spray`, um den Heap mit kontrollierten Daten zu füllen |
| 3 | Feng Shui | Ordne Allokationen so an, dass das Overflow-Ziel (`ngx_pool_cleanup_t`) benachbart ist |
| 4 | Corrupt Handler | Overflow überschreibt `ngx_pool_cleanup_t.handler` mit der Adresse von `system()` |
| 5 | Trigger Cleanup | Warte auf die Zerstörung des Pools → `system(cmd)` führt den Angreiferbefehl aus |
| 6 | Reverse Shell | Verkette mit Reverse-Shell-Payload für interaktiven Zugriff |
### Cross-Request Feng Shui
**Single-request Feng Shui schlägt fehl**, weil der Overflow die Metadaten des Pools (`->d.next`, `->d.failed`) beschädigt, bevor er den `cleanup`-Zeiger erreicht. Wenn der Pool am Ende der Anfrage zerstört wird, verursachen die beschädigten Metadaten einen **Absturz, bevor `system()` aufgerufen wird**.