Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen WebSocket connection to ws server
-
DeliverySend text frame with FIN=0
-
ExploitStream endless continuation fragments
-
ExecutionBuffers accumulate unbounded in receiver
-
ImpactNode heap exhausted, process OOM-killed
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires only that the target run a ws server (version before 8.21.1) that accepts WebSocket connections and permits fragmented data messages - the default configuration, since the pre-patch defaults for maxFragments/maxBufferedChunks were high enough to allow substantial accumulation. The concrete trigger is a data message begun with a text frame carrying FIN=0 followed by continuation frames (including empty fragments) that never complete the sequence, per the description. No authentication, no user interaction, and no special platform are needed (PR:N/UI:N/AV:N). Limiting factors: the target endpoint must be network-reachable by the attacker, and deployments that already set a low custom maxFragments, terminate incomplete/idle WebSocket sessions at a proxy, or restrict WebSocket access to authenticated internal users substantially reduce exposure. |
| Impact | This is a genuine availability risk but strictly a denial-of-service issue - the supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) with VA:H and VC/VI:N confirms a network-reachable, no-authentication, low-complexity attack that impacts only availability, consistent with the CWE-770 classification. The 8.7 CVSS 4.0 base is High, driven entirely by the high availability impact plus the trivial network preconditions. No EPSS score and no KEV listing were provided, and there is no indication of a public proof-of-concept, so despite the low exploitation barrier this should be treated as a plausible-but-not-yet-observed threat rather than an actively exploited one; the absence of EPSS data means widespread-exploitation probability cannot be quantified from the input. There is no confidentiality or integrity exposure, so this is a resource-availability priority - high value for internet-facing WebSocket services, lower urgency for internal or authenticated-only endpoints. The signals are internally consistent (network DoS, no privilege needed), so there is no CVSS-versus-description conflict to flag. |
| Exploit ScenarioDerived | An attacker opens a WebSocket connection to an internet-facing Node.js service running a pre-8.21.1 ws server, sends a text frame with FIN=0, and then streams a long series of continuation frames (including empty ones) without ever sending a final frame. Because each fragment is buffered as a separate Buffer and the count guard never trips, the server's heap grows until the Node process is killed by the out-of-memory handler; repeating this across a few connections amplifies the effect. No authentication or user interaction is required, and while no public POC is identified, the attack is straightforward to script against a raw WebSocket client. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 15, 2026
Denial of service in the ws WebSocket library for Node.js (versions before 8.21.1) allows remote unauthenticated attackers to exhaust server heap memory by opening fragmented messages that are never completed. Because the fragment guard in lib/receiver.js only fires when the fragment count reaches maxFragments, an attacker can stream continuation frames (starting with a text frame carrying FIN=0) indefinitely, and each fragment is retained as a separate Buffer with per-object overhead until the process runs out of memory. No public exploit has been identified at time of analysis, and the flaw was disclosed by VulnCheck with a vendor patch already available.
RemediationAI
Vendor-released patch: upgrade ws to version 8.21.1 or later, which counts empty fragments toward the limit and reduces the default values of the maxBufferedChunks and maxFragments options (fix commit f197ac65140920bdcecdab74bfc69c2d7858e55d; release notes at https://github.com/websockets/ws/releases/tag/8.21.1). Applications that pull ws transitively should rebuild their dependency tree (for example via npm update or a lockfile bump) to ensure the resolved ws version is 8.21.1+. If an immediate upgrade is not possible, explicitly set a conservative maxFragments (and maxBufferedChunks) value when constructing the WebSocket server so incomplete fragmented messages are rejected early - the trade-off is that legitimately large legitimately-fragmented messages may be cut off, so tune the limit to your real message sizes. As additional compensating controls, place WebSocket endpoints behind a reverse proxy or gateway that enforces per-connection message-size and idle timeouts and cap concurrent connections per client IP; the side effect is potential disruption to long-lived or high-throughput WebSocket clients. Reference the VulnCheck advisory (https://www.vulncheck.com/advisories/ws-default-maxfragments-allows-memory-exhaustion-dos) for confirmation.
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
ws is the de facto WebSocket client/server implementation for Node.js, used directly and as a transitive dependency of frameworks such as Socket.IO. The vulnerability lives in the receiver state machine (lib/receiver.js) that reassembles fragmented WebSocket data messages, a mechanism defined by RFC 6455 in which a message can be split across an initial frame with FIN=0 plus one or more continuation frames. The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling): the limit check for buffered fragments was only evaluated when the accumulated count actually reached the maxFragments threshold, and empty fragments were not counted, so a peer that sends many small or empty incomplete fragments without ever setting FIN=1 accumulates unbounded per-fragment Buffer objects. Each stored Buffer carries fixed allocation overhead, so the effective memory cost is amplified well beyond the raw payload bytes, turning modest network input into large heap growth.
Know when Ws 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:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Network-reachable, no authentication or interaction, and trivial to trigger (AV:N/AC:L/PR:N/UI:N); impact is availability-only heap exhaustion, so C:N/I:N/A:H with unchanged scope.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
ws before 8.21.1 contains a memory exhaustion vulnerability in lib/receiver.js where the fragment guard only triggers when fragment count reaches maxFragments, allowing attackers to exhaust memory by sending incomplete fragmented WebSocket messages. Attackers can send a text frame with FIN=0 followed by continuation frames without completing the sequence, causing each fragment to be stored as a separate Buffer object with significant overhead, enabling denial of service through heap exhaustion.
Executive ViewAI
The ws WebSocket library for Node.js (versions before 8.21.1) has a critical availability risk: unauthenticated attackers can remotely trigger memory exhaustion and crash affected applications. This directly impacts application reliability and user access for any service using this library. Immediate patching is essential to prevent service disruptions.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
ws is an open source WebSocket client and server library for Node.js. Rated medium severity (CVSS 5.3), this vulnerabili
Uninitialized memory disclosure in the ws WebSocket library for Node.js (versions 8.0.0 through 8.20.0) allows a connect
EUVD-2026-44729
GHSA-73jw-fp74-p77x
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB