Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted JSON body to WAF-fronted endpoint
-
DeliveryExhaust SecArgumentsLimit with 1000 shallow scalars
-
ExploitDeeply nested tail skipped by bounded walk reaches gjson.Valid
-
ExecutionUnbounded recursion triggers fatal stack overflow
-
ImpactHost process crashes (denial of service)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Requires that the target application routes request (ProcessRequest) or response (ProcessResponse) bodies through Coraza's JSON body processor - i.e. JSON content is parsed, which is the default behavior for application/json bodies in affected versions 3.0.0-3.8.0. No authentication, no user interaction, and no non-default tuning are needed; the attack works WITHIN default SecArgumentsLimit (1000) and under the recommended SecRequestBodyLimit, so default configurations are vulnerable. The only real limiting factors are that Coraza must be inline and configured to inspect JSON bodies, and the attacker must be able to deliver a body large enough to carry the deeply nested tail (the documented repro is ~13 MB); the SecRequestBodyJsonDepthLimit/SecResponseBodyJsonDepthLimit (default 1024) does not prevent it because the nested tail is never visited by the bounded walk before gjson.Valid runs on the raw body. |
| Impact | All signals point to a genuine but availability-only (DoS) issue. The provided CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) describes remote, unauthenticated, low-complexity exploitation with no user interaction and no scope change, and impact confined entirely to availability (C:N/I:N/A:H) - consistent with CWE-674 (uncontrolled recursion) producing a fatal, unrecoverable stack overflow that terminates the host process. There is no RCE or data-exposure dimension, so this is not a confidentiality/integrity emergency, but because Coraza runs inline as a WAF, a single crafted request can crash the protected application process and simultaneously remove WAF coverage, making it a meaningful operational-availability priority rather than a purely theoretical high-CVSS issue. No EPSS score was provided in the input, so exploitation probability cannot be quantified. The CVE is NOT listed in CISA KEV and no public exploit code is indicated in the input, so exploitation status is 'no public exploit identified at time of analysis'; however, the GHSA advisory documents an exact reproduction recipe (1000 shallow scalars to exhaust SecArgumentsLimit followed by ~13,000,000 nested '[' characters in a ~13 MB body), which substantially lowers the barrier to weaponization despite the absence of published exploit code. Net assessment: patch promptly for any Coraza deployment processing JSON bodies, but treat as a DoS/availability risk, not a compromise risk. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a single crafted JSON request (or triggers a crafted JSON response) to any endpoint fronted by Coraza with the JSON body processor active. The body stays under the recommended SecRequestBodyLimit and default SecArgumentsLimit, using 1000 shallow scalars to stop the bounded flattening walk early, then a deeply nested tail that reaches the unbounded gjson.Valid call and crashes the entire host process with an uncatchable fatal stack overflow. No public exploit code is identified, but the GHSA advisory documents a precise reproduction recipe, so the attack is effectively trivial to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Unauthenticated remote denial of service in the OWASP Coraza WAF Go library (versions 3.0.0 through 3.8.0) allows any client that can deliver a JSON request or response body to crash the entire hosting process with an unrecoverable fatal stack overflow. The flaw is reachable with default configuration - the payload stays under the recommended SecRequestBodyLimit and within the default SecArgumentsLimit of 1000 - because the body processor's bounded flattening walk stops early on argument truncation and then unconditionally hands the complete raw body to gjson.Valid, which recurses once per nesting level with no depth bound and cannot be intercepted by recover(). Impact is availability only (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-674); no public exploit code identified at time of analysis and no KEV listing, though the vendor advisory documents a working repro payload of roughly 13 MB.
RemediationAI
Upgrade to Coraza v3.8.1 or later: the vendor-released patch is v3.8.1 (release https://github.com/corazawaf/coraza/releases/tag/v3.8.1), implementing the fix commit 814e1898e083d2ff2ceb644382d0da17e930f93f, which adds an iterative depth pre-scan (jsonNestingExceedsLimit) before gjson.Valid so an over-deep body returns the recursion-limit error instead of crashing the process (verified repro returns in under 50ms post-fix). This resolves the issue on both the request and response JSON paths from a single change and preserves existing syntax validation. If immediate upgrade is not possible, compensating controls are limited, because the crash occurs during parsing and cannot be caught by recover() or by switching the engine to DetectionOnly: run the Coraza-hosting process under a supervisor (systemd/Kubernetes restart policy) so a crashed worker is respawned - this preserves availability only with a brief outage window per attack burst and does not prevent the crash; cap SecRequestBodyLimit well below the ~13 MB required by the documented payload to raise the bar for triggering the deep tail - the trade-off is rejecting legitimate large JSON bodies, and it is only a size barrier, not a fix; and terminate deeply nested JSON at an upstream proxy that performs its own independent nesting/depth check before forwarding to Coraza (do not rely on SecRequestBodyJsonDepthLimit, default 1024, since the vulnerable walk never visits the nested tail). Lowering SecArgumentsLimit does not mitigate the issue - the truncation it causes is precisely the mechanism that bypasses the depth guard. Consult the advisory GHSA-6gcq-wc29-5xf2 for the authoritative fix detail.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Root cause is uncontrolled recursion (CWE-674) created by a guard-ordering interaction inside internal/bodyprocessors/json.go. readJSON runs a best-effort, bounded flattening walk (readItems) guarded by maxRecursion, an argument limit (SecArgumentsLimit, default 1000 per internal/corazawaf/waf.go:359) and a byte budget; the byte-budget and argument-count checks execute before the recursion-depth check and short-circuit the walk with truncated=true, err=nil. When the limit is consumed by shallow scalar values early in the document, the walk never descends into a deeply nested tail later in the same document, so no recursion error is produced and readJSON falls through to gjson.Valid(s) on the entire raw body. gjson v1.18.0's Valid path (validany -> validarray/validobject) recurses once per nesting level with no depth bound, so a body containing millions of nested '[' characters overflows the goroutine stack; Go raises fatal error: stack overflow, which is not a panic and cannot be caught by recover(), terminating the process. The same readJSON flow is used by both ProcessRequest and ProcessResponse, so request and response body inspection are equally affected. This is the same hazard earlier fixes addressed for straightforward deep bodies, reopened by the truncation path; SecRequestBodyJsonDepthLimit/SecResponseBodyJsonDepthLimit (default 1024) does not help because the nested tail is never visited by the bounded walk. Affected module: go/github.com/corazawaf/coraza/v3 (CPE cpe:2.3:a:corazawaf:coraza). Fixed by an iterative, non-recursive depth pre-scan (jsonNestingExceedsLimit) that runs before gjson.Valid; gjson.Valid is retained for syntax validation.
Know when Coraza gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remote unauthenticated JSON request (AV:N/PR:N/UI:N) with low complexity; the impact is a full uncatchable process crash, so A:H with no confidentiality or integrity effect.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. From 3.0.0 until 3.8.1, readJSON in internal/bodyprocessors/json.go can stop its bounded flattening walk after reaching SecArgumentsLimit or the byte budget and then call gjson.Valid on the complete raw body. An unauthenticated attacker can submit shallow values followed by an extremely deeply nested JSON tail that was not visited by the bounded walk, causing gjson.Valid to recurse without a depth bound and terminate the hosting process with an unrecoverable fatal stack overflow. The ProcessRequest and ProcessResponse JSON paths share the affected readJSON validation flow, and the payload can remain within recommended body-size and argument-count limits. This issue is fixed in version 3.8.1.
Technical POC Analysis
CWE-674 (Uncontrolled Recursion).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
OWASP Coraza WAF Go library versions 3.0.0 through 3.8.0 can be crashed through unauthenticated JSON traffic, causing a process-wide availability outage for any application that embeds it. This affects internet-facing and partner-facing services using affected versions, and with no vendor-released patch identified at time of analysis, business continuity depends on interim controls and vendor tracking. Leadership should treat this as a high-priority availability risk because the condition is reachable in default configurations and requires no credentials.
No vendor-released patch identified at time of analysis. Interim mitigations include restricting JSON body size and nesting depth at the edge/reverse proxy, disabling Coraza JSON body processing where feasible, rate-limiting or blocking unusually large/deep JSON payloads, and isolating the WAF process with automatic restart and health checks.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. Rated high severity (CVSS 7.5), th
CPU exhaustion in OWASP Coraza WAF versions 3.0.0 through 3.7.x allows a remote, unauthenticated network attacker to pin
Resource exhaustion in OWASP Coraza WAF 3.0.0 through 3.7.x lets an unauthenticated remote attacker (CVSS vector PR:N/UI
Cookie-parser confusion in OWASP Coraza WAF prior to 3.8.1 allows unauthenticated remote attackers to hide cookie-carrie
GET-side WAF rule bypass in OWASP Coraza WAF 3.0.0 through 3.7.x lets unauthenticated attackers evade signature matching
EUVD-2026-95925
GHSA-6gcq-wc29-5xf2
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB