Skip to main content

Coraza WAF CVE-2026-114099

| EUVDEUVD-2026-106902 MEDIUM
Improper Input Validation (CWE-20)
2026-10-21 VulnCheck GHSA-vmwg-gmpq-826x
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Reach JSON endpoint behind Coraza WAF
  2. Delivery
    Craft JSON with nested SQLi plus dotted decoy key
  3. Exploit
    Coraza flattens colliding keys, decoy overwrites payload
  4. Execution
    CRS inspects harmless value, passes request
  5. Persist
    Backend parser exposes malicious nested value
  6. Impact
    SQL injection executes on backend

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
Exploitation Conditions

Exploitation requires the target application to run Coraza 3.0.0-3.8.1 with the JSON body processor active and to inspect request bodies using OWASP CRS (or equivalent rules keyed on ARGS_POST). The attacker needs no authentication or user interaction and sends a crafted JSON body containing a nested property whose literal name, when flattened with an unescaped dot, collides with a sibling dotted-key decoy, letting the later value overwrite the malicious one in Coraza's map. The critical LIMITING factor is that this only bypasses WAF detection - real impact depends on the protected backend having an actual injectable sink (e.g. SQL injection) for the hidden payload; applications without such a downstream vulnerability lose detection but suffer no direct compromise. It also requires the backend JSON parser to preserve both distinct properties (standard Go/most parsers do).

Impact

This is a WAF-inspection bypass in Coraza (the OWASP Go WAF engine), not a direct code-execution flaw, and the signals are internally consistent toward a moderate-but-real priority. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) scoring 6.9 correctly reflects remote, unauthenticated, low-complexity reachability with no special attack requirements; impact is limited to integrity (VI:L/SI:L, VC/VA/SC/SA:N) because the bug does not itself compromise data - it suppresses detection so that a separately-exploitable backend payload (e.g. SQL injection) slips past OWASP CRS. No EPSS score, CISA KEV entry, or standalone exploit-tool signal was provided in the input, so the 6.9 is a severity estimate rather than evidence of mass exploitation. However, the GHSA advisory supplies a concrete control-pair proof-of-concept JSON that demonstrably turns a CRS rule 949110 block into a pass, so working exploit knowledge is effectively public. The practical risk is conditional: it only matters where Coraza fronts a backend that is itself injectable, so treat it as a real defense-in-depth regression (your WAF stops protecting) rather than a standalone critical. EPSS is absent, not low - do not read its omission as a low-exploitation signal; VulnCheck (the reporter) is a credible exploitation-intelligence source.

Exploit ScenarioDerived

An unauthenticated attacker sends a JSON POST to an application protected by Coraza with the OWASP Core Rule Set, placing a SQL-injection payload in a nested property (account.role) and appending a sibling literal-dotted decoy property 'account.role' with a benign value. Coraza flattens both into the same ARGS_POST:json.account.role variable and the decoy overwrites the malicious value, so CRS inspects only the harmless string, while the Go backend's standard JSON parser still receives and processes the live injection. A proof-of-concept demonstrating exactly this CRS v4.25 bypass is published in the GHSA advisory.

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

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

Alert me

AnalysisAIv1 – Oct 21, 2026

JSON body inspection bypass in Coraza 3.0.0 through 3.8.1 lets unauthenticated remote attackers hide SQL-injection payloads from OWASP CRS rules while the backend still receives and processes them. The flaw is in Coraza's JSON body processor, which flattens nested objects into dot-separated ARGS_POST names without escaping dots that appear literally in property names, so a decoy sibling key such as "account.role" overwrites the flattened entry for the nested "account.role" value inside Coraza's map while standard backend JSON parsers keep both properties intact. Real-world impact is conditional: the bypass only matters where the protected application has an injectable downstream sink, though the vendor advisory demonstrates the evasion working against CRS v4.25 rule 949110; no public exploit code was identified and there is no KEV/active-exploitation signal, and independent assessment rates the direct risk as integrity-only (CVSS 3.1 5.3, C:N/I:L/A:N) rather than as code execution.

