Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-114116 Overview
CVE-2026-114116 affects the Vyper smart contract compiler. The compiler builds its source-line table with Python's str.splitlines(), which treats characters such as form feed (\f) and U+2028 as line breaks. The Python parser itself ignores these characters, creating a mismatch between the parser's view of source code and the compiler's line-based literal validation. An attacker contributing source code can hide these characters in comments, strings, or indentation to silently change address, integer, or decimal constants in the compiled bytecode. The flaw is categorized under CWE-436: Interpretation Conflict.
Critical Impact
Numeric literals, including Ethereum addresses, can be substituted at compile time without visible changes in reviewed source code, enabling supply-chain attacks on smart contracts.
Affected Products
- Vyper 0.1.0b1 through 0.1.0b16
- Vyper 0.4.1 through 0.5.0b1
- Smart contracts compiled with vulnerable Vyper versions
Discovery Timeline
- 2026-10-21 - CVE-2026-114116 published to NVD
- 2026-10-22 - Last updated in NVD database
Technical Details for CVE-2026-114116
Vulnerability Analysis
Vyper is a Pythonic smart contract language that compiles to Ethereum Virtual Machine (EVM) bytecode. During compilation, Vyper constructs a source-line table using str.splitlines() to associate tokens with original source text for literal validation.
Python's str.splitlines() recognizes a broader set of line-break characters than the Python tokenizer. These include form feed (\f, U+000C), line separator (U+2028), paragraph separator (U+2029), and other Unicode line-break characters. The Python parser treats these as whitespace inside tokens rather than as line terminators.
This interpretation conflict causes Vyper to validate numeric literals against the wrong source line. An attacker can embed one of these characters earlier in the file, shifting the compiler's view of subsequent lines. The parsed abstract syntax tree still points at the original token, but the literal-text lookup returns text from a different physical line.
Root Cause
The root cause is a parser-versus-tokenizer disagreement about what constitutes a line break. Vyper's source-line table is built from splitlines() output, while the Python ast module uses CPython's tokenizer, which recognizes only \n and \r\n as statement terminators. Any character in the splitlines() set that is not in the tokenizer's set desynchronizes the two views.
Attack Vector
An attacker who can submit source code to a project, through a pull request, library dependency, or shared template, can insert characters like U+2028 inside a comment or string. The code appears identical in most editors and code review tools. On compilation, the hidden character shifts Vyper's line table so that a constant such as a token address, fee rate, or integer bound is read from a line of attacker-chosen text. The resulting bytecode contains a different literal than the one visible in the reviewed source.
No verified public proof-of-concept code is published at this time. See the GitHub Security Advisory GHSA-wvx7-39qj-2g9v and the VulnCheck Advisory on Vyper Literal Manipulation for additional technical detail.
Detection Methods for CVE-2026-114116
Indicators of Compromise
- Presence of non-standard line separator characters (U+2028, U+2029, U+000C form feed, U+000B vertical tab, U+0085 NEL) in .vy Vyper source files.
- Discrepancy between numeric literals observed in reviewed source and the constants present in compiled EVM bytecode.
- Pull requests or dependency updates that modify only whitespace or comments but produce different compiled artifacts.
Detection Strategies
- Scan Vyper source files with a byte-level linter that flags any character outside the printable ASCII range plus \n and \r.
- Compare the disassembled constants in compiled bytecode against literals extracted from the source via an independent parser.
- Enforce reproducible builds and diff compiled artifacts across contributor commits in continuous integration.
Monitoring Recommendations
- Audit code review tooling to ensure invisible Unicode characters render as visible glyphs or warnings.
- Monitor dependency manifests for upgrades to Vyper and pin to patched versions in build pipelines.
- Track smart contract deployment pipelines for compiler version metadata and reject deployments built with vulnerable Vyper releases.
How to Mitigate CVE-2026-114116
Immediate Actions Required
- Upgrade Vyper to a patched release outside the 0.1.0b1 to 0.1.0b16 and 0.4.1 to 0.5.0b1 ranges before compiling production contracts.
- Recompile and audit any smart contract compiled with an affected Vyper version prior to redeployment.
- Reject source files containing U+2028, U+2029, form feed, or other non-standard line-break characters during code review and CI validation.
Patch Information
Refer to the GitHub Security Advisory GHSA-wvx7-39qj-2g9v for the fixed version numbers and remediation guidance from the Vyper maintainers. The fix aligns Vyper's internal source-line table with the character set recognized by the Python tokenizer.
Workarounds
- Pre-process Vyper source files to strip or reject any character not in a strict ASCII allowlist before compilation.
- Use a secondary parser or linter to extract numeric literals from source and compare them against the compiled bytecode constants.
- Restrict contributor access to Vyper source repositories and require signed commits with mandatory diff review of hidden characters.
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

