Skip to main content

OWASP Coraza WAF EUVDEUVD-2026-95925

| CVE-2026-107826 HIGH
Uncontrolled Recursion (CWE-674)
2026-10-09 GitHub_M GHSA-6gcq-wc29-5xf2
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Send crafted JSON body to WAF-fronted endpoint
  2. Delivery
    Exhaust SecArgumentsLimit with 1000 shallow scalars
  3. Exploit
    Deeply nested tail skipped by bounded walk reaches gjson.Valid
  4. Execution
    Unbounded recursion triggers fatal stack overflow
  5. Impact
    Host 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

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

Alert me

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

coraza 3.0.0, < 3.8.1

Affected Packages

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

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

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

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/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
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 09, 2026 - 19:02 EUVD
CVE Published
Oct 09, 2026 - 17:33 cve.org
HIGH 7.5

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.5%
Top 62% exploitable
Prevalence
Low
niche open-source Go WAF library, limited production footprint
Threat Intel
1
1 sources
Social Media
3
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 HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

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.

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