Skip to main content
Mallory
CriticalPublic exploitVulnerability

CVE-2026-42533: Heap Buffer Overflow in NGINX Regex Map Variable Evaluation

Published Jul 15, 2026 · Updated 4 days ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days16 mentions · peak 5 in a dayToday
CVSS9.2Critical · v4
EPSS6.3%94th percentile
CISA KEVNoNot listed
In the wildReported1 exploitation record in Mallory
Vendor
F5
IdentifiersCVE-2026-42533CWE-122 · Heap-based Buffer Overflow

CVE-2026-42533 is a heap-based buffer overflow in the internal script engine of NGINX Open Source and NGINX Plus. The engine constructs variable-containing strings using separate length-calculation and copying passes. Evaluating a regex-based map can change regex capture state between these passes, causing more data to be copied than the allocated buffer can hold. A vulnerable configuration references the map's regex capture variables before its output variable in a string expression; certain uses of non-cacheable variables can also trigger the flaw. Unauthenticated attackers can send crafted requests to corrupt an NGINX worker's heap, causing a worker restart or potentially arbitrary code execution. Vulnerable Stream configurations using TLS preread can also expose the affected evaluation path. The vulnerability affects the data plane only, with no control-plane exposure.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

Remote exploitation can crash or restart NGINX worker processes, disrupting request processing and causing denial of service. Repeated triggering can sustain service disruption. Arbitrary code execution is possible when Address Space Layout Randomization (ASLR) is disabled or successfully bypassed, potentially compromising the confidentiality and integrity of data accessible to the worker process. Enabling ASLR does not eliminate the underlying overflow or denial-of-service risk.

Mitigation

If you can’t patch tonight, do this now.

Replace unnamed regex captures with unique named captures, reference them only within the block containing the regex match, and do not reuse capture names across regex matches in different directives. Review complex expressions to avoid capture references before map output variables and remove problematic non-cacheable-variable evaluation patterns where feasible. Named captures alone are not a complete substitute for updating. Restrict untrusted access to affected HTTP and Stream listeners, particularly TLS-preread listeners. Keep ASLR enabled to reduce code-execution risk, while recognizing that it neither prevents worker crashes nor guarantees protection against exploitation.

Remediation

Patch, then assume compromise.

Install a current vendor-supported release containing the fix. Initial fixed releases include NGINX Open Source 1.30.4 and 1.31.3; NGINX Plus 37.0.3.1 or R36 P7; NGINX Instance Manager 2.22.2; F5 WAF for NGINX 5.13.4; NGINX Gateway Fabric 2.6.7; and NGINX Ingress Controller 2026-lts-r4 or 5.5.3. Prefer newer security-maintained releases: the original correction introduced the separately tracked regression CVE-2026-93479, addressed in NGINX 1.30.6 and 1.31.7. For distribution packages, install the latest applicable security update rather than relying solely on the upstream version number; some backports were reverted or subsequently corrected. Restart NGINX after updating to load the corrected binary and validate the configuration and request handling.

Public exploits

Exploits

6 exploits validated by Mallory's analysis. Hidden: 10 rejected by Mallory's analysis as not a working exploit.

