Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft Cookie header with CTL beside '='
-
ExploitCoraza parses name/value differently than backend
-
ExecutionSecRule on REQUEST_COOKIES fails to match
-
ImpactAttacker cookie payload reaches application uninspected
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service Interpretation consistency
|
| Exploitation Conditions | Exploitation requires Coraza < 3.8.1 AND a protective SecRule scoped specifically to REQUEST_COOKIES or REQUEST_COOKIES_NAMES (a specific cookie name/value) AND a backend whose cookie parser trims boundary control characters differently from Coraza - confirmed divergent backends are PHP's $_COOKIE and Python's http.cookies (Node's cookie package and current Werkzeug 3.1.9 keep the name like Coraza, so bypass does not apply there). The attacker must place an ASCII control character (0x00-0x1F or 0x7F) directly adjacent to the '=' separator in the Cookie header. Limiting factors: the bypass only works for boundary-adjacent CTLs - interior CTLs (e.g. 'ab\vcd') are explicitly outside the advisory's remediation and are disputed among backends; success depends on knowing the backend parser's behavior and on the WAF ruleset actually keying on cookie names/values, which drives the High attack complexity. No authentication is required (PR:N per the CVSS vector). |
| Impact | This is a genuine but modest-severity WAF-bypass issue, not a high-urgency emergency. The provided CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N, base 4.0 Medium) is internally consistent with the advisory: it is remotely reachable by an unauthenticated attacker (PR:N) but carries High attack complexity (AC:H) because success depends on the specific backend cookie parser and on a SecRule being scoped to a particular cookie name/value - a conditional, not a given. The Scope:Changed / Integrity:Low combination correctly reflects that the flaw in Coraza (the security-control component) causes impact on a different component (the protected backend application) by letting attacker-controlled cookie data slip past inspection; there is no confidentiality or availability impact, consistent with a detection-bypass rather than direct compromise. No EPSS score, no CISA KEV listing, and no public exploit code are present in the input, so there is no evidence of active exploitation or weaponization - the signals point to a low-likelihood, defense-in-depth weakness rather than a mass-exploited vulnerability. One cross-signal nuance worth flagging: the input Tags label this 'Information Disclosure,' but the mechanism described (and CWE-436, Interpretation Conflict) is a parser-confusion WAF bypass, not disclosure of data to the attacker - the labeling overstates/mischaracterizes the impact class. Net priority: patch during normal maintenance, prioritizing deployments that rely on cookie-scoped SecRules in front of PHP or Python/http.cookies backends. |
| Exploit ScenarioDerived | An attacker sends an HTTP request with a Cookie header containing an ASCII control character (e.g. a vertical tab) placed immediately next to the '=' separator, such as 'a\v=\t<payload>'. Coraza (< 3.8.1) indexes the cookie under a name/value that differs from what the backend application (e.g. PHP's $_COOKIE or Python's http.cookies) actually parses, so a SecRule scoped to that cookie name or value never matches, and the malicious cookie reaches the application uninspected. No public exploit code is identified at time of analysis, and the high attack complexity means the attacker must know or probe the backend's specific cookie-parsing behavior. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Cookie-parser confusion in OWASP Coraza WAF prior to 3.8.1 allows unauthenticated remote attackers to hide cookie-carried attack payloads from SecRules that inspect REQUEST_COOKIES or REQUEST_COOKIES_NAMES, because Coraza splits a Cookie header into name/value pairs differently than the protected backend application does. The bypass applies only when a Web Application Firewall ruleset is scoped to specific cookie names or values and the backend is a parser confirmed to trim boundary control characters - PHP's $_COOKIE and Python's http.cookies - while Node's cookie package and current Werkzeug 3.1.9 split the header the same way Coraza does, so exploitation does not apply there; the CVSS vector (AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N, score 4.0) reflects that attacker-supplied data repositions the name/value boundary across a security-authority change, producing limited integrity impact with high attack complexity and no availability or confidentiality effect. There is no public exploit identified at time of analysis, and the issue is fixed in version 3.8.1; this is a modest-severity WAF-bypass condition rather than an emergency, but operators running cookie-scoped rules against PHP or Python backends should treat it as a real detection gap.
RemediationAI
Vendor-released patch: upgrade to Coraza 3.8.1, which replaces the space/tab-only net/textproto.TrimString call with a trimCTLAndSpace helper that strips the full RFC 2616 CTL range (0x00-0x1F and 0x7F) plus space from both ends of each extracted cookie name and value, as shown in the upstream commits https://github.com/corazawaf/coraza/commit/0b940e197ad9983fb3aa36e84f1f81ff985461af and https://github.com/corazawaf/coraza/commit/9f8521398d1ff023b958fad0b944cac265763866 and the release at https://github.com/corazawaf/coraza/releases/tag/v3.8.1; see the advisory https://github.com/corazawaf/coraza/security/advisories/GHSA-g4qm-m288-5cp9. Where patching cannot be scheduled immediately, the highest-value compensating control is to normalize the input before Coraza sees it: configure the front-end proxy or load balancer to reject or strip Cookie headers containing raw control octets (0x00-0x1F, 0x7F), which removes the divergence entirely but may break non-compliant clients or legitimate encoded values, so validate against production traffic before enforcing. A second option is to stop keying solely on REQUEST_COOKIES/REQUEST_COOKIES_NAMES and add rules against the raw header (for example REQUEST_HEADERS:Cookie) so detection does not depend on Coraza's parser agreeing with the backend - the trade-off is more false positives from benign formatting and a ruleset that is harder to maintain. Patching the backend framework is not a fix, since the vulnerability is Coraza's misparse; at minimum, avoid writing new cookie-name-scoped rules against PHP and Python http.cookies backends until 3.8.1 is deployed. Interior control characters such as "ab\vcd" remain disputed across backends and are outside the scope of this advisory, so the 3.8.1 fix should not be relied on to cover them.
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
The defect lives in internal/cookies/cookies.go, where Coraza's ParseCookies function normalizes each extracted cookie fragment with net/textproto.TrimString, a helper that strips only space (0x20) and horizontal tab (0x09). RFC 6265 defines a cookie name as an HTTP token and a cookie value as a cookie-octet sequence, and both grammars exclude the entire C0 control range (0x00-0x1F) plus 0x7F, so any control character adjacent to the '=' separator is invalid at the token boundary. Because Coraza trims too narrow a character set, an input such as "a\v=\t'" (vertical tab against '=') is indexed as name="a\v" with value="\t'", whereas PHP's $_COOKIE and Python's http.cookies produce name="a" with value="'". The result is a classic CWE-436 interpretation conflict: two components consuming the same byte stream disagree about message structure, and the security control sees a different view of the request than the application that ultimately acts on it. Note that Coraza's Go parsing runs on every request and is fed attacker-controlled headers, which is why the patch deliberately hand-rolls the trim loop instead of using strings.TrimFunc - the commit message documents that the indirect per-byte predicate call measured roughly five times slower on a CTL-saturated header, making the naive implementation a CPU-amplification primitive. The fix trims the full CTL-and-space range from both ends of the name and value and deliberately does not attempt to resolve interior control characters (e.g. "ab\vcd"), a case disputed among backends and explicitly outside the advisory's remediation scope; note also that the CPE entry cpe:2.3:a:corazawaf:coraza:*:*:*:*:*:*:*:* is version-unbounded, so the authoritative affected range must be taken from the Go module metadata rather than the CPE string alone.
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:C/C:N/I:L/A:N
Remote and unauthenticated (AV:N/PR:N); AC:H because success depends on backend-parser divergence and cookie-scoped rules; S:C with I:L as the WAF flaw lets tampered data reach the protected app, with no C or A impact.
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. Prior to 3.8.1, internal/cookies.ParseCookies in internal/cookies/cookies.go handles boundary ASCII control characters and control-only or empty cookie names differently from several backend cookie parsers. An unauthenticated attacker can craft a Cookie header so Coraza indexes or drops a cookie under a different name or value from the backend application, causing rules targeting REQUEST_COOKIES or REQUEST_COOKIES_NAMES to miss application-visible attacker data. Exploitation depends on the backend parser and affected rule scope, and interior control characters with inconsistent backend behavior are outside this advisory's remediation. This issue is fixed in version 3.8.1.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
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
GET-side WAF rule bypass in OWASP Coraza WAF 3.0.0 through 3.7.x lets unauthenticated attackers evade signature matching
EUVD-2026-95930
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB