Skip to main content

OWASP Coraza WAF CVE-2026-107833

| EUVDEUVD-2026-95926 MEDIUM
Uncontrolled Recursion (CWE-674)
2026-10-09 GitHub_M GHSA-3c6w-j9xm-8h2h
5.9
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify app protected by vulnerable Coraza with response inspection
  2. Delivery
    Send request yielding deeply nested JSON response
  3. Exploit
    Trigger unbounded recursion in ProcessResponse JSON path
  4. Execution
    Quadratic parsing consumes one CPU core
  5. Impact
    Sustain 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

coraza 3.0.0, < 3.8.0

Affected Packages

go github.com/corazawaf/coraza/v3 fix: 3.8.0
euvd coraza_3_0_0 fix: 3.8.0

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

Vendor (GitHub_M) PRIMARY 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 5.9 MEDIUM

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).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

1
Patch available
Oct 09, 2026 - 19:02 EUVD

DescriptionCVE.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

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Low
embeddable OWASP Go WAF library, specialized Caddy/Traefik/Go deployments
Threat Intel
1
1 source
Social Media
2
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy