Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify deployed contract with name-shadowing pattern
-
ExploitCraft transaction overriding the shadowed variable
-
ExecutionSubstitute out-of-range or malicious value for imported constant/default
-
ImpactCorrupt validation or accounting logic
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Incorrectly specified target
|
| Exploitation Conditions | Exploitation is NOT possible against a default/arbitrary Vyper contract. It requires ALL of: (1) the contract was compiled with Vyper 0.4.0b1 through 0.5.0b1; (2) the contract imports a module that exposes an unfoldable constant and/or a function with an omitted default argument; and (3) the contract declares a parameter, local, or loop variable whose name shadows that imported name, so parse_Name misresolves it to the using function's scope. Only when this exact name-collision pattern exists can attacker-influenced input replace the intended value (e.g. supplying an out-of-range value for a narrow type such as uint8). LIMITING FACTORS: the bug is confined to beta compiler releases, depends on a specific non-default source-code pattern that the contract author must have written, and manifests only on the shadowed variable's input path - contracts without the collision are unaffected regardless of compiler version. |
| Impact | This is a compiler-level miscompilation flaw (CWE-706, incorrectly resolved name) in Vyper 0.4.0b1 through 0.5.0b1, reported by VulnCheck with an advisory and GitHub Security Advisory (GHSA-2489-32vh-8rrc). The input provides only a CVSS 4.0 base vector (score 8.6: AV:L/AC:L/AT:N/PR:N/UI:N with VC:H/VI:H/VA:H), and crucially there is NO EPSS score, NO CISA KEV listing, and NO POC indicator supplied - so the headline 8.6 is a severity rating, not an exploitation-likelihood signal. Exploitation status: no public exploit identified at time of analysis. The practical risk is materially lower than the raw score suggests because the flaw is latent: it only manifests when a contract is compiled with one of these specific BETA compiler versions AND the contract's own source contains a name collision between a local/parameter/loop variable and an imported unfoldable constant or defaulted argument. That narrow precondition points to targeted, case-by-case exploitation (or, more likely, accidental correctness bugs) rather than mass exploitation. Note a signal conflict: the vendor CVSS 4.0 vector uses AV:L (local), yet the description's 'attacker-influenced input' against a deployed smart contract is normally reachable over the network via a transaction - verify intended attack surface with the vendor. Also note the 'Information Disclosure' tag does not match the description, which describes integrity/accounting corruption rather than disclosure. |
| Exploit ScenarioDerived | A DeFi contract compiled with an affected Vyper beta imports a module constant (or relies on an omitted default argument) whose name coincides with a function parameter or loop variable in the contract. Because parse_Name resolves the name in the using function's scope, an attacker submits a transaction supplying that colliding input - e.g. an out-of-range value for a narrow uint8 - which silently replaces the intended constant/default and corrupts a validation check or accounting calculation. No public exploit code is known; exploitation requires the specific vulnerable code pattern to already exist in the deployed contract. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 22, 2026
Vyper compiler releases 0.4.0b1 through 0.5.0b1 can miscompile contracts that import an unfoldable constant or a function with an omitted default argument and then declare a parameter, local, or loop variable with the same name, causing the imported name to resolve in the using function's scope instead of at its declaration. When that name collision exists, attacker-influenced input can replace the intended value, including an out-of-range value for a narrow type such as uint8, corrupting validation or accounting logic. The independent assessment stresses that this is not exploitable against a default or arbitrary Vyper contract, that exploitation requires the specific import-and-shadowing source pattern in an affected beta compiler, and that no public exploit was identified at the time of analysis; the supplied CVSS 4.0 vector is PR:N, but the assessed CVSS 3.1 vector treats the issue as high-complexity and integrity-focused.
RemediationAI
No vendor-released patch is identified in the provided data, so teams should check GHSA-2489-32vh-8rrc for the fixed release and move affected contracts off the 0.4.0b1 through 0.5.0b1 beta range only after verifying the replacement compiler version. As a source-level mitigation, rename imported unfoldable constants and default-argument names, or alias imports, so they cannot collide with any parameter, local, or loop variable in using functions; this directly removes the shadowing trigger but requires code review and redeployment of affected contracts. Where feasible, pass default arguments explicitly instead of relying on omitted defaults, which removes the default-argument trigger but not the unfoldable-constant case, and add explicit bounds checks for narrow types such as uint8 as defense in depth, accepting extra gas and the risk that compiler misresolution could still affect other paths. For deployed affected contracts, pause or upgrade the contract and restrict calls to functions that consume shadowed inputs until a clean recompilation and review are complete; immutable contracts may require redeployment.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Vyper is a Python-like smart contract language that compiles to EVM bytecode, so compile-time name resolution defects can become on-chain logic errors. The root cause is CWE-706 (use of incorrectly resolved name or reference): parse_Name resolves names for imported unfoldable constants and omitted default arguments in the scope of the function that uses them rather than at the imported declaration, enabling name shadowing to redirect the reference. CPE cpe:2.3:a:vyperlang:vyper:*:*:*:*:*:*:*:* is broad and does not constrain versions, so the precise affected range must be taken from the description: 0.4.0b1 through 0.5.0b1. Impact is conditional on a contract importing the affected symbol and declaring a colliding parameter, local, or loop variable; the vulnerable path is the shadowed input path, and narrow integer types such as uint8 can receive out-of-range values that bypass intended validation or distort accounting. The reported CVSS 4.0 score is 8.6 with a local vector, while the independent assessment uses CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N, highlighting high attack complexity and integrity impact rather than universal remote compromise.
Know when Vyper 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:L/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Deployed contract is callable over the network (AV:N, PR:N); exploitation needs the specific name-shadowing code pattern to pre-exist (AC:H); impact is value corruption of validation/accounting logic (I:H, C:N/A:N).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Vyper 0.4.0b1 through 0.5.0b1 miscompiles unfoldable constants and omitted default arguments from imported modules, because parse_Name resolves their names in the using function's scope rather than at declaration. When a contract's parameter, local, or loop variable shares such a name, attacker-influenced input can replace the intended value, including out-of-range values for narrow types such as uint8, corrupting validation or accounting logic.
Technical POC Analysis
CWE-706 (Use of Incorrectly-Resolved Name or Reference) in the Vyper compiler.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Vyper beta compiler releases 0.4.0b1 through 0.5.0b1 can miscompile smart contracts that use a specific import-and-name-shadowing pattern, potentially corrupting validation or accounting logic. Leadership should care because only contracts built with these affected beta releases and containing that pattern are exposed, and no public exploit was identified at time of analysis, but no vendor-released patch is available and integrity failures in on-chain logic could be material.
No vendor-released patch identified at time of analysis. Interim mitigations include prohibiting Vyper 0.4.0b1 through 0.5.0b1 for production contracts, refactoring or renaming colliding imports, parameters, locals, and loop variables, recompiling with a non-affected stable Vyper release, and adding CI/source-review checks for the import-and-shadowing pattern.
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.
Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine. Rated critical severity (CVSS 9.8), this v
Vyper is a pythonic Smart Contract Language for the ethereum virtual machine. Rated critical severity (CVSS 9.8), this v
Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine. Rated critical severity (CVSS 9.8), this v
Vyper is a pythonic Smart Contract Language for the ethereum virtual machine. Rated critical severity (CVSS 9.8), this v
Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine (EVM). Rated critical severity (CVSS 9.1),
Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated critical severity (CVSS 9.1), this v
Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine (EVM). Rated high severity (CVSS 8.1), this
Vyper is a Pythonic Smart Contract Language for the EVM. Rated high severity (CVSS 7.5), this vulnerability is remotely
Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne
Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne
Vyper is a pythonic smart contract language for the EVM. Rated high severity (CVSS 7.5), this vulnerability is remotely
Vyper is a Pythonic Smart Contract Language for the ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne
EUVD-2026-107698
GHSA-9r8w-599f-g6jq
NVD
CVE.org
EPSS
Exploit-DB