Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Mongoose behind CL-preferring proxy
-
DeliverySend request with both CL and TE:chunked
-
ExploitProxy and server disagree on boundary
-
ExecutionSmuggle second request into next connection
-
ImpactAccess or modify another user's resources
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Exploitation requires that the vulnerable Mongoose instance (pre-7.22) sits behind a reverse proxy or load balancer that resolves request length using Content-Length while Mongoose prioritizes Transfer-Encoding: chunked - this interpretation mismatch IS the required condition. The attacker crafts a request containing both Content-Length and Transfer-Encoding: chunked headers. No authentication is required (CVSS PR:N) and no user interaction is needed (UI:N). The key limiting factor: a direct-to-Mongoose deployment with no fronting proxy, or a proxy that already rejects/normalizes dual-header requests, is not exploitable via this desync - so realistic risk hinges on the actual front-end topology, not merely on running a vulnerable Mongoose version. |
| Impact | The vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, 9.1) presents this as a network-reachable, unauthenticated, low-complexity issue with high confidentiality and integrity impact and no availability impact - consistent with smuggling that reads/alters other users' requests but does not crash the service. One important caveat: exploitation is not truly condition-free. The desync only manifests when Mongoose is deployed behind a reverse proxy whose Content-Length/Transfer-Encoding interpretation differs from Mongoose's chunked preference; a direct-to-Mongoose deployment with no fronting proxy is not smuggleable this way. That real-world prerequisite arguably warrants higher attack complexity than AC:L suggests. No EPSS score, KEV listing, or POC was provided, so exploitation probability cannot be quantified from the input; treat this as a credible, patch-worthy issue but prioritize it according to whether affected devices actually sit behind a CL-preferring proxy. Signals are broadly consistent (high CVSS, confirmed vendor patch); the main uncertainty is deployment-topology dependence, not conflicting data. |
| Exploit ScenarioDerived | An attacker sends a single HTTP request to a Mongoose-backed application fronted by a Content-Length-preferring reverse proxy, including both a Content-Length header and Transfer-Encoding: chunked. The proxy forwards what it considers one request while Mongoose parses the chunked body and treats trailing bytes as the start of a second, smuggled request, which is then attributed to another user's connection - allowing the attacker to poison responses, hijack requests, or access/modify resources in another user's context. No public exploit code is identified at time of analysis, but the CL.TE technique is well-documented and low-complexity. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 20, 2026
HTTP request smuggling (CL.TE desynchronization) in Cesanta Mongoose embedded web server before 7.22 lets a remote unauthenticated attacker craft a request bearing both Content-Length and Transfer-Encoding: chunked headers. Because mg_http_parse()/http_cb() accept both and prioritize chunked encoding while a front-end reverse proxy that prefers Content-Length draws a different request boundary, an attacker can smuggle a second request that reads or modifies resources belonging to another user's context. No public exploit is identified at time of analysis; the issue is fixed in 7.22 which rejects requests containing both headers.
RemediationAI
Upgrade to Mongoose 7.22, which is the vendor-released patch (fixed via PR #3611 / commit a9df523f76f43a38bd53b4232b9cfd4c16869e71, tagged release https://github.com/cesanta/mongoose/releases/tag/7.22); the fix makes mg_http_parse() reject any request carrying both Content-Length and Transfer-Encoding. For embedded/firmware deployments where recompiling and reflashing is not immediately possible, the practical compensating control is at the fronting proxy: configure the reverse proxy to normalize or reject ambiguous requests that contain both Content-Length and Transfer-Encoding headers (many proxies can be set to strip Transfer-Encoding or return 400 on such messages), which closes the desync without touching Mongoose but requires the proxy to support that policy. Where feasible, also disable chunked request-body handling or restrict which clients can reach the server. Review the advisory GHSA-5wfq-r6mr-wqp6 for vendor guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Mongoose is a small C embedded web server and networking library (cpe:2.3:a:cesanta:mongoose) widely embedded in IoT and firmware. The flaw is CWE-444 (Inconsistent Interpretation of HTTP Requests). In src/http.c the cl_count and te_count logic tolerated a message that specified both a Content-Length and a chunked Transfer-Encoding, resolving the body length via chunked encoding. RFC 7230 requires that when both are present the Transfer-Encoding wins and, in practice, such ambiguous messages should be rejected. When Mongoose sits behind a reverse proxy that instead honors Content-Length, the two components disagree on where one request ends and the next begins - the classic CL.TE desync primitive underpinning request smuggling. The upstream fix (mongoose.c) makes mg_http_parse() return -1 when both Content-Length and Transfer-Encoding headers are present.
Know when Mongoose 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:L/PR:N/UI:N/S:U/C:H/I:H/A:N
Network and unauthenticated (AV:N/PR:N), but exploitation depends on a specific CL-preferring front-end proxy topology, so AC:H rather than AC:L; smuggling reads/modifies other users' requests giving C:H/I:H, no availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Mongoose is an embedded web server and network library. Priro to version 7.22, a remote unauthenticated attacker can send an HTTP request containing both Content-Length and Transfer-Encoding: chunked. The cl_count and te_count checks in the mg_http_parse() and http_cb() paths in src/http.c accept both headers and prioritize chunked encoding, while a Content-Length-preferring reverse proxy can use a different request boundary. This CL.TE desynchronization can inject requests that access or modify resources in another user context. This issue is fixed in version 7.22.
Executive ViewAI
Cesanta Mongoose embedded web server versions prior to 7.22 contain an HTTP request smuggling vulnerability (CVE-2026-73257) that enables unauthenticated attackers to bypass authentication boundaries and access or modify resources belonging to other users. Organizations deploying vulnerable Mongoose versions face direct risk to data confidentiality and integrity. Vendor patch is immediately available, requiring urgent deployment across all affected deployments.
Apply vendor patch.
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
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Mongoose ODM for Node.js before version 8.9.5 contains a search injection vulnerability when using $where filters with p
An exploitable stack buffer overflow vulnerability exists in the MQTT packet parsing functionality of Cesanta Mongoose 6
An exploitable use-after-free vulnerability exists in the HTTP server implementation of Cesanta Mongoose 6.8. Rated crit
An exploitable memory corruption vulnerability exists in the Websocket protocol implementation of Cesanta Mongoose 6.8.
An exploitable memory corruption vulnerability exists in the Websocket protocol implementation of Cesanta Mongoose 6.8.
Prototype Pollution in GitHub repository automattic/mongoose prior to 7.3.4. Rated critical severity (CVSS 9.8), this vu
Prototype Pollution in GitHub repository automattic/mongoose prior to 6.4.6. Rated critical severity (CVSS 9.8), this vu
An integer overflow in parse_mqtt in mongoose.c in Cesanta Mongoose 6.16 allows an attacker to achieve remote DoS (infin
Mongoose before 8.8.3 can improperly use $where in match, leading to search injection. Rated critical severity (CVSS 9.1
The mg_tls_init function in Cesanta Mongoose HTTPS server 7.0 (compiled with OpenSSL support) is vulnerable to remote OO
The mg_tls_init function in Cesanta Mongoose HTTPS server 7.0 and 6.7-6.18 (compiled with mbedTLS support) is vulnerable
The mg_http_serve_file function in Cesanta Mongoose HTTP server 7.0 is vulnerable to remote OOB write attack via connect
EUVD-2026-63492
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB