Skip to main content

py-libp2p CVE-2026-73568

| EUVDEUVD-2026-58183 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-08-13 GitHub_M GHSA-hmj8-5xmh-5573
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Establish TCP/QUIC connection to target libp2p node
  2. Delivery
    Complete standard Noise handshake (normal peer behavior)
  3. Exploit
    Send 12-byte yamux DATA frame with length=0xFFFFFFFF
  4. Execution
    Withhold frame body bytes entirely
  5. Persist
    Victim read_exactly() suspends indefinitely
  6. Impact
    All yamux streams on connection permanently stalled

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

The victim must run py-libp2p version 0.7.0 or earlier using the default new_host() yamux configuration - no non-default setup is required on either side. The attacker must be able to reach the target's libp2p listening address and complete a standard Noise handshake, which is the normal prerequisite for any peer-to-peer communication in the libp2p ecosystem; CVSS PR:N confirms no authentication beyond this handshake is required. Exploitation is bounded to denial-of-service on the targeted yamux connection and all streams within it - it does not grant code execution or data access (CVSS C:N/I:N). Other connections on the same host process are not directly stalled by a single attack frame, though an adversary can open multiple connections to amplify impact. There is no user interaction requirement.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, score 7.5) accurately represents this vulnerability: the only prerequisite is completing the standard Noise handshake, which is the normal connection setup for any libp2p node, so attack complexity is genuinely low with no authentication barrier. No EPSS data was supplied in the input, so a numerical exploitation probability cannot be stated; however, the trivial exploit mechanics and a documented proof-of-concept in the GHSA advisory confirm this is not a high-CVSS/low-real-risk case. KEV status is not confirmed, so active exploitation in the wild cannot be asserted - the exploitation status is 'publicly available exploit code exists' based on the PoC in the advisory. The absence of a released patched version extends the exposure window, as operators must manually apply the upstream commit. The per-connection scope of the DoS (CVSS S:U) slightly limits blast radius compared to a process-level crash, but an attacker controlling multiple connections could amplify impact. The risk is meaningful for any py-libp2p node accepting inbound connections from untrusted peers.

Exploit ScenarioDerived

An attacker operates a libp2p node and initiates a standard connection to the target py-libp2p host, completing the Noise handshake normally - an operation indistinguishable from legitimate peer behavior. The attacker then writes a single 12-byte yamux DATA frame with the length field set to 0xFFFFFFFF (4,294,967,295 bytes) and withholds all body bytes. The victim's handle_incoming() loop suspends indefinitely inside read_exactly(), and every stream multiplexed over that yamux connection becomes permanently unresponsive; a proof-of-concept demonstrating this exact sequence is documented in the GHSA advisory.

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

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

Alert me

AnalysisAIv1 – Aug 13, 2026

Uncontrolled resource consumption in py-libp2p's yamux stream multiplexer allows any remote peer that completes a standard Noise handshake to permanently stall a connection using a single 12-byte frame. Affected versions 0.7.0 and earlier accept an attacker-controlled 32-bit DATA frame length before validating it against the receive window, so a frame claiming a 4 GB body with no body bytes delivered causes the sequential read loop to block indefinitely, freezing every stream on the connection. No patched release exists at time of analysis; a remediation commit is available upstream, and a proof-of-concept demonstrating the stall is documented in the GHSA advisory.

RemediationAI

No officially released patched version of py-libp2p is available at the time of this analysis; the pip package advisory confirms 'fixed in: None.' An upstream remediation commit is available at https://github.com/libp2p/py-libp2p/commit/146ea87d1a20cc7dacf684ecf7c204543be04b37 and should be applied manually or tracked for inclusion in a future tagged release. The commit introduces two controls: a flow-control guard that closes the connection immediately if a DATA frame length exceeds MAX_WINDOW_SIZE, and a configurable per-body-read timeout (default 60 seconds, overridable via the PY_YAMUX_DATA_READ_TIMEOUT environment variable) implemented with trio.fail_after(). As a compensating control where patching is not immediately feasible, operators should restrict inbound yamux connections to explicitly trusted peers using network-layer ACLs or firewall rules - note this approach trades open connectivity for availability and is incompatible with open peer-to-peer topologies. Monitoring transport-layer connections for declared frame lengths near 0xFFFFFFFF and terminating them at a protocol proxy is a further defensive option. Operators should monitor https://github.com/libp2p/py-libp2p/security/advisories/GHSA-hmj8-5xmh-5573 for a patched release.

Affected VersionsENISA

py-libp2p ≤ 0.7.0

Affected Packages

pypi libp2p no fix
euvd py_libp2p no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in pypi, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

py-libp2p (CPE: cpe:2.3:a:libp2p:py-libp2p:*:*:*:*:*:*:*:*) is the Python implementation of the libp2p modular networking stack used in peer-to-peer applications. The defect is in the yamux stream multiplexer at libp2p/stream_muxer/yamux/yamux.py lines 915-926. CWE-400 (Uncontrolled Resource Consumption) captures the root cause: handle_incoming() decodes the 32-bit length field directly from the wire frame header - with a maximum value of 4,294,967,295 - and passes it to read_exactly() before checking it against DEFAULT_WINDOW_SIZE (256 KiB) or MAX_WINDOW_SIZE, and before verifying that the referenced stream_id exists. The yamux specification (section 3.3) explicitly requires the receiver to reset a stream when the sender exceeds the receive window; py-libp2p omits this enforcement. All three comparable peer implementations (go-yamux, rust-yamux, js-libp2p yamux) enforce this constraint. The same unguarded read also appears in the SYN branch at lines 804-806. Because handle_incoming() is a single sequential async loop with no timeout around body reads, a suspended read_exactly() call halts all multiplexed streams on the connection with no exception raised.

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Network-reachable with no auth beyond standard handshake (PR:N, AC:L), no confidentiality or integrity impact, availability impact confirmed as High.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

DescriptionCVE.org

py-libp2p is the Python implementation of the libp2p networking stack. In 0.7.0 and earlier, the yamux handle_incoming() method in libp2p/stream_muxer/yamux/yamux.py reads an attacker-controlled 32-bit DATA frame length with read_exactly() before validating it against MAX_WINDOW_SIZE or checking whether stream_id exists. A peer that completes the standard Noise handshake can send a 12-byte frame declaring a 0xFFFFFFFF body and then withhold the body, causing the sequential yamux read loop used by the default new_host() configuration to block and preventing every stream on that connection from making progress. No fixed version is available as of this review.

Executive ViewAI

Why It Matters

A denial-of-service vulnerability in py-libp2p versions 0.7.0 and earlier (CVE-2026-73568) enables remote attackers to permanently freeze network connections with a single malformed frame, disrupting services that depend on this P2P communication library. Organizations using affected versions face immediate service availability risk with no vendor patch currently available. Publicly available exploit code exists, elevating exploitation risk.

Business Impact: High
Compensating Controls

Until a vendor patch is released: (1) Restrict P2P peer connections to allowlisted trusted peers using network and firewall rules; (2) Implement per-peer connection rate limiting and resource quotas in application logic; (3) Deploy enhanced monitoring for connection stalls, zero-byte frames, and sequential read loop blocking with rapid escalation procedures; (4) Evaluate applying the upstream remediation commit as a custom patch if your build and deployment process permits. Deploy vendor-released patches within 24 hours of availability.

Threat Intelligence Overview

EPSS Score
0.4%
Top 72% exploitable
Prevalence
Low
niche Python p2p library, limited enterprise production footprint
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA 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 Yes
EPSS 0.4%
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Libp2P

View all
CVE-2026-89146 HIGH POC
8.7 Sep 11

Denial-of-service in libp2p-rendezvous ≤0.17.1 (Rust) allows a malicious rendezvous server to crash any connecting clien

CVE-2026-86039 HIGH POC
8.2 Sep 17

Address-book poisoning in the @libp2p/peer-store component of js-libp2p (8.0.0 up to, but not including, 12.0.24) allows

CVE-2023-39533 HIGH POC
7.5 Aug 08

go-libp2p is the Go implementation of the libp2p Networking Stack. Rated high severity (CVSS 7.5), this vulnerability is

CVE-2026-86038 HIGH POC
7.5 Sep 17

Forged message authorship in @libp2p/gossipsub 15.0.0 through 16.0.4 lets an unauthenticated, remote attacker sign a gos

CVE-2026-32314 HIGH
8.7 Mar 13

Rust Yamux prior to version 0.13.10 is vulnerable to denial of service when processing specially crafted inbound stream

CVE-2026-95859 HIGH
8.7 Oct 16

Remote unauthenticated denial of service in rust-libp2p Gossipsub affects versions prior to 0.49.5 and allows any peer t

CVE-2026-103936 HIGH
7.5 Oct 15

Unauthenticated remote denial of service in @libp2p/webrtc (the js-libp2p WebRTC transport) before 6.0.28 lets a single

CVE-2026-86040 HIGH
7.5 Sep 17

Unauthenticated denial of service in @libp2p/floodsub before 11.0.26 (packaged with js-libp2p < 11.0.26) lets a remote p

CVE-2026-77384 HIGH
7.5 Aug 24

Unbounded abort listener accumulation in js-libp2p's circuit-relay-v2 relay server allows any remote peer to exhaust mem

CVE-2023-40583 HIGH
7.5 Aug 25

libp2p is a networking stack and library modularized out of The IPFS Project, and bundled separately for other tools to

CVE-2022-23492 HIGH
7.5 Dec 08

go-libp2p is the offical libp2p implementation in the Go programming language. Rated high severity (CVSS 7.5), this vuln

CVE-2022-23487 HIGH
7.5 Dec 07

js-libp2p is the official javascript Implementation of libp2p networking stack. Rated high severity (CVSS 7.5), this vul

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