Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconIdentify exposed CivetWeb WebSocket endpoint
-
DeliverySend HTTP upgrade request advertising permessage-deflate extension
-
ExploitConfirm server accepts extension (dual build flags present)
-
InstallSend crafted RSV1-flagged compressed WebSocket frame
-
C2Trigger 4-byte out-of-bounds zlib trailer write
-
ExecuteCorrupt adjacent heap metadata
-
ImpactAchieve DoS crash or exploit heap for code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires CivetWeb to be compiled with BOTH the USE_ZLIB preprocessor flag (enabling zlib decompression) AND the MG_EXPERIMENTAL_INTERFACES preprocessor flag (enabling experimental WebSocket extension negotiation including permessage-deflate); if either flag is absent at build time, the vulnerable code path is unreachable and exploitation is impossible regardless of network access. Given the CVSS 4.0 vector (PR:N, UI:N), no authentication is required and no user interaction is needed once a WebSocket connection can be established. The permessage-deflate extension must be successfully negotiated during the initial HTTP upgrade handshake, which requires the server to advertise support for it - a condition satisfied only under the above build configuration. Limiting factors are: the non-default dual compile-time flag requirement (MG_EXPERIMENTAL_INTERFACES by name signals experimental/non-production status), and the AC:H rating reflecting the specific build prerequisite. There is no platform, OS, or deployment-topology restriction beyond the build flags. |
| Impact | The CVSS 4.0 score of 8.3 (AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H) correctly captures the tension between unauthenticated network reachability (AV:N, PR:N, UI:N - no authentication barrier once the endpoint is exposed) and the high attack complexity (AC:H) imposed by the dual compile-time flag prerequisite. In practice, the exploitable population is a strict subset of CivetWeb deployments: only those explicitly compiled with both USE_ZLIB and MG_EXPERIMENTAL_INTERFACES, the latter flag's name explicitly signalling non-production readiness. Real-world risk is therefore medium for the general CivetWeb ecosystem but high for any affected deployment (e.g., embedded IoT firmware builds that enable compression). EPSS data was not provided, preventing quantitative exploitation-probability assessment. CivetWeb is not listed in CISA KEV, and no confirmed public exploit exists at time of analysis; the RCE tag from VulnCheck is a theoretical impact classification based on the heap corruption primitive, not a confirmed working exploit. DoS via crash is the more certain outcome. No conflicting signals exist between the CVSS vector and the description - both consistently require specific build configuration, making this a real priority only for deployments matching that configuration. |
| Exploit ScenarioDerived | An attacker identifies a network-accessible WebSocket endpoint served by a CivetWeb binary compiled with USE_ZLIB and MG_EXPERIMENTAL_INTERFACES, then sends a WebSocket upgrade request advertising the permessage-deflate extension; if the server accepts (confirming the vulnerable build), the attacker sends a crafted compressed frame with the RSV1 bit set, causing read_websocket() to write a 4-byte zlib sync trailer four bytes past the end of the allocated heap buffer. Depending on the allocator and memory layout at the time of the write, this corrupts adjacent heap metadata and causes an immediate server crash (DoS) or, under controlled conditions, may enable an attacker to manipulate heap structure for potential code execution - though no public exploit demonstrating RCE has been confirmed. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 11, 2026
Heap and stack buffer overflow in CivetWeb's read_websocket() function (through commit 4a4f0c95) allows unauthenticated remote attackers to corrupt memory by sending crafted compressed WebSocket frames, but only against instances compiled with both USE_ZLIB and MG_EXPERIMENTAL_INTERFACES build flags. Attackers negotiate permessage-deflate during the WebSocket handshake and send an RSV1-flagged frame that triggers a 4-byte zlib sync trailer write past the allocated buffer boundary, corrupting heap metadata and enabling denial of service or potential code execution (per VulnCheck tagging). No public exploit code is confirmed and this CVE does not appear in CISA KEV at time of analysis, but the deterministic 4-byte overwrite primitive is a credible research target; the non-default build configuration substantially limits the real-world exploitable population.
RemediationAI
No vendor-released patched version is confirmed from the available data; the fix status should be monitored at the upstream repository https://github.com/civetweb/civetweb and via VulnCheck's advisory at https://www.vulncheck.com/advisories/civetweb-heap-stack-buffer-overflow-via-websocket-permessage-deflate-decompression. The most effective immediate compensating control is to rebuild CivetWeb without the MG_EXPERIMENTAL_INTERFACES compile-time flag, which disables the experimental WebSocket compression negotiation path entirely and removes exploitability without requiring any network-level changes; the trade-off is loss of permessage-deflate support, which reduces bandwidth efficiency for WebSocket traffic. Alternatively, removing USE_ZLIB at build time achieves the same result by eliminating the zlib code path. If neither recompilation is feasible, restrict network access to the WebSocket endpoint via firewall ACLs or reverse proxy access controls to limit exposure to trusted clients only, accepting that this does not eliminate the underlying flaw. Do not deploy CivetWeb builds with both flags enabled in production-facing or internet-exposed environments until a patch is released.
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
CivetWeb is a lightweight, embeddable C web server and WebSocket library (CPE: cpe:2.3:a:civetweb:civetweb:*:*:*:*:*:*:*:*) widely used in embedded systems, IoT firmware, and desktop applications as a self-contained HTTP/WebSocket backend. The root cause is CWE-787 (Out-of-Bounds Write) in the read_websocket() decompression path: when the permessage-deflate WebSocket extension is negotiated, zlib decompression requires appending a 4-byte sync flush trailer (0x00 0x00 0xFF 0xFF) to the compressed payload before inflating it, but the allocated receive buffer does not reserve space for this suffix. The write lands in adjacent heap or stack memory, corrupting allocator metadata. This code path is conditionally compiled and is only reachable when both USE_ZLIB (enabling zlib compression support) and MG_EXPERIMENTAL_INTERFACES (enabling experimental WebSocket extension negotiation, including permessage-deflate) are defined at build time. All CivetWeb commits up to and including 4a4f0c95 are affected; no patched release tag has been identified from available data.
Know when Civetweb 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:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Network vector (WebSocket over network), high complexity (non-default dual build flags required), no auth needed; availability high (crash), integrity low (heap metadata corruption), no confidentiality impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
CivetWeb (commit 4a4f0c95) contains a heap and stack buffer overflow vulnerability in the read_websocket() function that allows unauthenticated remote attackers to corrupt memory by sending compressed WebSocket frames when both USE_ZLIB and MG_EXPERIMENTAL_INTERFACES are defined. Attackers can negotiate permessage-deflate during the WebSocket handshake and send a crafted frame with the RSV1 bit set, causing the server to write a 4-byte zlib sync trailer out-of-bounds past the allocated buffer, leading to heap metadata corruption, denial of service, or potential code execution.
Executive ViewAI
CivetWeb instances compiled with the non-default USE_ZLIB and MG_EXPERIMENTAL_INTERFACES flags are vulnerable to remote unauthenticated heap/stack buffer overflow attacks via crafted WebSocket frames, potentially enabling denial of service or code execution. Organizations deploying CivetWeb with these build configurations require immediate inventory and remediation to prevent exploitation of this actively-exploitable memory corruption vulnerability.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) disable permessage-deflate compression during WebSocket handshake negotiation, (2) implement strict validation and sanitization of compressed WebSocket frames prior to decompression, (3) restrict WebSocket endpoint access via network controls or additional authentication layers, or (4) rebuild CivetWeb without USE_ZLIB and MG_EXPERIMENTAL_INTERFACES flags if operationally feasible.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Buffer Overflow in the URI parser of CivetWeb 1.14 through 1.16 (latest) allows a remote attacker to achieve remote code
Local privilege escalation in CivetWeb v1.16 service allows authenticated users to execute arbitrary code with SYSTEM pr
A flaw was found in the way civetweb frontend was handling requests for ceph RGW server with SSL enabled. Rated high sev
Out-of-bounds Read in the send_ssi_file function in civetweb.c in CivetWeb through 1.10 allows attackers to cause a Deni
EUVD-2026-56944
GHSA-xvrx-cw3m-h23c
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB