Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCall affected deployed contract function
-
ExploitSupply input selecting narrower ternary arm
-
ExecutionCompiler reads inner arrays at wrong offsets
-
ImpactCorrupted values stored on-chain or revert
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Type safety enforcement
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a contract compiled with an affected Vyper version (0.3.8 through 0.5.0b1) that contains a ternary expression ( |
| Impact | This is a CVSS 4.0 6.3 (Medium) compiler miscompilation (CWE-843 type confusion) with a vulnerable-system integrity impact only (VI:L; VC:N, VA:N). The 4.0 vector's AT:P (Attack Requirements: Present) is the single most important signal: exploitation is gated on a contract actually containing the specific vulnerable code pattern, so this is not a broadly exploitable flaw across all Vyper contracts. PR:N in the vector indicates that, for an affected deployed contract, no authentication is needed - any caller can trigger the misread over the network (unauthenticated). No EPSS score, no CISA KEV listing, and no public exploit were provided in the input, which is consistent with a correctness/compiler bug rather than a mass-exploited network vulnerability; absence of EPSS/KEV data is noted, not inferred as low. The realistic risk is concentrated and high-consequence rather than widespread: the small subset of contracts compiled with affected Vyper that use widening nested-array ternaries can silently store corrupted values on an immutable ledger or revert, which is serious for those specific contracts, but the overall exploitation surface is narrow. Net: a patch-and-recompile priority for Vyper developers using the affected pattern, not an emergency for the general population. One data note: the input Tag 'Information Disclosure' sits uneasily with the vendor-aligned CVSS VC:N - the described impact is corrupted/misread values (integrity), so confidentiality impact is unconfirmed. |
| Exploit ScenarioDerived | A developer compiles a Vyper contract (0.3.8-0.5.0b1) containing a ternary ( |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Contracts written in Vyper 0.3.8 through 0.5.0b1 that use a ternary expression to select between nested arrays with differing inner bounds can silently store corrupted values or revert at runtime, because the compiler emits code that reads the narrower arm using the wider result type's memory layout. Only deployments that already contain this specific widening nested-array ternary pattern are exposed, and no public exploit code has been identified at time of analysis. The impact is confined to the integrity of the affected contract's own state (CVSS 4.0 6.3 Medium, VI:L with no confidentiality or availability impact), so contracts lacking the pattern are entirely unaffected.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - the correction is in Vyper commit https://github.com/vyperlang/vyper/commit/1fb7dfe2, referenced from advisory GHSA-cw3h-xwxq-8cx2, so teams should upgrade to a compiler build that contains that commit and recompile from source. Because the miscompilation is baked into deployed bytecode, patching the compiler does nothing for contracts already on-chain: each affected contract must be recompiled, verified against the new regression tests, and redeployed, with state migrated and users notified - a costly process that should be prioritised by scanning sources for ternaries whose arms are nested arrays of unequal inner bounds. Until a redeploy is possible, the only reliable mitigation is source-level: rewrite the offending ternary as an explicit if/else that assigns into a local variable declared with the exact target type, or force both arms to the same inner bounds so no widening occurs, then recompile and re-verify. There is no runtime guard, feature flag, or configuration toggle that can neutralise already-deployed vulnerable bytecode, so monitoring should focus on unexpected reverts or anomalous stored values in contracts known to use this pattern.
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, and the flaw lives in the compiler's expression-lowering stage rather than in any deployed runtime primitive. CWE-843 (Type Confusion) describes the root cause: when the two arms of an a if c else b expression have different but compatible types, parse_IfExp widens both arms to a common result type - for example DynArray[Bytes[10], 5] versus DynArray[Bytes[512], 5] widening to DynArray[Bytes[512], 5]. Codegen for the narrower arm then walks its inner elements assuming the wider type's element stride and offsets, so every inner array after the first is loaded from the wrong memory location. The affected shapes are DynArray of Bytes/String, DynArray of DynArray, and static arrays of DynArray, in either operand order and both at return sites and via local variable assignment. The published fix (commit 1fb7dfe2) adds a dedicated regression suite, tests/functional/codegen/features/test_ternary_widening.py, that exercises widening across DynArray[Bytes], DynArray[String], nested DynArray[uint256, N], and static-array wrappers, plus flipped operand ordering - confirming the defect was in the layout/stride computation rather than in bounds checking. The CPE cpe:2.3:a:vyperlang:vyper:*:*:*:*:*:*:*:* covers the Vyper compiler distribution as a whole; the practical blast radius is determined by which compiled contracts embed the vulnerable pattern.
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:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
AV:N and PR:N since any caller can trigger an affected deployed contract; AC:H because exploitation depends on the specific vulnerable nested-array ternary pattern existing; impact limited to integrity (I:L).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Vyper 0.3.8 through 0.5.0b1 contains a compiler miscompilation vulnerability in parse_IfExp that reads nested arrays with narrower inner bounds using the wider result type's memory layout. When a ternary selects the narrower array, inner arrays after the first are read at wrong offsets, causing contracts to silently store corrupted values or revert.
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
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Related Vulnerabilities in Vyper Compiler Miscompilation and Parsing Bugs
View all 5Vyper 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-106918
GHSA-fccw-crcx-53fr
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB