Skip to main content

Vyper EUVDEUVD-2026-106918

| CVE-2026-114115 MEDIUM
Access of Resource Using Incompatible Type (Type Confusion) (CWE-843)
2026-10-21 VulnCheck GHSA-fccw-crcx-53fr
6.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Call affected deployed contract function
  2. Exploit
    Supply input selecting narrower ternary arm
  3. Execution
    Compiler reads inner arrays at wrong offsets
  4. Impact
    Corrupted 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 (a if c else b) whose arms are nested arrays - DynArray of Bytes/String, DynArray of DynArray, or static arrays of DynArray - with DIFFERING inner bounds, where the expression widens to the wider result type and the narrower arm is selected at runtime; only then are inner arrays after the first read at incorrect offsets. The decisive LIMITING factor (reflected as AT:P in CVSS 4.0) is that the contract must already contain this specific widening nested-array ternary pattern - contracts without it are entirely unaffected, which is why this is not remotely exploitable against arbitrary deployments. No special attacker authentication is needed against an affected deployed contract (PR:N), and no user interaction is required.

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 (a if c else b) that selects between nested arrays of differing inner bounds and widens to the wider type. Once deployed, when the narrower arm is selected at runtime, inner arrays after the first are read at the wrong memory offsets, so a caller receives or the contract stores corrupted values, or the transaction reverts. No public exploit was identified; VulnCheck and the GHSA advisory include compiler test cases demonstrating the miscompilation rather than a weaponized exploit, and attack complexity is low once the vulnerable pattern is present (AC:L) though it depends on that pattern existing (AT:P).

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

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

Alert me

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

vyper 0.3.8 ≤0.5.0b1

Affected Packages

euvd vyper no fix

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

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

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).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

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

EPSS Score
0.2%
Top 88% exploitable
Prevalence
Medium
popular Ethereum/EVM smart-contract compiler, niche outside that ecosystem
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.2%
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
None
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

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.

More in Vyper

View all
CVE-2024-24563 CRITICAL POC
9.8 Feb 07

Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine. Rated critical severity (CVSS 9.8), this v

CVE-2024-24561 CRITICAL POC
9.8 Feb 01

Vyper is a pythonic Smart Contract Language for the ethereum virtual machine. Rated critical severity (CVSS 9.8), this v

CVE-2024-22419 CRITICAL POC
9.8 Jan 18

Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine. Rated critical severity (CVSS 9.8), this v

CVE-2022-24845 CRITICAL POC
9.8 Apr 13

Vyper is a pythonic Smart Contract Language for the ethereum virtual machine. Rated critical severity (CVSS 9.8), this v

CVE-2023-39363 CRITICAL POC
9.1 Aug 07

Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine (EVM). Rated critical severity (CVSS 9.1),

CVE-2023-31146 CRITICAL POC
9.1 May 11

Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated critical severity (CVSS 9.1), this v

CVE-2023-42443 HIGH POC
8.1 Sep 18

Vyper is a Pythonic Smart Contract Language for the Ethereum Virtual Machine (EVM). Rated high severity (CVSS 8.1), this

CVE-2023-42460 HIGH POC
7.5 Sep 27

Vyper is a Pythonic Smart Contract Language for the EVM. Rated high severity (CVSS 7.5), this vulnerability is remotely

CVE-2023-32059 HIGH POC
7.5 May 11

Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne

CVE-2023-32058 HIGH POC
7.5 May 11

Vyper is a Pythonic smart contract language for the Ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne

CVE-2023-30837 HIGH POC
7.5 May 08

Vyper is a pythonic smart contract language for the EVM. Rated high severity (CVSS 7.5), this vulnerability is remotely

CVE-2023-30629 HIGH POC
7.5 Apr 24

Vyper is a Pythonic Smart Contract Language for the ethereum virtual machine. Rated high severity (CVSS 7.5), this vulne

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