Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect as floodsub peer over /floodsub/1.0.0
-
DeliverySend bounded frame with millions of subscription entries
-
ExploitSynchronous processRpc iteration blocks event loop
-
ExecutionUnique-topic SUBSCRIBEs leak PeerSet objects
-
ImpactCPU/memory exhaustion and OOM node unavailability
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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 that the target node runs @libp2p/floodsub (js-libp2p < 11.0.26) with the /floodsub/1.0.0 pubsub protocol enabled and accepting inbound connections from untrusted peers - the normal open peer-to-peer deployment mode. No authentication, credentials, or user interaction are needed (PR:N/UI:N), and because the subscription path bypasses message signature validation and the message-only processing queue, signature/peer-authentication defenses do not limit it. The primary limiting factor is that floodsub must actually be in use: it is a legacy pubsub protocol largely superseded by gossipsub, so nodes configured only with gossipsub or without pubsub are not affected. Persistent memory exhaustion additionally requires the attacker to send many unique-topic SUBSCRIBE entries; empty entries cause only transient CPU exhaustion without growing this.topics. |
| Impact | This is a network-reachable, unauthenticated denial-of-service flaw (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) - availability-only impact, no confidentiality or integrity exposure. The vendor CVSS vector is internally consistent with the description: a remote peer speaking the /floodsub/1.0.0 protocol needs no credentials and no user interaction, and the subscription-processing path explicitly bypasses signature validation and the message queue, so attack complexity is genuinely low. No EPSS score, KEV entry, or public POC was provided in the input, so this is best characterized as no public exploit identified at time of analysis rather than active exploitation. The signals do not conflict: a moderately-severe (7.5) but purely-availability issue in a peer-to-peer library, with a fix already shipped (11.0.26) and a detailed public GitHub Security Advisory plus PR diff, is a legitimate patch-soon item for anyone running floodsub - but it is not a drop-everything emergency absent evidence of in-the-wild abuse. The main real-world risk driver is that floodsub peers accept connections from arbitrary untrusted peers by design, so the 'unauthenticated remote' precondition is effectively always met wherever the component is enabled. |
| Exploit ScenarioDerived | A malicious peer connects to a target node over the /floodsub/1.0.0 protocol and sends a single bounded-size protobuf RPC frame that decodes into millions of empty subscription entries, which processRpc/processRpcSubOpt iterate synchronously and block the Node.js event loop, causing sustained CPU exhaustion. Alternatively the attacker sends hundreds of thousands of unique-topic SUBSCRIBE entries, permanently allocating PeerSet objects in this.topics that are never freed after peer removal, driving memory growth to out-of-memory termination. No public POC is referenced, but the GitHub advisory and fix PR (#3568) describe the mechanism in enough detail to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
Unauthenticated denial of service in @libp2p/floodsub before 11.0.26 (packaged with js-libp2p < 11.0.26) lets a remote peer exhaust CPU and memory by sending a single bounded-size RPC frame on the /floodsub/1.0.0 protocol that decodes into an unbounded number of subscription entries. The affected path (PeerStreams.attachInboundStream → processRpc/processRpcSubOpt) applies no per-frame element limits, bypasses message signature validation and the message-only processing queue, and leaks PeerSet objects in this.topics for unique-topic SUBSCRIBE entries that are never cleaned up, leading to event-loop starvation, out-of-memory termination and node unavailability; no public exploit identified at time of analysis and no KEV listing. Only nodes actually running floodsub with inbound connections from untrusted peers are exposed - the legacy protocol is largely superseded by gossipsub - but for those nodes the attacker needs no authentication, credentials or user interaction (AV:N/AC:L/PR:N/UI:N).
RemediationAI
Vendor-released patch: 11.0.26 - upgrade @libp2p/floodsub (and js-libp2p) to 11.0.26 or later, as shipped in the floodsub-v11.0.26 release; the fix lands via PR #3568 (commit fb9e8a76e9ac75924928fae4ce11d00f68320a83), details in advisory https://github.com/libp2p/js-libp2p/security/advisories/GHSA-cvfg-hcf3-ggwv. If upgrading is not immediately possible, the highest-value compensating control is to stop running floodsub entirely: configure nodes with gossipsub only, or remove/disable the /floodsub/1.0.0 protocol handler, which fully eliminates the attack surface at the cost of interoperability with floodsub-only peers on a legacy protocol already superseded by gossipsub. Where floodsub must stay enabled, restrict inbound peer admission to trusted or authenticated peers, apply strict connection and stream limits per peer, and monitor for event-loop lag, rising RSS and large numbers of empty topic entries; note these are partial mitigations because the subscription path bypasses signature validation and the message processing queue, so authenticated or allowlisted peers can still trigger the flaw. Post-upgrade, operators can additionally tune the new decodeRpcLimits option (defaults: maxSubscriptions 5000, maxMessages 5000) - lowering it tightens protection but may reject legitimate subscriptions from peers tracking many topics. The pre-patch stream byte cap (maxDataLength) is not an effective workaround because it bounds frame size, not decoded element count.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
libp2p is a modular peer-to-peer networking stack; @libp2p/floodsub is its legacy pubsub implementation speaking the /floodsub/1.0.0 protocol. Incoming RPC frames are protobuf messages decoded by the protons-runtime codec (packages/floodsub/src/message/rpc.ts) and are read through a length-prefixed stream that caps frame bytes (maxDataLength) but not element counts - protobuf packs many tiny repeated entries into very few bytes, so a small frame can decode into millions of RPC.SubOpt/Subscribe objects. This is a CWE-400 uncontrolled resource consumption flaw: processRpc and processRpcSubOpt iterate the decoded subscriptions array synchronously with no per-frame cap, blocking the event loop, and unique-topic SUBSCRIBE entries allocate PeerSet objects stored in this.topics that are not removed when the peer disconnects or the node stops. Critically, the subscription path skips the signature validation and the message-only processing queue that normally throttle pubsub traffic, so peer-authentication and message-queue defenses provide no protection. The upstream fix introduces decodeRpc.ts with DecodeRPCLimits (default maxSubscriptions 5000, maxMessages 5000), passes those limits to PeerStreams.attachInboundStream, adds this.topics.clear() on stop, evicts zero-size topic sets, and reserves the unused gossipsub-style ControlMessage field 3 in the RPC schema.
Know when Libp2P 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:N/I:N/A:H
Remote unauthenticated peer sends a single crafted frame with no user interaction (AV:N/AC:L/PR:N/UI:N); impact is availability-only event-loop/memory exhaustion (A:H, C:N/I:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
libp2p is a JavaScript implementation of the libp2p networking stack. Prior to 11.0.26, @libp2p/floodsub accepts unauthenticated RPC frames on /floodsub/1.0.0 through PeerStreams.attachInboundStream in packages/floodsub/src/peer-streams.ts without protobuf element limits, then processRpc and processRpcSubOpt in packages/floodsub/src/floodsub.ts synchronously process the subscriptions array without a per-frame cap. A single bounded-size frame can decode into millions of empty subscription entries that block the event loop, while hundreds of thousands of unique-topic SUBSCRIBE entries allocate PeerSet objects in this.topics that are not removed after peer removal or stop. Empty entries cause CPU exhaustion but do not grow this.topics; persistent memory growth requires unique topics. The subscription path bypasses message signature validation and the message-only processing queue, allowing a remote peer to cause sustained CPU denial of service, memory exhaustion, out-of-memory termination, and node unavailability. The issue is fixed in version 11.0.26.
Technical POC Analysis
CWE-400 (Uncontrolled Resource Consumption), with CWE-770 (allocation without limits) and CWE-401 (missing release of memory) as the concrete sub-mechanisms.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity flaw in the @libp2p/floodsub library, bundled with js-libp2p before 11.0.26, allows any remote peer to exhaust a node's CPU and memory with a single malformed message, with no credentials or user interaction required. Organizations running floodsub-enabled libp2p nodes - common in peer-to-peer and distributed ledger components - face unplanned outages and node unavailability, while environments already migrated to gossipsub are not exposed. Leadership should care because the exposure is limited to a legacy protocol but the consequence for affected nodes is total service loss at low attacker effort.
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.
Denial-of-service in libp2p-rendezvous ≤0.17.1 (Rust) allows a malicious rendezvous server to crash any connecting clien
Address-book poisoning in the @libp2p/peer-store component of js-libp2p (8.0.0 up to, but not including, 12.0.24) allows
go-libp2p is the Go implementation of the libp2p Networking Stack. Rated high severity (CVSS 7.5), this vulnerability is
Uncontrolled resource consumption in py-libp2p's yamux stream multiplexer allows any remote peer that completes a standa
Forged message authorship in @libp2p/gossipsub 15.0.0 through 16.0.4 lets an unauthenticated, remote attacker sign a gos
Rust Yamux prior to version 0.13.10 is vulnerable to denial of service when processing specially crafted inbound stream
Remote unauthenticated denial of service in rust-libp2p Gossipsub affects versions prior to 0.49.5 and allows any peer t
Unauthenticated remote denial of service in @libp2p/webrtc (the js-libp2p WebRTC transport) before 6.0.28 lets a single
Unbounded abort listener accumulation in js-libp2p's circuit-relay-v2 relay server allows any remote peer to exhaust mem
libp2p is a networking stack and library modularized out of The IPFS Project, and bundled separately for other tools to
go-libp2p is the offical libp2p implementation in the Go programming language. Rated high severity (CVSS 7.5), this vuln
js-libp2p is the official javascript Implementation of libp2p networking stack. Rated high severity (CVSS 7.5), this vul
EUVD-2026-81688
NVD
CVE.org
EPSS
GitHub
Exploit-DB