Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCall public verify() on wrapper contract
-
DeliverySupply bytes32 commitment ≥ BN254 modulus
-
ExploitLength checks pass, no range check
-
ExecutionVerifier reduces to canonical field element
-
ImpactApplication accepts ambiguous non-canonical commitment
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | Exploitation requires an application that relies on the OpenVmHalo2Verifier Solidity verifier wrapper (versions before 1.7.0, or the affected 2.0/2.1 prereleases) and that trusts the byte-level appExeCommit/appVmCommit values at the wrapper boundary as if they were canonical field elements. The attacker-controllable input is the bytes32 commitment values passed to verify(); the specific condition is supplying a 256-bit encoding greater than or equal to the BN254 scalar field modulus (0x30644e72...f0000001). Limiting factors: impact only materializes in downstream application logic that assumes a one-to-one mapping between supplied bytes and verified field elements - deployments that already canonicalize or constrain these commitments elsewhere are not meaningfully affected, and the issue does not forge or bypass the underlying Halo2 proof check itself. |
| Impact | This is a moderate-severity input-validation flaw (CWE-20), not an urgent priority despite being network-reachable. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) reflects that the OpenVmHalo2Verifier.verify function is an on-chain, publicly callable contract method requiring no authentication or user interaction, but impact is limited to VI:L (low integrity) with VC:N and VA:N - no confidentiality or availability consequence. The real-world risk is bounded by the fact that the flaw only produces ambiguity between byte-level commitment values and field elements; it does not by itself forge a valid proof or bypass verification arithmetic. No EPSS score, KEV listing, or working exploit is present in the input - only patch/commit/PR references and vendor advisory GHSA-w82q-w67c-67wv. The vuln.today decision label is 'this_month', consistent with a genuine but non-emergency fix. One data conflict to flag: the package metadata states 'not yet patched' for rust/openvm-sdk, while the description and release references explicitly list fixed versions (1.7.0, 2.0.0-rc.3, 2.1.0-preview) - treat the fixed-version list as authoritative and verify the package feed is stale. |
| Exploit ScenarioDerived | An actor interacting with an application built on the OpenVmHalo2Verifier Solidity wrapper submits appExeCommit and/or appVmCommit as bytes32 values greater than or equal to the BN254 scalar field modulus. Because the pre-fix wrapper only validated public-value and proof-data lengths, it forwards these non-canonical 256-bit encodings as field elements, so a downstream application may treat the raw bytes as a valid commitment that differs from the canonical field element actually used by the verifier. No public exploit identified at time of analysis; the only trigger-demonstrating artifacts are the patch's own negative-path unit tests. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
OpenVM's OpenVmHalo2Verifier Solidity wrapper accepts non-canonical app commitments: verify() takes appExeCommit and appVmCommit as raw bytes32 without rejecting values greater than or equal to the BN254 scalar field modulus (0x30644e72...f0000001), so the byte-level input a caller supplies can differ from the field element the verifier arithmetic actually consumes. Applications built on the wrapper - OpenVM SDK releases before 1.7.0 in the 1.x line, plus the 2.0 and 2.1 prereleases before 2.0.0-rc.3 and 2.1.0-preview - can therefore accept ambiguous commitments if their own logic assumes a one-to-one mapping between the supplied bytes and the verified elements. This is a moderate input-validation issue (CWE-20) that does not forge or bypass the underlying Halo2 proof check; no public exploit has been identified at time of analysis, and the network-reachable path is unauthenticated per the CVSS vector (PR:N).
RemediationAI
Vendor-released patch: OpenVM 1.7.0 (1.x line), 2.0.0-rc.3 (2.0 prereleases) and 2.1.0-preview (2.1 prereleases) - upgrade to the build matching your branch, since a single 1.x point release does not cover the prerelease lines. The fix is commit 1962276254aabc5420de266a8cb672433ce955ff (PR https://github.com/openvm-org/openvm/pull/152), which introduces BN254_SCALAR_MODULUS and reverts with InvalidAppExeCommit/InvalidAppVmCommit when either commitment is >= 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001; if you maintain a forked or vendored copy of OpenVmHalo2Verifier.sol, port those two range checks and the constant. As a compensating control where upgrading is not immediate, add an equivalent explicit check in the calling contract that rejects appExeCommit and appVmCommit values >= the BN254 scalar modulus before invoking verify(), and enforce a single canonical encoding of each commitment throughout application logic - the trade-off is that any off-chain signer or commitment producer must then guarantee it emits reduced field elements, or previously accepted inputs will start reverting. Consult the GHSA advisory at https://github.com/openvm-org/openvm/security/advisories/GHSA-w82q-w67c-67wv for the maintainers' remediation guidance.
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
OpenVM is a modular zkVM framework; its SDK ships a Solidity template contract, OpenVmHalo2Verifier, that wraps a Halo2 proof verifier for on-chain use. Halo2 arithmetic operates over the BN254 (alt_bn128) scalar field Fr, whose modulus is defined in EIP-197 as 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001. Field elements are canonically represented as integers in [0, Fr); a 256-bit value at or above Fr is a non-canonical encoding that reduces to a different field element. Before the fix, the wrapper validated public-value and proof-data lengths but passed appExeCommit and appVmCommit into the verifier as field elements without a range check, so a caller could supply encodings >= Fr. The fix adds a BN254_SCALAR_MODULUS constant and reverts with new InvalidAppExeCommit and InvalidAppVmCommit errors when either argument is >= the modulus; the accompanying Forge tests check the boundary case (commitment == modulus) and confirm the constant equals the order of the ecMul precompile's curve group. The root cause is CWE-20 improper input validation at the wrapper boundary rather than a soundness break in the proof system - the Halo2 verification itself is not forged or bypassed.
Know when Solidity 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:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
verify() is a publicly callable on-chain function (AV:N, AC:L, PR:N, UI:N); only commitment integrity is partially affected (I:L) with no confidentiality or availability impact.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
OpenVM is a performant and modular zkVM framework built for customization and extensibility. Before 1.7.0 in the 1.x line and in affected 2.0 and 2.1 prereleases, OpenVmHalo2Verifier.verify accepts appExeCommit and appVmCommit as bytes32 values without checking that either is less than the BN254 scalar field modulus. Although public-value and proof-data lengths are checked, callers can provide non-canonical 256-bit encodings greater than or equal to that modulus at the Solidity wrapper boundary. Applications relying on the wrapper can therefore accept non-canonical app executable and app VM commitments, creating ambiguity between the supplied byte-level values and the field elements used by the verifier. This issue is fixed in versions 1.7.0, 2.0.0-rc.3 and 2.1.0-preview.
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.
EUVD-2026-114438
NVD
CVE.org
EPSS
GitHub
Exploit-DB