RemediationAI

Vendor-released patch: upgrade to Coraza 3.8.1, which contains the upstream fixes in commits 52af139cab5ad10c5cb0152a161063b523907bdf and 5f577a548aeb9ca836122df4258f93ef6cfab38a and addresses the unescaped-dot flattening in internal/bodyprocessors/json.go; confirm the new module version is pinned in go.mod and rebuilt, since dependency pinning is the only reliable fix. If immediate upgrade is not possible, compensating controls include disabling the JSON body processor (or request-body inspection entirely) for JSON endpoints - which removes the differential but also blinds the WAF to JSON-borne payloads, so pair it with strict schema validation at the application layer; adding a custom rule that inspects the raw REQUEST_BODY for dotted-key/duplicate-key patterns or nested-vs-dotted collisions - effective but prone to false positives and requiring recursion into JSON that CRS does not natively do; and rejecting or normalizing JSON bodies containing keys with literal dots at the reverse proxy, with the trade-off that legitimate APIs using dotted field names will break. Whatever the mitigation, the hidden payload only causes harm if the backend has an actual SQL-injection sink, so remediation must also include parameterized queries or equivalent fixes in the protected application. Advisory reference: https://github.com/corazawaf/coraza/security/advisories/GHSA-5gj4-9gm7-2fx2.

Affected VersionsENISA

coraza 3.0.0 <3.8.1

Affected Packages

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

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 4 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 an open-source Go WAF engine that implements ModSecurity/OWASP CRS semantics. Its JSON body processor (internal/bodyprocessors/json.go) walks the parsed document with gjson and builds a single map[string]string in which every scalar is keyed by a path such as json.account.role; each object level appends a literal '.' plus the raw, unescaped property name before storing res[string(objKey)] = val. Because literal dots inside user-controlled key names are never escaped or otherwise disambiguated, two structurally distinct JSON properties - a nested {"account":{"role":...}} and a top-level "account.role" - collapse onto the same Coraza variable ARGS_POST:json.account.role, and last-write-wins. This is CWE-20 (improper input validation): ambiguous key canonicalization in a security control rather than a memory-safety or injection flaw in Coraza itself. The consequence is a parsing differential between the WAF and the application: Go's encoding/json and most standard parsers preserve both properties, so the backend resolves account.role to the malicious nested value while CRS rules evaluating ARGS_POST see only the harmless decoy. Exploitation prerequisites are specific - Coraza 3.0.0-3.8.1 must be deployed with the JSON body processor active and inspecting request bodies via OWASP CRS or equivalent rules keyed on ARGS_POST, the attacker must be able to submit JSON with both a nested property and a dotted sibling key, and the backend must preserve duplicate-by-flattening keys.

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 (VulnCheck) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:L/SA:N
vuln.today AI 5.3 MEDIUM

Remote unauthenticated JSON request with no interaction (AV:N/AC:L/PR:N/UI:N); only integrity of WAF inspection is degraded (I:L), with no confidentiality or availability impact and no scope change in the engine itself.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
Low
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Oct 21, 2026 - 02:01 EUVD

DescriptionCVE.org

Coraza from 3.0.0 before 3.8.1 has a JSON body processor that flattens nested properties into dot-separated ARGS_POST names without escaping literal dots, so distinct properties collide. Unauthenticated attackers can add a later dotted property such as account.role that overwrites a malicious nested value, hiding SQL injection payloads from OWASP CRS rules while backends still receive them.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Medium
OWASP Go WAF engine embedded in Caddy/Envoy proxies, moderate cloud-native adoption
Data Quality
5 sources
Confidence: Medium

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.2%
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· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

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

Attack Technique

SQL injection exploits the way applications construct database queries by mixing user input directly into SQL statements.

Related Vulnerabilities in Coraza WAF Request Body Inspection Bypasses

View all 3

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