View more in app →
CVE-2026-42533This repository is a real exploit research and reproduction project for CVE-2026-42533, a pre-authentication nginx memory corruption issue caused by two-pass complex-value evaluation reusing and clobbering regex capture state. The repo is not a framework module; it is a standalone lab/research repository combining documentation, debug tooling, and exploit helpers. Structure-wise, it has three main purposes: (1) deep technical analysis in ANALYSIS.md and README.md, (2) HTTP-variant reproduction and dynamic debugging under debug/ and http-rift/, and (3) a referenced/ported stream-variant RCE chain. The debug/ directory builds nginx 1.30.3 from source with symbols and --with-debug, exposes gdbserver, and includes Python gdb automation to trace the vulnerable code paths (ngx_http_complex_value, ngx_http_map_variable, ngx_http_regex_exec, capture copy routines). The recon scripts inspect heap layout, overflow landing zones, and leak behavior. The http-rift/ directory contains an alternate nginx lab configuration, a local TCP sink service for heap spraying via /spray, a TLS ClientHello/SNI sender for stream leak testing, and a copied nginx source subtree used for source-level analysis. Main exploit capabilities extracted from the repo are: response/header capture clobbering, heap overflow when attacker-controlled mapped input is longer than the original regex capture, heap information disclosure when it is shorter, and reliable worker crash/DoS. The documentation also states that the stream variant achieves full RCE and supports arbitrary command execution, with the example payload writing /tmp/pwn. The HTTP path in this repo is more of an operational exploit lab than a one-click RCE: it demonstrates the primitives, validates memory corruption and leaks, and includes heap-spray helpers, but the README/analysis explicitly notes that full HTTP RCE remains an engineering task while stream RCE is already reproduced. The primary network target pattern is nginx configured with a regex location and regex map over attacker-controlled input. For HTTP, the trigger is a GET request to /test/<path> with an X-Input header. For stream/TLS testing, the repo includes code that sends a crafted TLS ClientHello with a long SNI to a local port. Overall maturity is OPERATIONAL: the repository contains working exploit primitives, lab automation, and a documented command-execution chain for the stream variant, but it is not packaged as a generalized weaponized framework.jelasin · Disclosed Jul 27, 2026 · python · bash · web · networkOperationalCVE-2026-42533This repository is a standalone Python proof-of-concept exploit suite for the claimed nginx vulnerability CVE-2026-42533, described as a pre-auth heap buffer overflow caused by two-pass evaluation of regex captures and map directives. The repo contains four main Python scripts under exploit/: `leak.py` for information disclosure, `overflow.py` for diagnostic/crash/heap-spray/overflow triggering, `exploit.py` for the full chain combining leak, spray, and RCE, and `analyze.py` for generating a GDB helper script to derive target-specific offsets. Supporting infrastructure includes a Dockerfile, docker-compose file, and a deliberately vulnerable `nginx/nginx.conf` that exposes multiple regex-driven endpoints to reproduce the bug. The exploit capability is substantial: it first abuses `/leak/<long path>` with the `X-Clobber` header to cause a LEN/VALUE mismatch and expose uninitialized heap bytes in the `X-Leak-Result` response header, then scans the leaked bytes for likely libc and heap pointers to bypass ASLR. It next performs heap grooming/spraying and finally targets `/api/abc` (or related variants) with attacker-controlled header/body content to trigger a controlled heap overflow. The intended corruption target is `ngx_pool_cleanup_t`, specifically its handler and data pointers, so that nginx connection teardown calls an attacker-chosen libc function such as `system()` or `execve()` with attacker-controlled arguments. The code also supports crash-only verification, leak-only reconnaissance, manual mode with supplied addresses, and reverse-shell style execution. Fingerprintable targets are primarily local HTTP endpoints on the victim nginx instance: `/leak/`, `/api/`, `/x/`, `/proxy/`, and `/named/`, all served on port 8080 in the included lab environment. Important request/response headers include `X-Clobber`, `X-Overflow`, `X-Leak-Result`, `X-Path`, `X-Leak`, and `X-Named`. The included nginx config logs to `/tmp/nginx-error.log`, and the example command payload writes to `/tmp/pwned`. Overall, this is not merely a detector or README; it is an operational PoC exploit repository with explicit crash, leak, and RCE functionality, though successful RCE depends on target-specific offsets and heap layout tuning.imbas007 · Disclosed Jul 27, 2026 · python · dockerfile · network · webOperationalCVE-2026-42533-POCRepository is a real exploit PoC suite for CVE-2026-42533, a pre-auth nginx heap overflow plus heap/libc info leak caused by capture-state corruption across two-pass script evaluation. The repo contains 9 files: 5 Python exploit/validator scripts, 2 nginx configs, 1 exploitation writeup, and a README. The main exploit is exploits/poc.py, which targets a local nginx instance on 127.0.0.1:8950 and supports four modes: --crash (trigger ASan-visible heap overflow), --leak (extract libc and heap pointers from oversized response body), --rce (general pre-auth RCE using leak + heap shaping + overflow), and --rce-det (deterministic RCE against a tightly controlled config). The RCE chain uses a leak request to recover libc and heap addresses, opens many victim connections to shape adjacency, frees one to create a hole, then sends a crafted POST /b/abc body that overwrites a neighboring pool cleanup pointer so nginx later calls system() on attacker-controlled command data. Payload construction is hardcoded/basic rather than framework-driven, so maturity is OPERATIONAL. Supporting scripts broaden coverage: calibrate.py derives deterministic offsets by launching nginx and reading /proc/<pid>/maps and /proc/<pid>/mem; leak_multi.py demonstrates the same leak primitive through additional sinks (return and set) on temporary listeners; named_capture_poc.py triggers the related named-capture r->variables[] variant under ASan; test_all_sites.py validates 13 vulnerable HTTP/stream sink sites with temporary nginx configs and ASan. The configs directory provides nginx_poc.conf for crash/leak/general RCE and nginx_det.conf for deterministic RCE. Both expose listen 127.0.0.1:8950 and use proxy_pass to http://127.0.0.1:19999, though the backend need not exist because the overflow occurs before connection. Overall, the repository’s purpose is to reproduce, validate, and weaponize the vulnerability from primitive crash/leak through full pre-auth code execution, while also documenting affected sinks and exploitation details.0xCyberstan · Disclosed Aug 5, 2026 · python · markdown · network · webOperationalcve-2026-42533This is an 11-file, self-contained Python/Docker research repository for CVE-2026-42533, an NGINX HTTP-script-engine heap overflow caused by two-pass LEN/VALUE evaluation and regex `map` capture clobbering. Documentation describes affected versions, patch commits, detection behavior, allocator analysis, and an intended cleanup-handler RCE chain. The `lab/` directory builds vulnerable NGINX 1.31.2 by default, optionally builds patched 1.31.3, disables ASLR for deterministic exploit research, and supplies slow, echo, and raw-dump Python backends. Its NGINX configuration deliberately exposes header- and body-driven vulnerable sinks. The repository provides three progressively capable tools: `poc/diagnose.py` is a non-crashing detector that sends small HTTP requests and identifies vulnerable response divergence versus the patched 500 response; `poc/crash.py` submits an oversized `X-Gadget` header to `/trigger/` and verifies a worker PID change after heap-corruption SIGABRT; and `exploit/exploit.py` performs precise socket-driven heap grooming, sends a NUL-capable request-body overflow to `/x/`, and tries to redirect an NGINX pool cleanup callback to libc `system()`. The command payload creates `/tmp/PWNED_CVE_2026_42533`. The RCE code is credible exploit-development code rather than a detection-only script or fake exploit, but it is highly lab-specific. It hard-codes allocator geometry and a libc `system` address, requires ASLR disabled and GDB-derived snapshot values (`victim_pool`, `trigger_buf`, pool pointers, and request blob) that are currently `None`, so the shipped non-dry RCE path cannot succeed until an operator fills those values for the exact lab process. The confirmed practical capability in the committed default state is vulnerability detection and worker DoS against the deliberately vulnerable configuration.FranklinF25 · Disclosed Aug 29, 2026 · python · dockerfile · network · containerOperationalcve-scannerThe repository is a standalone Go batch scanner with exploit attempts, not merely a README or a passive detector. Its 18 supplied files include eight Go files, two Python files, one shell script, and one Makefile counted as code-bearing files. main.go exposes target-list, output, concurrency, timeout, and command options; internal/scanner coordinates concurrent scanning and result recording. Separate packages handle WebLogic, PHP, web-server fingerprints, and application probes. Docker files provide test services, scripts/test.sh orchestrates local testing, and the Makefile/GitHub workflow build and package binaries. The WebLogic code fingerprints T3 and Console services, checks version prefixes, probes encoded Console bypass paths, and attempts Runtime.exec through a ShellSession expression. T3 delivery references external serialized payloads and cycles through UID variants, but ignores -cmd and always returns an empty result. The referenced embedded payload directory is absent, preventing compilation of the supplied tree. Although documentation mentions IIOP, no IIOP implementation is supplied. The LMCache claim is particularly misleading: the scanner sends plaintext EXEC:<cmd>, not a ZeroMQ/msgpack/pickle exploit. Its included Python target is a purpose-built unauthenticated shell-command server, not LMCache. Rails is simulated with nginx and Langroid with a small Python HTTP server. Their scanner checks establish only endpoint/content fingerprints, not arbitrary file read or sandbox escape. Thus successful lab output does not validate the claimed vulnerabilities. PHP probing actively sends a 64 MiB request and checks errors or disconnects, which can affect availability and contradicts the README's harmless-command-only characterization. NGINX, Apache, Node.js, IIS, and HTTP.sys findings in the main execution path are fingerprint/version assertions; additional malformed-request helpers exist but are not invoked. PASS is assigned to any output not containing version_match or the failure marker, so even vulnerable_detected or a TCP read failure can be labeled successful exploitation. The claimed CVE mappings and affected-version ranges are repository assertions, not independently verified facts. There is no demonstrated hidden exfiltration, persistence, or malicious cleanup; the Makefile's rm -rf is a conventional dist-directory cleanup and is not evidence of a fake exploit. Nevertheless, missing payload assets, mock-based validation, unsupported tcp:// parsing, permissive heuristics, and unreliable output extraction substantially limit validity. No original repository URL, git reference, archive path, or archive byte size was supplied; empty metadata and size 0 represent unavailable values.hktalent · Disclosed Oct 27, 2026 · go · python · network · webOperationalCVE-2026-42533This repository is a compact exploit lab for CVE-2026-42533 against nginx 1.30.1. It contains four files: a minimal top-level README, a Dockerfile that builds a reproducible Ubuntu-based lab, an environment/setup guide (env.md), and the main Python exploit (poc.py). The Dockerfile downloads nginx 1.30.1, builds two variants of nginx (a normal debug build and an AddressSanitizer build), and clones the PoC repository into the container. The documentation explains that the vulnerable path involves nginx stream/SSL preread/map/regex processing and that separate builds are used for crash analysis versus leak/RCE development. The main exploit logic is in cve-2026-42533-lab/poc.py. It is a real exploit, not merely a detector. It implements several modes exposed via CLI flags: --crash for heap overflow crash reproduction, --leak for information disclosure, --rce for a probabilistic full RCE chain, and --rce-det for a more deterministic RCE path requiring a special nginx configuration and calibrated offsets. The exploit communicates directly with nginx over raw TCP sockets and crafts HTTP requests to specific paths (/l2/, /static/a.txt, /b/abc, /b/zz). It uses heap grooming with multiple held victim connections, partial POST body spraying, and a crafted binary request body that forges nginx pool cleanup structures. The payload places the address of libc system() and an inline command string into attacker-controlled heap data so that corrupted cleanup handling results in command execution. Notable exploit capabilities include: leaking heap/libc pointers from a response body; checking for bad bytes in candidate addresses; shaping allocator state with many concurrent sockets; spraying forged cleanup objects into buffered request bodies; and triggering cleanup-pointer corruption to execute a command. The code is operational rather than framework-integrated: offsets such as LIBC_LEAK_OFFSET, SYSTEM_OFFSET, BODY_DELTA_* and PL_OFF are hardcoded and build-specific, but the exploit chain is complete and intended to achieve actual code execution in the provided lab environment.Leeyoonjoo · Disclosed Aug 12, 2026 · python · dockerfile · network · webPoC
Exposure surface

