Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCall vulnerable blueprint factory
-
DeliverySupply oversized code_offset
-
Exploituint256 subtraction wraps to small size
-
ExecutionFactory deploys contract with no runtime code
-
ImpactETH and tokens permanently trapped
Vulnerability Assessment
| Weakness |
CWE
|
| Exploitation Conditions | Exploitation requires a factory contract compiled with vulnerable Vyper (0.3.4 through 0.5.0b1) that uses create_from_blueprint AND passes an attacker-influenceable code_offset argument without bounds validation; the attacker must be able to supply a code_offset larger than the blueprint's code size so the uint256 subtraction wraps. Limiting factors: this is not exploitable against arbitrary contracts - only factories that both use this specific builtin and expose code_offset to callers are affected (reflected by CVSS AT:P). Although PR:N means no authentication is needed to call the factory on-chain, the non-default requirement of attacker-controlled offset materially narrows the real-world attack surface, and impact is confined to trapping assets in the newly-deployed codeless contract rather than compromising the factory or its state. |
| Impact | This is a moderate, conditional risk rather than a drop-everything priority. The input CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:L) yields 6.3 (Medium): network-reachable and unauthenticated - consistent with any EVM caller invoking a contract - but it carries AT:P, meaning a specific attack requirement must hold, and impact is limited to low integrity and low availability with no confidentiality loss. There is no EPSS score, no CISA KEV listing, and no public POC provided, so all three exploitation-likelihood signals are either absent or negative; this points to a latent correctness bug, not evidence of active or imminent mass exploitation. The real-world risk is gated by the AT:P condition: exploitation only matters for factory contracts that (a) were compiled with vulnerable Vyper 0.3.4-0.5.0b1 and (b) expose code_offset to attacker control in create_from_blueprint. Note a tag/impact conflict: the input Tags include 'Information Disclosure', which contradicts the CVSS vector's VC:N (no confidentiality impact) - the actual effect is fund-trapping (integrity/availability), so the tag appears mislabeled. Bottom line: prioritize for teams that build or depend on Vyper blueprint factories, but it is not a widespread, high-urgency item absent those conditions. |
| Exploit ScenarioDerived | A DeFi protocol deploys a factory contract (compiled with a vulnerable Vyper version) that lets callers specify a code_offset when deploying child contracts via create_from_blueprint. An attacker calls the factory with an enormous code_offset; the unsigned subtraction wraps to a small positive 'remaining size', so the factory deploys a child contract with no runtime code, causing any ETH or tokens routed to that child to become permanently trapped. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Factories compiled with Vyper 0.3.4 through 0.5.0b1 that forward an attacker-influenced code_offset into the create_from_blueprint builtin can be tricked into deploying contracts with zero runtime code. The compiler computes the remaining blueprint size with unchecked uint256 subtraction, so an offset larger than the blueprint's code size wraps to a small positive number and the copy silently yields empty bytecode; assets sent to the resulting codeless address, or initialization logic that assumes a working contract, can be permanently trapped. Impact is conditional rather than universal: only factories that both use this builtin and expose code_offset to callers are reachable (reflected in the assessed CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/C:N/I:L/A:L), no public exploit code has been identified at time of analysis, and no CISA KEV entry exists, so this is a moderate, conditional risk rather than a drop-everything priority.
RemediationAI
Patch status: patch available per vendor advisory - consult GHSA-fxg7-4wqg-c8gh (https://github.com/vyperlang/vyper/security/advisories/GHSA-fxg7-4wqg-c8gh) for the exact first fixed compiler release, since this dataset only pins the affected ceiling at 0.5.0b1 and does not state the remediated version. Because Vyper is a compiler, upgrading is necessary but not sufficient: every factory built with an affected compiler must be recompiled with the fixed release and redeployed, and already-deployed vulnerable factories cannot be patched in place. If immediate recompilation is not possible, add an explicit bounds check in the factory source - assert code_offset < len(blueprint_code) - before invoking create_from_blueprint and rebuild; the trade-off is a modest gas increase per deployment and a source change that must be audited and redeployed. Alternatively, stop accepting code_offset from callers entirely and hardcode a constant offset (or remove the builtin in favor of a full-code deployment), which eliminates the attack path at the cost of the partial-code flexibility the pattern provides. Operators of live factories should also treat caller-supplied offsets as untrusted input at the front end and pause or migrate factory usage until the redeployment lands, and should warn users that assets sent to contracts deployed with empty runtime code are generally unrecoverable.
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-derived smart contract language that compiles to EVM bytecode. Its create_from_blueprint builtin implements the EIP-5202 blueprint deployment pattern: a factory stores a blueprint contract's code and instantiates copies of it, optionally skipping a leading portion of that code via a code_offset argument. Internally the builtin derives the number of bytes left to copy as (blueprint code size - code_offset) using unsigned uint256 arithmetic, but versions 0.3.4 through 0.5.0b1 perform that subtraction without first asserting that code_offset is strictly less than the blueprint's code size. Supplying an offset at or beyond the code length therefore underflows and wraps to a small positive value, so the copy routine reads out-of-range data or nothing at all and returns a deployed contract whose runtime code is empty. The weakness maps to CWE-681 (Incorrect Conversion between Numeric Types), i.e. an unsigned wraparound / numeric truncation flaw rather than a memory-safety issue. Because the defect lives in the compiler, the vulnerable behavior is baked into deployed bytecode; there is no runtime switch to flip on an already-deployed factory. Affected builds are tracked as cpe:2.3:a:vyperlang:vyper across the 0.3.4 to 0.5.0b1 range (also recorded by ENISA EUVD as EUVD-2026-106921).
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:L/SC:N/SI:N/SA:N
Unauthenticated on-chain call (PR:N/AV:N) but requires the specific condition of an attacker-controlled code_offset in a vulnerable factory (AC:H); no confidentiality impact, with low integrity and availability from fund-trapping.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Vyper 0.3.4 through 0.5.0b1 computes the remaining blueprint size in create_from_blueprint by uint256 subtraction without first checking that code_offset is below the blueprint's code size, so a huge offset wraps to a small positive value. An attacker controlling code_offset can make a factory deploy contracts with no runtime code, potentially trapping ETH and tokens.
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-106921
GHSA-p4mc-qjvf-mf2m
NVD
CVE.org
EPSS
Exploit-DB