Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft multipart HTTP upload request
-
ExploitSet decoy filename plus filename*=iso-8859-1''shell.php
-
ExecutionCoraza FILES rules evaluate only decoy name
-
ImpactDangerous file reaches filename*-honoring 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 three concrete conditions. First, the target must be running Coraza < 3.8.1 configured with FILES / FILES_SIZES-based rules (e.g., CRS file-upload restrictions) to inspect or block upload filenames - if no filename-based rules are in use, there is nothing to bypass. Second, the attacker supplies a Content-Disposition header with a non-utf-8/us-ascii extended parameter, specifically filename*=iso-8859-1''shell.php (optionally with a benign plain 'filename' decoy), exploiting that Go's mime.ParseMediaType silently discards such filename* values. Third - the key limiting factor - the downstream backend application must itself honor the RFC 5987 filename* parameter so that the real (malicious) filename is what actually gets used server-side; backends that only read plain 'filename' do not receive the dangerous name. A secondary variant (filename* alone, no plain filename) causes Coraza to not recognize the part as a file at all, routing it into ARGS and skipping FILES inspection entirely. No authentication is required (PR:N). The practical ceiling on risk is the dependence on backend filename* handling, which is why CVSS rates impact as low. |
| Impact | This is a defense-in-depth bypass, not a direct code-execution flaw, and the signals point to a genuine-but-moderate priority rather than an emergency. The vendor-assigned CVSS:4.0 base score is 6.3 (Medium): AV:N and PR:N/UI:N make it remotely reachable by unauthenticated attackers, but AC:H and AT:P (a specific attack requirement) correctly reflect that successful abuse depends on conditions outside the attacker's control - namely a backend that actually honors the RFC 5987 filename* parameter and a Coraza deployment relying on FILES-based rules for upload filtering. The declared impact is integrity-only and low (VI:L/SI:L, with VC:N/VA:N), consistent with a WAF rule bypass that weakens a security control rather than directly compromising data. No EPSS score is provided in the input, so exploitation probability cannot be quantified. There is no CISA KEV listing and no public exploit code identified in the provided data, so exploitation status is: no public exploit identified at time of analysis. The flaw was reported by VulnCheck, a credible source, and the GHSA advisory documents verified behavior, so the technical validity is high even though real-world exploitation is unproven. Note the tag 'Information Disclosure' conflicts with the CVSS vector (VC:N = no confidentiality impact); the actual effect is an integrity-side control bypass, so defenders should not treat this as a data-leak issue. |
| Exploit ScenarioDerived | An unauthenticated attacker submits a multipart/form-data file upload to an application fronted by Coraza, supplying a benign decoy 'filename="safe.jpg"' alongside 'filename*=iso-8859-1''shell.php'. Because Go's mime.ParseMediaType silently drops the non-utf-8/us-ascii filename* value, Coraza's FILES rules evaluate only the decoy name and allow the request, while a backend that honors filename* writes shell.php. No public exploit code is identified, but the GHSA advisory documents the exact header constructions that reproduce the bypass. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Coraza WAF before 3.8.1 can be induced to record a decoy multipart filename for FILES-based inspection while a downstream application receives a different, attacker-chosen name, allowing upload-name restrictions to be bypassed when the backend honors RFC 5987 filename* parameters. The root cause is Go's mime.ParseMediaType, which silently discards filename* values whose charset is not us-ascii or utf-8, so a header such as filename*=iso-8859-1''shell.php is either masked by a benign plain filename or, when filename* appears alone, causes the part not to be classified as a file upload at all. Exploitation is unauthenticated but requires both FILES/FILES_SIZES-based Coraza rules and a backend that itself parses filename*, and no public exploit identified at time of analysis.
RemediationAI
Upgrade to Coraza 3.8.1, the vendor-released patch (Go module go/github.com/corazawaf/coraza/v3 fixed in 3.8.1; upstream commits 5427c50 and b2a9264), following GHSA-3wr7-993q-jrff. If an immediate upgrade is not possible, add an edge or reverse-proxy rule in front of Coraza that rejects or normalizes multipart Content-Disposition headers containing filename* with any charset other than us-ascii or utf-8; the trade-off is possible false positives for legitimate RFC 5987 clients. Alternatively, change the backend so uploaded filenames are generated server-side and filename* is ignored, which removes the exploitation precondition but requires application work. Disabling FILES/FILES_SIZES-based rules stops the bypass from mattering but also removes upload-name enforcement, so it is only a stopgap; ensure the backend sanitizes and canonicalizes uploaded filenames independently of Coraza.
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 web application firewall written in Go, typically deployed as middleware or a reverse-proxy filter in front of PHP and other web applications. Its multipart body processor parses Content-Disposition with Go's mime.ParseMediaType, whose RFC 6266/5987 extended-parameter decoder (decode2231Enc) only accepts charset tokens us-ascii and utf-8; other charsets, including iso-8859-1, which RFC 5987 explicitly permits, cause the decoder to return false and the stdlib silently leaves the plain filename parameter untouched with no error or partial-parse signal. Because RFC 7578 §4.2 and RFC 6266 make filename* authoritative when both parameters are present, Coraza's FILES and FILES_SIZES collections can hold a decoy plain filename (for example safe.jpg) while a filename*-honoring backend uses shell.php; when filename* is supplied alone, the part is not recognized as a file upload and is routed into ordinary argument collections instead, skipping FILES inspection entirely. The flaw maps to CWE-20 (Improper Input Validation): an unsupported parameter encoding is accepted without normalization or rejection, producing a parser differential between the WAF and the backend. MULTIPART_FILENAME is declared but not populated by any code path in the affected versions and is not affected.
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:H/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:L/SA:N
Remote unauthenticated request (AV:N/PR:N/UI:N); AC:H because success depends on backend honoring filename*; S:C as the bypass affects the protected backend; integrity-only low impact, no confidentiality or availability effect.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Coraza before 3.8.1 extracts multipart upload filenames with Go's mime.ParseMediaType, which silently ignores RFC 5987 filename* parameters whose charset is not utf-8 or us-ascii. Unauthenticated attackers can send a decoy filename with filename*=iso-8859-1''shell.php, or filename* alone, so FILES-based rules never see the real name, letting dangerous uploads reach backends that honor filename*.
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.
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-106904
GHSA-7xj5-pmcw-rwmp
NVD
CVE.org
EPSS
Exploit-DB