Affected products & vendors

Products and vendors Mallory has correlated with this vulnerability. Open in Mallory to drill down to specific CPE configurations and version ranges.

VendorProductType
F5Nginx Gateway Fabricapplication
F5Nginx Ingress Controllerapplication
F5Nginx Plusapplication
F5Wafapplication
FAQ

Frequently asked questions

Is CVE-2026-42533 exploited in the wild?
Yes. As of Nov 14, 2026, Mallory has reports of exploitation in the wild.
Is there a public exploit for CVE-2026-42533?
Yes. Mallory tracks 6 public exploits or proofs of concept for CVE-2026-42533, the earliest disclosed Jul 27, 2026.
Is there a patch for CVE-2026-42533?
Install a current vendor-supported release containing the fix. Initial fixed releases include NGINX Open Source 1.30.4 and 1.31.3; NGINX Plus 37.0.3.1 or R36 P7; NGINX Instance Manager 2.22.2; F5 WAF for NGINX 5.13.4; NGINX Gateway Fabric 2.6.7; and NGINX Ingress Controller 2026-lts-r4 or 5.5.3.
What products are affected by CVE-2026-42533?
F5 Nginx Plus, F5 Nginx Gateway Fabric, F5 Nginx Ingress Controller, and F5 Waf.
How severe is CVE-2026-42533?
CVE-2026-42533 has a CVSS v4 score of 9.2 (Critical) and an EPSS score of 6.3% (94th percentile) as of Nov 14, 2026.
Activity feed

Recent activity

206 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
tenable nessus pluginsNews · Nov 13, 2026Rocky Linux 9.6 [CIQ] Security Update: nginx / nginx-all-modul... | Tenable®A vulnerability affecting nginx packages on Rocky Linux 9.6 covered by CIQ LTS updates. The content does not describe its technical cause or individual impact. Nessus identifies affected packages using self-reported version information rather than testing exploitation.Read more ↗tenable nessus pluginsNews · Nov 13, 2026Unity Linux 20.1050a / 20.1060a / 20.1070a Security Update: ng... | Tenable®A vulnerability referenced by a Unity Linux security-check plugin. The supplied CVSS vectors indicate network-based exploitation with high attack complexity, no authentication or user interaction required, and high confidentiality, integrity, and availability impacts. The affected component and technical cause are not specified. Exploits and a patch are reported available.Read more ↗almalinuxNews · Nov 4, 2026Call for testing - nginx fix for "no buffer space in script copy" errors | AlmaLinux OSA buffer overrun in nginx’s script engine. The security update introduced a regression in backported AlmaLinux, CentOS Stream, and RHEL packages: nested scripts overwrite a shared buffer-end pointer, causing incorrect bounds checks and intermittent HTTP 500 responses in certain volatile-map configurations. AlmaLinux has published testing packages that preserve the CVE protection while fixing the regression without changing the ABI. The content does not specify the original vulnerability’s broader security impact.Read more ↗tenable nessus pluginsNews · Nov 2, 2026RHEL 9 : nginx (RHSA-2026:93472) | Tenable®A vulnerability in nginx allows arbitrary code execution through crafted HTTP requests. Security updates are available under RHSA-2026:93472. The multi-vulnerability plugin states that exploits are available without specifying their coverage for this individual CVE.Read more ↗
+62 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidenceEvery report linking this CVE to a named adversary.
Associated malwareMalware families linked to this CVE, with evidence and IOCs.
Detection signaturesYARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity124Community discussion across Reddit, Mastodon, and other social sources.