Skip to main content

CivetWeb CVE-2026-29035

| EUVDEUVD-2026-56944 HIGH
Out-of-bounds Write (CWE-787)
2026-08-11 VulnCheck GHSA-xvrx-cw3m-h23c
8.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Identify exposed CivetWeb WebSocket endpoint
  2. Delivery
    Send HTTP upgrade request advertising permessage-deflate extension
  3. Exploit
    Confirm server accepts extension (dual build flags present)
  4. Install
    Send crafted RSV1-flagged compressed WebSocket frame
  5. C2
    Trigger 4-byte out-of-bounds zlib trailer write
  6. Execute
    Corrupt adjacent heap metadata
  7. Impact
    Achieve 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

civetweb 0 ≤4a4f0c95

Affected Packages

euvd civetweb no fix

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

Vendor (VulnCheck) PRIMARY 8.3 HIGH
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
vuln.today AI 6.5 MEDIUM

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Red Hat 7.5 HIGH

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.5%
Top 62% exploitable
Prevalence
Low
embeddable C library used primarily in embedded and IoT devices
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy