Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessContribute crafted Vyper source
-
DeliveryHide U+2028/form-feed in comments or indentation
-
ExploitVictim compiles affected Vyper version
-
Executionsplitlines desynchronizes literal validation
-
ImpactDeploy contract with silently altered constants
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service Interpretation consistency
|
| Exploitation Conditions | Exploitation requires that a victim compile attacker-supplied Vyper source with an affected version (0.1.0b1 before 0.1.0b17, or 0.4.1 through 0.5.0b1) that contains line-separator characters Python's str.splitlines() treats as line breaks (e.g. form feed U+000C, U+2028) hidden in comments, string contents, or indentation. The attack is limited by requiring a human workflow: the attacker must get source accepted/reviewed and the victim must compile it, and the discrepancy only affects numeric literal (address, integer, decimal) classification and validation - it does not grant remote system access. It relies on code reviewers failing to notice invisible Unicode characters in a diff; projects that render or normalize such characters, or compile only trusted first-party source, are not realistically exposed. |
| Impact | This is a medium-severity integrity flaw, not an urgent remote-code-execution priority. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:P, VI:H only) scores 6.0 and correctly reflects an attack that depends on human workflow rather than direct remote compromise: no confidentiality or availability impact (VC:N/VA:N), and exploitation requires both an attack prerequisite (AT:P) and victim interaction (UI:P - someone must compile the malicious source). No EPSS score was provided, so statistical exploitation likelihood cannot be assessed. There is no CISA KEV listing and no public exploit was supplied in the intelligence, so this is 'no public exploit identified at time of analysis.' CWE-436 (interpretation conflict between Python's str.splitlines() and the actual parser) matches the description precisely. The real-world risk is concentrated and targeted: it matters most to teams that compile third-party or contributed Vyper source for on-chain deployment, where silently altered address/integer/decimal constants can redirect funds or change contract logic undetected. It is a genuine supply-chain/source-review concern for Vyper users but is not a candidate for mass automated exploitation. Note: the vector is CVSS 4.0, not 3.1, and PR:N here means no system privilege is needed - but the practical precondition is the ability to get source in front of a victim compiler. |
| Exploit ScenarioDerived | An attacker submits a pull request or shares Vyper source containing invisible characters (form feed or U+2028) tucked into comments, strings, or indentation. Because an affected Vyper version builds its line table with str.splitlines() while the Python parser ignores those characters, numeric literals are validated against shifted source, so a maintainer who reviews and compiles the code deploys a contract whose address, integer, or decimal constants differ from what the diff appeared to show. No public exploit code was provided, but the technique is straightforward to reproduce once understood. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Numeric literal manipulation in the Vyper smart-contract compiler (versions 0.1.0b1 through 0.1.0b16 and 0.4.1 through 0.5.0b1) lets attacker-supplied source silently alter address, integer, and decimal constants that survive into compiled bytecode. The compiler builds its source-line table with str.splitlines(), which recognizes line separators such as form feed (U+000C) and U+2028 that the Python parser ignores, so literals are classified and validated against a shifted view of the source. Exploitation requires a victim to compile and deploy malicious-looking-but-reviewed code (unauthenticated remote attacker, user interaction required per the assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N), and no public exploit code or confirmed active exploitation has been identified at time of analysis; this is a medium-severity integrity issue, not an urgent remote-code-execution priority.
RemediationAI
A vendor-released patch is available per the GitHub security advisory (GHSA-wvx7-39qj-2g9v) - upgrade to a fixed Vyper release, i.e. 0.1.0b17 or later on the legacy 0.1.0b line and a release published after 0.5.0b1 on the 0.4.x/0.5.x line, and rebuild/redeploy any contract already compiled with an affected version after re-verifying its literal constants against the source. If an upgrade cannot be done immediately, add a pre-compile gate that rejects or normalizes source containing invisible line separators (U+000B, U+000C, U+000D, U+0085, U+2028, U+2029) outside of approved string data - implement it as a lint/pre-commit/CI check that scans raw bytes before vyper runs; the trade-off is that legitimate string literals containing these code points must be escaped (e.g. \u2028) or allowlisted, and such escapes change the reviewed bytes, so re-review is required. Complement this by configuring code review tooling to render non-ASCII and control characters visibly in diffs and by restricting compilation/deployment to source from trusted contributors or a signature-verified repository, accepting reduced contributor throughput as the cost. Both workarounds are detective/process controls only and do not change compiler behavior, so they should be treated as temporary until the fixed release is deployed.
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-based smart-contract language and compiler for the EVM. The flaw is CWE-436 (Interpretation Conflict): two components interpret the same byte sequence differently. The compiler's line-tracking utility splits source text with Python's str.splitlines(), which treats U+000B, U+000C (form feed), U+000D, U+0085, U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR) as line boundaries, while the actual Python tokenizer only breaks lines on \n (and \r\n/\r). When such a character is embedded in a comment, string literal, or indentation, the line table and the parser disagree about which physical line a token occupies. Any downstream logic that maps a token back to its source line - particularly the classification and validation of numeric literals such as addresses, integers, and decimals - therefore reads the wrong span of text, letting an attacker present one constant to a human reviewer and have a different one compiled and deployed into the contract. Impact is confined to integrity of compiled literal values (integrity: high, confidentiality/availability: none, scope: unchanged); the bug does not provide code execution or access to the build host. The affected CPE is cpe:2.3:a:vyperlang:vyper, tracked by ENISA EUVD-2026-106919 and reported by VulnCheck.
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:P/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
No privilege is needed to contribute source but the victim must review and compile it (UI:R); impact is integrity-only as constants are silently altered, with no confidentiality or availability effect.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Vyper 0.1.0b1 before 0.1.0b17 and 0.4.1 through 0.5.0b1 builds its source-line table with str.splitlines(), which treats characters like form feed and U+2028 as line breaks the Python parser ignores, so numeric literals are classified and validated from shifted source text. An attacker contributing source code can hide these characters in comments, strings or indentation to silently change address, integer or decimal constants.
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
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-106919
GHSA-2gvm-cwr3-3pcg
NVD
CVE.org
EPSS
Exploit-DB