Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app protected by vulnerable Coraza with response inspection
-
DeliverySend request yielding deeply nested JSON response
-
ExploitTrigger unbounded recursion in ProcessResponse JSON path
-
ExecutionQuadratic parsing consumes one CPU core
-
ImpactSustain requests to exhaust CPU, denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Exploitation requires response-body inspection to be enabled (SecResponseBodyAccess On) with application/json among the inspected SecResponseBodyMimeType values, and a backend whose JSON response structure/nesting depth can be shaped by attacker input (e.g. echo or validation-error endpoints, GraphQL responses mirroring query nesting, or store-and-retrieve JSON blob APIs). The malicious nested payload must fit within the default 512 KiB ResponseBodyLimit (~87,000 nesting levels suffices for ~12s/core). Limiting factors: the request JSON path is NOT affected (it uses the configured recursion limit, default 1024), so only response processing is vulnerable; deployments with response-body access disabled, non-JSON responses, or backends that cannot be coerced into deep nesting are not exploitable; and CVSS AC:H reflects the indirect, backend-mediated nature of the trigger. |
| Impact | This is a moderate-severity availability-only flaw (CWE-674, uncontrolled recursion) best characterized as a CPU-exhaustion denial-of-service, not a confidentiality or integrity issue. The provided CVSS:3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, base 5.9) is internally consistent and credible: network-reachable and unauthenticated (PR:N) but with high attack complexity (AC:H) because the attacker cannot hit the vulnerable code path directly - they must induce the protected backend to emit deeply nested JSON that Coraza then inspects. Impact is bounded to availability (A:H) with no data exposure. A proof-of-concept Go test is published inside the GHSA advisory with measured timings (~12s/core for a 512 KiB response at ~87,000 nesting levels), so publicly available exploit code exists; however, this is NOT confirmed active exploitation - there is no CISA KEV listing in the input and no EPSS score was provided, so the real-world exploitation-probability signal is MISSING and cannot be compared against the POC signal. No SSVC decision data was supplied. Net assessment: a legitimate, patch-worthy DoS for exposed Coraza deployments with response-body JSON inspection enabled, but it is materially gated by configuration and by whether a backend's JSON response nesting is attacker-influenceable - closer to a 'real but conditional' issue than a drop-everything emergency. Note the 'Information Disclosure' input tag conflicts with the actual availability-only impact and appears mislabeled. |
| Exploit ScenarioDerived | An attacker repeatedly sends requests to an application fronted by Coraza (with SecResponseBodyAccess On and application/json in the inspected MIME types) that cause the backend to return deeply nested JSON - for example an echo/validation endpoint, a store-and-retrieve JSON blob API, or a GraphQL response whose nesting mirrors the attacker's query. Each ~512 KiB nested response forces the response-body processor into unbounded O(depth²) recursion, pinning one CPU core for roughly 12 seconds; a stream of such requests exhausts CPU and degrades or denies service. A working proof-of-concept test with measured timings is published in the GHSA-3c6w-j9xm-8h2h advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
CPU exhaustion in OWASP Coraza WAF versions 3.0.0 through 3.7.x allows a remote, unauthenticated network attacker to pin a server CPU core by causing an inspected JSON response body to be deeply nested, because the response-side JSON body processor recurses without an effective depth limit. The flaw is availability-only (CWE-674, uncontrolled recursion, CVSS 3.1 5.9 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) and is bounded by the default 512 KiB ResponseBodyLimit, which still permits roughly 87,000 nesting levels and about 12 seconds of single-core work per response. Exploitation is indirect and requires response-body inspection to be enabled (SecResponseBodyAccess On plus application/json in SecResponseBodyMimeType) and a backend whose JSON nesting depth the attacker can shape; the request-body JSON path is unaffected because it uses the configured request recursion limit. No public exploit is identified at time of analysis, and no evidence of active exploitation was provided; vendor-released patch 3.8.0 fixes the issue.
RemediationAI
Upgrade to Coraza WAF 3.8.0, which is the vendor-released patch that replaces the sentinel -1 with a real recursion budget: ProcessResponse now passes bpo.ResponseBodyRecursionLimit, a new additive field on BodyProcessorOptions, and adds the SecResponseBodyJsonDepthLimit directive with a default of 1024, mirroring the existing request-side SecRequestBodyJsonDepthLimit (see the fix commit cae3c7407e7b84372c207033de03f15f89bf351a and the release at https://github.com/corazawaf/coraza/releases/tag/v3.8.0; full details in advisory GHSA-3c6w-j9xm-8h2h). Operators who cannot upgrade immediately should disable outbound body inspection with SecResponseBodyAccess Off, or at minimum remove application/json from SecResponseBodyMimeType, accepting the trade-off that outbound JSON data-leakage and response-inspection rules stop firing for those content types; lowering ResponseBodyLimit reduces the achievable nesting depth and therefore the per-response CPU cost but does not eliminate the quadratic growth, so it is only a partial control. Because the trigger is backend-mediated, additional compensating controls include front-end or reverse-proxy response-size/depth limits on JSON produced by echo, validation-error, GraphQL, or generic store-and-retrieve endpoints, rate limiting those endpoints, and constraining upstream response nesting so attacker input cannot dictate deep structure. After upgrading, deployments whose backends legitimately emit very deeply nested JSON may need to raise SecResponseBodyJsonDepthLimit above the 1024 default, which restores exposure above the new threshold.
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
Coraza is a Go implementation of a ModSecurity-compatible WAF, and the vulnerable component is its JSON body processor at internal/bodyprocessors/json.go. ProcessResponse called readJSON(ss, ignoreJSONRecursionLimit) with the constant ignoreJSONRecursionLimit set to -1, while the depth guard in readItems only returns the 'max recursion reached while reading json object' error when maxRecursion == 0. Counting down from -1 produces -2, -3, ... and never reaches zero, so the guard was effectively dead on the response path; ProcessResponse additionally discarded its BodyProcessorOptions parameter (bound to the blank identifier), meaning callers had no way to inject a limit. The request path, by contrast, has been bounded since ADR-0030 and passes RequestBodyRecursionLimit (default 1024), which is why request JSON processing is not affected by this path. Because each nesting level re-parses the remaining document through gjson.ForEach, total work is O(depth^2) rather than O(depth): the advisory's measurements on an Intel Core Ultra 7 255H with Go 1.22.2 and gjson v1.18.0 show ~30 ms at 5,000 levels and ~12.09 s at 87,381 levels, with a log-log slope of ~2.09 across the range. This is the CWE-674 uncontrolled-recursion class applied to a per-response CPU budget; the CPE cpe:2.3:a:corazawaf:coraza confirms the Coraza project as the affected vendor product, and the provided tags labeling this as 'Information Disclosure' are not supported by the technical evidence or the assessed vector, which is availability-only.
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:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Unauthenticated and network-reachable (PR:N/AV:N) but AC:H because the attacker must indirectly induce deeply nested JSON responses and response inspection must be enabled; availability-only impact (A:H).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. From 3.0.0 until 3.8.0, ProcessResponse in internal/bodyprocessors/json.go passes the ignoreJSONRecursionLimit value of -1 to readJSON, while the recursive guard only stops at zero. A network attacker who can cause an application protected by Coraza to return deeply nested JSON can make response-body processing perform quadratic work, consuming one CPU core for seconds per response within the default ResponseBodyLimit. Request JSON processing is not affected by this specific path because it uses the configured request recursion limit, and exploitation requires response-body inspection to be enabled. This issue is fixed in version 3.8.0.
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
Unauthenticated remote denial of service in the OWASP Coraza WAF Go library (versions 3.0.0 through 3.8.0) allows any cl
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. Rated high severity (CVSS 7.5), th
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-95926
GHSA-3c6w-j9xm-8h2h
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB