Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition on adjacent network between client and SOCKS5 proxy
-
DeliveryClient initiates wss:// WebSocket connection through proxy
-
Exploithttpcore2 skips TLS upgrade due to missing wss scheme check
-
ExecutionWebSocket Upgrade handshake transmitted in cleartext
-
PersistIntercept Authorization headers, cookies, query params
-
ImpactRead or modify all WebSocket frames in transit
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V12 - Secure Communication Transport encryption
|
| Exploitation Conditions | Three concurrent conditions are required: (1) the application explicitly uses HTTPX2's Client.websocket() or AsyncClient.websocket() API (not generic HTTP requests), (2) the target URL uses the wss:// scheme, and (3) a SOCKS5 proxy is configured in the HTTPX2 client. Additionally, the attacker must occupy the adjacent network path - either controlling the SOCKS5 proxy itself, or positioned on the layer-2 segment between the client and the proxy where unencrypted traffic is visible. Exploitation is limited to HTTPX2 versions 2.6.0 through 2.9.1; applications using plain ws://, https://, or http:// are not affected. Applications routing wss:// connections through HTTP CONNECT proxies rather than SOCKS5 are also not affected. Standard https:// REST calls from the same client are unaffected regardless of proxy type. |
| Impact | The CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, score 8.1) accurately characterises the threat: an attacker must occupy the adjacent network segment on the path between the HTTPX2 client and its SOCKS5 proxy, but once there faces no complexity barrier, requires no credentials, and gains full read and write access to what should have been an encrypted channel. The AC:L rating is appropriate because no brute-force or race condition is required - the traffic simply flows in plaintext. The AV:A constraint meaningfully reduces real-world exposure compared to AV:N; exploitation requires controlling or passively monitoring a specific network hop (the proxy egress segment or the internal segment to the proxy). No EPSS score was provided in the input data, so probabilistic exploitation likelihood is not quantifiable from this dataset. KEV status is negative, and no public proof-of-concept has been published. However, the fix is a one-line change in a well-understood code path, and the vulnerability pattern (missing scheme in a TLS-upgrade guard) is easy to reproduce by anyone reading the advisory. Overall this is a genuine, exploitable MITM flaw for the narrow population of applications using wss:// over SOCKS5, but real-world impact is bounded by both the adjacent-network prerequisite and the early-adoption stage of the HTTPX2 library itself. |
| Exploit ScenarioDerived | An attacker who controls or can passively monitor the network segment between the HTTPX2 client host and its configured SOCKS5 proxy intercepts the outbound connection intended for a wss:// endpoint. Because httpcore2 skips TLS negotiation on that tunnel, the attacker receives the WebSocket Upgrade HTTP request in cleartext - including any Authorization or Cookie headers - and can relay, read, or alter all subsequent WebSocket frames. The attacker can also present their own forged WebSocket responses without triggering a certificate error, since no TLS handshake and no certificate check ever occur. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 02, 2026
HTTPX2's SOCKS5 proxy implementation omits TLS negotiation for WebSocket Secure (wss://) origins, exposing the full WebSocket session - opening handshake, query parameters, Authorization headers, cookies, and message frames - in plaintext to anyone who can observe or control the proxy path. Affected are applications using Client.websocket() or AsyncClient.websocket() in HTTPX2 versions 2.6.0 through 2.9.1 when routing through a SOCKS5 proxy. An adjacent-network attacker can passively eavesdrop on or actively modify traffic, and can impersonate the WebSocket server due to the missing certificate verification step. No public exploit code has been identified at time of analysis and this CVE does not appear in the CISA KEV catalog.
RemediationAI
Vendor-released patch: HTTPX2 2.10.0 and httpcore2 2.10.0, available at https://github.com/pydantic/httpx2/releases/tag/v2.10.0. Upgrade by running 'pip install --upgrade httpx2' which will pull the corrected httpcore2 dependency. For applications that cannot upgrade immediately, the most actionable compensating control is to avoid routing wss:// WebSocket connections through SOCKS5 proxies - either use a direct connection for WebSocket endpoints or substitute an HTTP CONNECT proxy, which does not contain the defective TLS-upgrade guard. Disabling SOCKS5 proxy configuration entirely for the affected Client instances eliminates the vulnerable code path without requiring the upgrade, though this removes proxy functionality. Note that simply switching from wss:// to ws:// is not a workaround; it removes encryption entirely and is appropriate only on fully trusted internal networks.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
HTTPX2 (cpe:2.3:a:pydantic:httpx2) is Pydantic's next-generation Python HTTP client; its transport layer, httpcore2 (cpe:2.3:a:pydantic:httpcore2), handles low-level connections. When a SOCKS5 proxy is configured, httpcore2 must perform a CONNECT tunnel and then upgrade the tunneled socket to TLS before proceeding with the application-layer handshake. The upgrade guard in both the synchronous (socks_proxy.py:handle_request) and asynchronous (socks_proxy.py:handle_async_request) code paths compared the remote origin scheme only against b'https', omitting b'wss'. Because the wss scheme triggers no TLS upgrade, the raw TCP socket is used for the WebSocket handshake and all subsequent frames, violating CWE-319 (Cleartext Transmission of Sensitive Information). The GitHub PR diff (pull/1104) confirms the single-line root cause: scheme == b'https' changed to scheme in (b'https', b'wss') in both files.
Know when Httpx2 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:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N
Adjacent-network position required to observe proxy traffic; no privileges or complexity once there; full read and write of plaintext session data.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
HTTPX2 is a next generation HTTP client for Python. Prior to 2.10.0, httpcore2 fails to start TLS in src/httpcore2/httpcore2/_sync/socks_proxy.py and src/httpcore2/httpcore2/_async/socks_proxy.py when the remote origin uses wss through a SOCKS5 proxy because the TLS upgrade condition only recognizes https. HTTPX2 exposes the flaw through Client.websocket() and AsyncClient.websocket() from 2.6.0 through 2.9.1, so the opening handshake, query parameters, Authorization headers, cookies, and subsequent frames can cross the proxy path in plaintext without certificate verification. An attacker controlling or observing that path can read or modify traffic and impersonate the WebSocket server. This issue is fixed in httpcore2 2.10.0 and HTTPX2 2.10.0.
Blast Radius
ecosystem impact- 8 pypi packages depend on httpcore2 (3 direct, 5 indirect)
- 106 pypi packages depend on httpx2 (1 direct, 105 indirect)
Ecosystem-wide dependent count for version 2.10.0 and other introduced versions.
Articles & Coverage 1
Technical POC Analysis
The flaw is in the SOCKS5 proxy connection transports of httpcore2, in src/httpcore2/httpcore2/sync/socksproxy.py and src/httpcore2/httpcore2/async/socksproxy.py (CWE-319, Cleartext Transmission of S…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
HTTPX2 Python library versions 2.6.0-2.9.1 omit TLS encryption when routing WebSocket Secure (wss://) connections through SOCKS5 proxies, exposing authentication credentials, session cookies, and message content in plaintext to network-adjacent attackers. Organizations relying on HTTPX2 for secure WebSocket communication behind SOCKS5 proxies face undetected credential theft and session hijacking risks. No public exploit code has been identified to date, but the vulnerability affects any Python application combining these two features.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Reconfigure applications to route WebSocket Secure connections directly over HTTPS instead of through SOCKS5 proxies; (2) If proxy routing is required, use HTTPS CONNECT tunneling rather than SOCKS5; (3) Implement application-layer encryption (mutual TLS, end-to-end message encryption) to protect against plaintext exposure; (4) Deploy VPN or IPsec encryption across the entire proxy path as a network-layer defense; (5) Restrict SOCKS5 proxy access to trusted network segments and enable detailed traffic logging to detect anomalies; (6) Evaluate alternative Python HTTP client libraries (e.g., aiohttp with secure proxy implementations) as temporary replacements until HTTPX2 patch is available.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Memory exhaustion via unbounded decompression in HTTPX2 (all versions before 2.12.0) allows any HTTP server the client c
Quadratic CPU exhaustion in HTTPX2's Server-Sent Events parser allows a malicious or compromised SSE endpoint to deny se
HTTP request smuggling in pydantic's HTTPX2 Python client library, all versions prior to 2.11.0, arises because Request.
CRLF injection in httpx2 (pydantic's next-generation Python HTTP client) before v2.11.0 allows manipulation of multipart
EUVD-2026-70250
GHSA-7mj9-2mp8-4m2p
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB