Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit Vyper source with NFKC-normalizing unicode or BOM
-
DeliveryVictim compiles untrusted contributed source
-
ExploitByte/character col_offset mismatch shifts literal slices
-
ExecutionSubstituted address or integer emitted into bytecode
-
ImpactMalicious constant deployed in on-chain contract
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Unicode normalization
|
| Exploitation Conditions | Exploitation requires the victim to compile attacker-supplied Vyper source that contains either (a) a non-ASCII identifier that NFKC-normalizes to an ASCII name or (b) an invisible byte-order mark, triggering the character-vs-byte col_offset mismatch in vyper/ast/parse.py that shifts the slices used to reconstruct later numeric literals. Affected: Vyper 0.1.0b1 through 0.1.0b11, 0.1.0b14, and 0.4.1 through 0.5.0b1. Limiting factors that reduce real-world risk: the attacker must get malicious source into the victim's build pipeline (e.g. a merged pull request or a trusted package) and the victim must actually compile it, so code that is authored in-house or reviewed byte-for-byte is unaffected; there is no remote network service to attack and no impact on already-compiled trusted contracts. |
| Impact | This is a genuine code-integrity flaw rather than a hyped high-CVSS item, but its real-world priority is conditional on workflow. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:P, VC:N/VI:H/VA:N) scores 6.0 (Medium) and correctly captures the shape of the risk: no confidentiality or availability impact, but HIGH integrity impact because attacker-controlled source can silently alter the constants emitted into compiled bytecode. The AT:P (attack requirements present - the attacker must craft characters that NFKC-normalize to ASCII or insert a BOM) and user-interaction requirement (the victim must compile the untrusted source) are real brakes on mass or automated exploitation. There is NO EPSS score, NO CISA KEV listing, and NO public exploit in the provided data, so there is no evidence of active or widespread exploitation - this reads as a targeted supply-chain/source-review integrity threat, not an internet-facing mass-exploitation bug. The priority is HIGH specifically for teams that compile Vyper source received from multiple or untrusted contributors (e.g. open-source DeFi projects, audited smart-contract repos), because a silently substituted address could redirect on-chain funds; it is LOW for developers compiling only their own trusted code. One signal to verify: PR:N implies the attacker needs no privileges, which fits a pull-request/contribution threat model, but the attack still depends entirely on the victim trusting and compiling foreign source. |
| Exploit ScenarioDerived | An attacker submits a pull request (or publishes a package) containing Vyper source where a non-ASCII identifier NFKC-normalizes to an ASCII name, or an invisible byte-order mark is embedded. Because parse.py mixes character-based line offsets with Python's byte col_offset values, the multi-byte character shifts the source slices used to rebuild later numeric literals, so the code that a human reviewer reads differs from the constants actually compiled - e.g. a benign-looking address is silently replaced by the attacker's address. No public exploit is identified at time of analysis, so this would require the attacker to independently develop the crafted-source technique. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Source-code integrity compromise in the Vyper compiler allows attacker-supplied Vyper source to silently substitute numeric literals, addresses, and other constants during compilation. Affected versions are Vyper 0.1.0b1 through 0.1.0b11, 0.1.0b14, and 0.4.1 through 0.5.0b1; exploitation requires the victim to compile source containing either a non-ASCII identifier that NFKC-normalizes to ASCII or an invisible byte-order mark, which triggers a character-versus-byte offset mismatch in literal reconstruction. No public exploit code identified at time of analysis, and the flaw does not affect already-compiled trusted contracts or expose a remote network service.
RemediationAI
Vendor patch is available per the GitHub Security Advisory GHSA-r3c7-7xwm-6vfw; upgrade to the fixed release identified there, and for the 0.1.0b14 branch EUVD version data indicates 0.1.0b15 or later resolves the issue. If immediate upgrade is not possible, restrict compilation to source that has been reviewed for non-ASCII identifiers and byte-order marks, add CI checks that reject BOM characters and non-ASCII identifiers before compilation, and compare compiled bytecode constants against expected values as a detection control. ASCII-only source restrictions reduce exposure but may break legitimate Unicode identifiers; bytecode diffing adds build overhead but can catch silent literal substitution; source review and merge-control restrictions are labor-intensive but necessary because exploitation requires attacker-controlled source to enter the victim's build pipeline.
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 Ethereum/EVM bytecode. The flaw is rooted in CWE-176 (Improper Handling of Unicode Encoding): vyper/ast/parse.py mixes character-based line offsets with Python AST's UTF-8 byte-based col_offset values. Python's ast module reports col_offset in UTF-8 bytes, while Vyper's parsing logic uses character positions for some line-offset calculations. When source contains multi-byte characters-specifically non-ASCII identifiers that NFKC-normalize to ASCII names or an invisible byte-order mark-the byte length diverges from the character length, shifting the source slices used to reconstruct later numeric literals. That shift can cause the compiler to emit different constants than the reviewed source appears to contain. The CPE records identify vyperlang:vyper as the affected product, and the public advisory is GHSA-r3c7-7xwm-6vfw.
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
Attacker needs no privileges (PR:N) but the victim must compile the delivered source (UI:R); reliably craftable so AC:L; integrity-only impact (I:H, C:N, A:N), scope unchanged.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Vyper 0.1.0b1 before 0.1.0b12, 0.1.0b14, and 0.4.1 through 0.5.0b1 mix character-based line offsets with Python's UTF-8 byte col_offset values in vyper/ast/parse.py, so multi-byte characters shift the source slices used to reconstruct later numeric literals. An attacker contributing source with non-ASCII identifiers that NFKC-normalize to ASCII, or an invisible byte-order mark, can silently substitute addresses, integers or other constants in compiled code.
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-106917
GHSA-vchg-h45q-h36m
NVD
CVE.org
EPSS
Exploit-DB