Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeploy malicious CCIP Read contract
-
DeliveryVictim backend calls contract via .call()
-
ExploitReturn OffchainLookup with ::ffff: mapped internal IP
-
Executionweb3.py fetches loopback/metadata endpoint
-
ImpactExfiltrate cloud credentials or probe internal services
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires ALL of: (1) a web3.py version in the affected range with CCIP Read enabled - this is ON by default (global_ccip_read_enabled=True), so no opt-in is needed; (2) the application performing .call()/eth_call against an attacker-controlled or otherwise untrusted ERC-3668/OffchainLookup contract address; and (3) the attacker returning an OffchainLookup URL whose host is an IPv4-mapped IPv6 address (e.g. ::ffff:127.0.0.1, ::ffff:169.254.169.254) or an AAAA record, which _check_ip_blocked() fails to unwrap and therefore does not match against loopback/RFC1918/link-local blocklists. LIMITING FACTORS: per CVSS AC:H/AT:P, the attacker must specifically craft the mapped-address bypass, and the deployment must query untrusted contracts (pure read-only use against trusted contracts is not exposed); impact is partial (information disclosure / internal request forgery, VC:L/VI:L), not full host compromise. Primarily a server-side (backend, indexer, bot, API) risk - not a concern for isolated client wallets querying only trusted contracts. |
| Impact | This is a genuine but moderate-priority issue, best characterized as a CVSS-medium flaw rather than an urgent emergency. The vendor-provided CVSS 4.0 vector (6.3, medium) rates it AV:N but with AC:H and AT:P, signaling that exploitation is network-reachable yet depends on specific, non-trivial attack requirements (crafting IPv4-mapped IPv6 / AAAA records to slip past _check_ip_blocked) and on the victim application calling untrusted contracts. CISA SSVC reinforces this: Exploitation=poc (proof-of-concept only, not active exploitation), Automatable=no (an attacker cannot trivially mass-scan and auto-exploit), and Technical Impact=partial - all consistent with the low VC:L/VI:L/VA:N impact metrics. No EPSS score was provided and the CVE is NOT in CISA KEV, so there is no evidence of widespread or active exploitation. The strongest aggravating signal is NOT in the raw score: the GHSA advisory states CCIP Read is enabled by default (global_ccip_read_enabled=True), so any backend/indexer/API using .call() against attacker-influenced contracts is silently exposed. Net: prioritize patching for server-side web3.py deployments that process untrusted contract addresses (classic SSRF-to-cloud-metadata risk), but this is not a drop-everything, auto-wormable critical. |
| Exploit ScenarioDerived | A backend indexer or API uses web3.py's .call() against an attacker-controlled or user-supplied ERC-3668 contract with CCIP Read enabled (default). The malicious contract returns an OffchainLookup URL whose host resolves to an IPv4-mapped IPv6 address such as ::ffff:169.254.169.254, bypassing the private/reserved-range block so web3.py fetches the cloud metadata endpoint and leaks credentials. A proof-of-concept exists (SSVC Exploitation=poc), and the high attack complexity (AC:H/AT:P) means exploitation requires the crafted mapped-address trick plus a victim that queries untrusted contracts. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Server-side request forgery in web3.py's CCIP Read (EIP-3668) URL handling (CVE-2026-111171) allows a malicious or attacker-controlled smart contract to make victim applications issue outbound HTTP requests to loopback, RFC1918, or link-local destinations, including cloud metadata services such as 169.254.169.254. The flaw affects web3.py 7.15.0 through 7.16.0 and 8.0.0b2 through 8.0.0, and is reachable unauthenticated (CVSS:4.0 PR:N, AV:N) by any backend, indexer, bot, or API that performs .call()/eth_call against untrusted contracts, since CCIP Read is enabled by default (global_ccip_read_enabled=True). Exploitation requires the attacker to deliberately craft an IPv4-mapped IPv6 host (e.g. ::ffff:127.0.0.1) or AAAA record that bypasses _check_ip_blocked(), so the attack is automatable only with specific crafting (SSVC Automatable: no); publicly available exploit code exists, impact is partial (low confidentiality and integrity), and the issue is not currently listed in CISA KEV.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - apply the vendor fix in https://github.com/ethereum/web3.py/pull/3875 (commit b1c57bb0a124359c9902daaefab4d8af7c3c4c1e), which canonicalizes IPv4-mapped IPv6 addresses in _check_ip_blocked() via a new _canonical_ip() helper, or upgrade to a web3.py release that incorporates it, and track the advisory at https://github.com/ethereum/web3.py/security/advisories/GHSA-5hr4-253g-cpx2 for the exact patched version. If immediate upgrade is not possible, the most effective compensating control is to disable CCIP Read entirely - set global_ccip_read_enabled = False on the provider or pass ccip_read_enabled=False to individual .call() invocations - with the trade-off that legitimate EIP-3668 offchain resolution (for example offchain-resolved ENS names) will stop working. Where CCIP Read must remain enabled, restrict it to trusted contract addresses and known-good offchain gateways, and, as recommended by the advisory and EIP-3668, add a validation or override hook that rewrites or denies CCIP URLs so requests are proxied through an egress service with a domain allowlist. Network-layer controls should also be applied: block the web3.py process from reaching loopback, RFC1918, and link-local ranges (especially 169.254.169.254) and from following HTTP redirects, and enforce IMDSv2-only metadata access on cloud instances so that any residual SSRF cannot retrieve instance credentials; each of these measures is a hardening layer and should be combined with the code fix rather than treated as equivalent to it.
Affected VersionsENISA
Affected Packages
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
web3.py implements EIP-3668 'CCIP Read' so that revert responses carrying an OffchainLookup payload cause the client to fetch data from contract-supplied URLs found in offchain_lookup_payload['urls'], with {sender}/{data} template substitution. The vulnerable validation routine, _check_ip_blocked() in web3/utils/ccip_url_validation.py (CWE-918, Server-Side Request Forgery), resolves each host with socket.getaddrinfo and compares the resulting IPs against private, loopback, and link-local blocklists - but it feeds the raw string into ipaddress.ip_address() and never checks IPv6Address.ipv4_mapped. Consequently an address such as ::ffff:127.0.0.1, ::ffff:10.0.0.1, ::ffff:192.168.1.1, or ::ffff:169.254.169.254 is treated as an ordinary IPv6 address rather than its embedded IPv4 equivalent and passes the blocklist; the same gap is reachable through an AAAA DNS record for an attacker-controlled domain. Because the HTTP clients used (requests and aiohttp) follow redirects by default and the advisory notes there is no allowlist, no scheme enforcement beyond an http opt-in, and no redirect-target revalidation, a malicious contract can pivot the web3.py process into internal services or the cloud instance metadata endpoint. The upstream fix (PR #3875, commit b1c57bb0a124359c9902daaefab4d8af7c3c4c1e) introduces a _canonical_ip() helper that unwraps IPv4-mapped IPv6 addresses before blocklist matching, with regression tests covering both blocked and public mapped addresses.
Know when Web3 Py 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:H/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N
AC:H because the bypass requires crafted IPv4-mapped IPv6/AAAA records; PR:N as no client auth is needed; S:C with C:L/I:L for limited SSRF into internal systems; A:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Web3.py 7.15.0 through 7.16.0 and 8.0.0b2 through 8.0.0 contains a server-side request forgery vulnerability because _check_ip_blocked() does not unwrap IPv4-mapped IPv6 addresses in CCIP Read URL validation. Malicious contracts can return OffchainLookup URLs with IPv4-mapped IPv6 hosts or AAAA records, making clients with CCIP Read enabled send requests to loopback, private, or link-local services.
Blast Radius
ecosystem impact- 1 pypi packages depend on web3 (1 direct, 0 indirect)
Ecosystem-wide dependent count for version 6.0.0b3.
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
EUVD-2026-102298
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB