Skip to main content

web3.py EUVDEUVD-2026-102298

| CVE-2026-111171 MEDIUM
Server-Side Request Forgery (SSRF) (CWE-918)
2026-10-15 VulnCheck
6.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Deploy malicious CCIP Read contract
  2. Delivery
    Victim backend calls contract via .call()
  3. Exploit
    Return OffchainLookup with ::ffff: mapped internal IP
  4. Execution
    web3.py fetches loopback/metadata endpoint
  5. Impact
    Exfiltrate 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

web3.py 7.15.0 ≤7.16.0
web3.py 8.0.0b2 ≤8.0.0

Affected Packages

pypi web3 fix: 7.15.0, 8.0.0b2
euvd web3_py 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

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

Vendor (VulnCheck) PRIMARY 6.3 MEDIUM
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
vuln.today AI 5.4 MEDIUM

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 1 pypi packages depend on web3 (1 direct, 0 indirect)

Ecosystem-wide dependent count for version 6.0.0b3.

Threat Intelligence Overview

EPSS Score
0.3%
Top 74% exploitable
Prevalence
Medium
de facto Python Ethereum library, but confined to blockchain/web3 backends
Data Quality
6 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

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