Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach JSON endpoint behind Coraza WAF
-
DeliveryCraft JSON with nested SQLi plus dotted decoy key
-
ExploitCoraza flattens colliding keys, decoy overwrites payload
-
ExecutionCRS inspects harmless value, passes request
-
PersistBackend parser exposes malicious nested value
-
ImpactSQL 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.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
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
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 3Unauthenticated 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
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-106902
GHSA-vmwg-gmpq-826x
NVD
CVE.org
EPSS
Exploit-DB