Nov 18, 2026·12 min read·1 visit
Versions of snark-verifier prior to 0.2.5 fail to enforce canonical bit-width bounds when decoding KZG accumulator limbs from public instances. This allows proof representation malleability in generated EVM verifier contracts and causes denial-of-service panics in native Rust verification services.
CVE-2026-61618 (GHSA-265x-v3qf-ff6p) is an improper input validation vulnerability (CWE-20) in Axiom Crypto's snark-verifier library prior to version 0.2.5. The library decodes KZG accumulator public-instance limbs without enforcing canonical bit-width bounds prior to elliptic curve coordinate reconstruction. In the Ethereum Virtual Machine (EVM) loader path, the generated Yul bytecode validates that reconstructed affine coordinates lie on the elliptic curve, but fails to verify that the constituent limbs respect their allocated bit-widths, allowing non-canonical proof representations. In the native Rust execution path, accumulator decoding relies on unchecked assertions and unwraps, allowing malformed public instances to trigger an unhandled process panic.
snark-verifier is an open-source Rust library developed by Axiom Crypto for verifying zero-knowledge (S)NARK proofs across both native execution environments and the Ethereum Virtual Machine (EVM). The library provides foundational primitives for verifying Halo2 and Plonk proofs utilizing Kate-Zaverucha-Goldberg (KZG) polynomial commitment schemes. In recursive proof aggregation pipelines, verification circuits defer elliptic curve pairing checks by maintaining a KZG accumulator exposed as public instances.
Because elliptic curve base field elements (such as BN254 $F_q$ coordinates) generally cannot be natively represented within a single scalar field element ($F_r$) without modular overflow, snark-verifier decomposes each affine coordinate $(x, y)$ into multiple smaller scalar limbs of a fixed bit-width (BITS). During proof verification, the verifier reads these limbs from the public instance array and reconstructs the full base field coordinates to perform final pairing check validations.
In snark-verifier versions prior to 0.2.5, the decoding logic in both the EVM code generator and the native Rust verifier fails to enforce canonical range bounds on these individual limbs before reconstructing the elliptic curve points. Classified under CWE-20 (Improper Input Validation), this omission affects two distinct code paths: snark-verifier/src/loader/evm/loader.rs for EVM smart contract generation and snark-verifier/src/pcs/kzg/accumulator.rs for native verification.
In the EVM execution environment, the generated Yul verifier assembly accepts overflowing limbs that exceed $2^{\text{BITS}} - 1$, provided the resulting shifted sum still resolves to a valid point on the curve. This breaks public instance canonicality and introduces representation malleability. In the native Rust verifier environment, the limb parsing logic relies on assert_eq! macros and .unwrap() calls rather than structured error propagation, allowing malformed inputs or off-curve coordinates to trigger an unhandled thread panic.
The root cause of CVE-2026-61618 resides in how PlonkProof::read processes public instances designated by accumulator_indices. When extracting scalar field elements to reconstruct the left-hand side (lhs) and right-hand side (rhs) $G_1$ affine points of a KZG accumulator, the elements are passed to AccumulatorEncoding::from_repr. The vulnerability diverges depending on whether the active LoadedScalar implementation targets the EvmLoader or the native Rust loader.
In the EVM loader path (snark-verifier/src/loader/evm/loader.rs), LimbsEncoding::from_repr delegates coordinate assembly to EvmLoader::ec_point_from_limbs. For a configuration with LIMBS limbs of BITS width each, the loader emits Yul assembly that reconstructs coordinates $x$ and $y$ via bitwise left-shifts (shl) and additions (add):
$$x = \sum_{i=0}^{\text{LIMBS}-1} \text{limb}_i \cdot 2^{i \cdot \text{BITS}} \pmod{2^{256}}$$
Prior to version 0.2.5, ec_point_from_limbs did not emit Yul lt (less-than) comparisons to verify that each individual $\text{limb}_i < 2^{\text{BITS}}$ or that the highest limb did not overflow the 256-bit EVM word boundary. Once $x$ and $y$ were accumulated, the loader invoked validate_ec_point, which only confirmed that $(x, y)$ satisfied the curve equation over the base field $F_q$. Consequently, two distinct limb vectors—one canonical and one where limb $i$ carries high bits that overlap with limb $i+1$—reconstruct to the exact same elliptic curve point and pass verification.
In the native loader path (snark-verifier/src/pcs/kzg/accumulator.rs), the implementation suffered from two distinct defects: lack of canonical limb range checks and unsafe error handling. The native AccumulatorEncoding::from_repr converted limbs using fe_from_limbs, which reconstructed the base field element without checking whether each scalar limb was less than $2^{\text{BITS}}$ or whether the combined integer value exceeded the target prime field modulus before modular reduction.
Furthermore, the native parser validated the input slice length using assert_eq!(limbs.len(), 4 * LIMBS) and converted the reconstructed coordinates into an affine curve point via C::from_xy(lhs_x, lhs_y).unwrap(). In Rust, assert_eq! and .unwrap() on a CtOption / Option matching None immediately invoke the panic! macro. When an external caller supplies an instance slice of invalid length or coordinates that do not lie on the curve $C$, the verifier crashes the worker thread instead of returning Err(Error::InvalidInstances).
Commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70 resolves both the EVM canonicality gap and the native panic condition by introducing strict per-limb bounds verification and fallible decoding paths.
snark-verifier/src/loader/evm/loader.rs)In the vulnerable version of EvmLoader::ec_point_from_limbs, the code directly shifted and added each limb without verifying its magnitude:
// VULNERABLE CODE (Prior to 0.2.5)
for (idx, limb) in x_limbs.iter().enumerate() {
let limb_i = self.push(limb);
code.push_str(&if idx == 0 {
format!("let x := {limb_i}\n")
} else {
format!("x := add(x, shl({}, {limb_i}))\n", idx * BITS)
});
}The patch introduces a helper function limb_bound_check_code that calculates the maximum permissible bit-width for each limb position relative to the 256-bit EVM word limit, and emits Yul instructions that bitwise-AND the check result into the global verification success flag:
// PATCHED CODE (0.2.5)
fn limb_bound_check_code(limb: &str, shift: usize, bits: usize) -> String {
// Calculate remaining bits before hitting the 256-bit EVM word ceiling
let remaining_bits = 256usize.saturating_sub(shift);
let bound_bits = bits.min(remaining_bits);
if bound_bits == 0 {
// Any limb shifted by >= 256 bits must be strictly zero
format!("success := and(iszero({limb}), success)\n")
} else {
// Enforce limb < (1 << bound_bits)
format!("success := and(lt({limb}, shl({bound_bits}, 1)), success)\n")
}
}Within EvmLoader::ec_point_from_limbs, the patched code asserts BITS > 0 at generation time and injects limb_bound_check_code for every limb in both x_limbs and y_limbs prior to performing coordinate accumulation:
assert!(BITS > 0);
let mut code = String::new();
for (idx, limb) in x_limbs.iter().enumerate() {
let limb_i = self.push(limb);
let shift = idx * BITS;
// Emit Yul bounds check before shifting/adding
code.push_str(&limb_bound_check_code(&limb_i, shift, BITS));
code.push_str(&if idx == 0 {
format!("let x := {limb_i}\n")
} else {
format!("x := add(x, shl({shift}, {limb_i}))\n")
});
}snark-verifier/src/pcs/kzg/accumulator.rs)In the native path, the vulnerable implementation used panicking macros and unchecked conversions:
// VULNERABLE CODE (Prior to 0.2.5)
assert_eq!(limbs.len(), 4 * LIMBS);
let [lhs_x, lhs_y, rhs_x, rhs_y]: [_; 4] = limbs
.chunks(LIMBS)
.map(|limbs| {
fe_from_limbs::<_, _, LIMBS, BITS>(
limbs.iter().map(|limb| **limb).collect_vec().try_into().unwrap(),
)
})
.collect_vec()
.try_into()
.unwrap();
let accumulator = KzgAccumulator::new(
C::from_xy(lhs_x, lhs_y).unwrap(),
C::from_xy(rhs_x, rhs_y).unwrap(),
);The patch replaces the panicking logic with fe_from_limbs_checked, which converts each limb to a BigUint, verifies that it is strictly less than $2^{\text{BITS}}$, accumulates the full arbitrary-precision integer, and verifies that the total sum is strictly less than the modulus of target prime field F2:
// PATCHED CODE (0.2.5)
fn fe_from_limbs_checked<F1, F2, const LIMBS: usize, const BITS: usize>(
limbs: &[&F1],
) -> Result<F2, Error>
where
F1: PrimeField,
F2: PrimeField,
{
if limbs.len() != LIMBS {
return Err(Error::InvalidInstances);
}
let limb_bound = BigUint::from(1usize) << BITS;
let mut value = BigUint::default();
for (idx, limb) in limbs.iter().enumerate() {
let limb = fe_to_big(**limb);
// Reject limb if it exceeds canonical bit-width
if limb >= limb_bound {
return Err(Error::InvalidInstances);
}
value += limb << (idx * BITS);
}
// Reject coordinate if reconstructed value overflows target field modulus
if value >= modulus::<F2>() {
return Err(Error::InvalidInstances);
}
Ok(fe_from_limbs::<F1, F2, LIMBS, BITS>(std::array::from_fn(|idx| *limbs[idx])))
}Additionally, AccumulatorEncoding::from_repr in accumulator.rs now checks if limbs.len() != 4 * LIMBS to return Err(Error::InvalidInstances) and wraps the elliptic curve point initialization with Option::from(C::from_xy(...)).ok_or(Error::InvalidInstances)?, completely eliminating the panic surface.
The patch in commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70 is comprehensive across both execution backends. In the EVM backend, validate_ec_point already enforces that the reconstructed coordinates are less than the base field modulus $q$ and satisfy the curve equation; combined with the new limb_bound_check_code and saturating_sub shift limit, 256-bit modular wraparound and inter-limb overlap are no longer possible. In the native backend, arbitrary-precision BigUint arithmetic prevents intermediate overflow during validation, and all failure modes cleanly propagate Error::InvalidInstances.
Exploitation of CVE-2026-61618 follows two distinct methodologies depending on whether the target deployment relies on an EVM smart contract verifier or an off-chain native Rust verifier.
When targeting an on-chain verifier contract generated by an unpatched version of snark-verifier, an attacker aims to submit an alternate public instance array that verifies against an existing valid proof. Consider a standard configuration where BITS = 68 and LIMBS = 4 are used to encode a 254-bit BN254 base field coordinate $x$. In a canonical encoding, $x$ is represented as $[L_0, L_1, L_2, L_3]$ where each $L_i \in [0, 2^{68} - 1]$.
To craft a non-canonical equivalent encoding $[L'_0, L'_1, L_2, L_3]$ that reconstructs to the exact same coordinate $x$ in Yul assembly, an attacker modifies $L_0$ and $L_1$ by transferring a multiple $k$ of $2^{68}$ from the upper limb to the lower limb:
$$L'_0 = L_0 + k \cdot 2^{68}$$ $$L'_1 = L_1 - k$$
As long as $L_1 \ge k$ and $L'_0 < r$ (where $r$ is the BN254 scalar field modulus, approximately $2^{254}$), $L'_0$ remains a valid scalar field element. When the vulnerable Yul bytecode executes add(L'_0, shl(68, L'_1)), the $k \cdot 2^{68}$ terms cancel out:
$$L'_0 + (L'_1 \ll 68) = (L_0 + k \cdot 2^{68}) + (L_1 - k) \cdot 2^{68} = L_0 + L_1 \cdot 2^{68}$$
Note that this attack requires that the underlying SNARK circuit itself does not constrain the public instance limbs to [0, 2^BITS) in-circuit, or that the accumulator limbs are handled outside the constrained circuit boundary.
When targeting an off-chain proof aggregation service, relayer, or RPC node that uses the native snark-verifier engine to pre-validate proofs before on-chain submission, no cryptographic manipulation is necessary.
An unauthenticated attacker with network access to the proof submission endpoint sends a verification request containing a malformed public instance vector. The attacker can trigger the crash via two mechanisms:
accumulator_indices yield fewer than 4 * LIMBS elements, triggering assert_eq!(limbs.len(), 4 * LIMBS).4 * LIMBS field elements that reconstruct to $(x, y)$ coordinates that do not satisfy the Weierstrass equation $y^2 = x^3 + b \pmod q$, causing C::from_xy(lhs_x, lhs_y).unwrap() to panic on None.If the Rust application server processes incoming verification requests on worker threads without wrapping the call in std::panic::catch_unwind, or if the binary is compiled with panic = "abort" in Cargo.toml, the single malformed request terminates the verifier process.
CVE-2026-61618 is assigned a CVSS v4.0 base score of 6.9 (Medium) with the vector 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. The score reflects a network-accessible attack surface (AV:N) with low attack complexity (AC:L), no attack requirements (AT:N), no required privileges (PR:N), and no user interaction (UI:N), resulting in low integrity impact (VI:L) to the vulnerable system.
> [!NOTE]
> While the CVSS v4.0 vector records Vulnerable System Availability as None (VA:N) based on the primary EVM contract canonicality flaw, deployments utilizing the native Rust verifier path face a direct availability risk from unhandled panics if unvalidated user inputs reach AccumulatorEncoding::from_repr.
The concrete security impact depends on the deployment architecture:
keccak256(instances)) as a unique nullifier or deduplication key to prevent proof replay, non-canonical limb encodings allow a single valid proof to be submitted under multiple distinct public instance arrays, bypassing instance-hash replay checks.PlonkVerifier::verify on untrusted network payloads can be crashed remotely.In standard production deployments using snark-verifier-sdk, the practical impact of the EVM malleability vector is significantly constrained. Standard aggregation circuits generated by the SDK enforce range constraints on the KZG accumulator limbs inside the circuit itself before exposing them as public instances. Consequently, even if the generated EVM verifier contract lacks the Yul limb bound checks, the Plonk polynomial constraints will reject a proof whose public instance inputs deviate from the range-checked in-circuit witness values.
To remediate CVE-2026-61618, development teams must update the snark-verifier library and regenerate any downstream verifier artifacts.
Update snark-verifier and snark-verifier-sdk in Cargo.toml to version 0.2.5 or later, which incorporates commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70:
[dependencies]
snark-verifier = "0.2.5"
snark-verifier-sdk = "0.2.5"If pinned to a Git revision rather than a crates.io release, ensure the dependency points to commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70 or a subsequent commit on the main branch.
Upgrading the Rust crate alone does not fix already-generated Solidity or Yul verifier contracts deployed on-chain. Engineering teams must re-run their verifier generation pipeline using snark-verifier >= 0.2.5 to produce updated smart contract bytecode containing the lt(limb, shl(bound_bits, 1)) Yul checks, and redeploy the updated verifier contracts.
To verify that a generated Yul/Solidity contract contains the fix, inspect the coordinate reconstruction assembly block for the presence of the lt bound check prior to coordinate shifting:
success := and(lt(limb, shl(68, 1)), success)
x := add(x, shl(68, limb))For deployed EVM verifier contracts that cannot be immediately replaced, implement an explicit pre-validation check in the caller contract (or wrapper contract) that iterates over the public instance indices corresponding to the KZG accumulator limbs and reverts if any limb value is greater than or equal to $2^{\text{BITS}}$. For native Rust services where immediate dependency upgrades are blocked, pre-validate that all accumulator public instance limbs satisfy limb < (1 << BITS) and that reconstructed coordinates represent valid affine curve points before passing the instances to PlonkProof::read.
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| Product | Affected Versions | Fixed Version |
|---|---|---|
snark-verifier axiom-crypto | < 0.2.5 | 0.2.5 |
snark-verifier-sdk axiom-crypto | < 0.2.5 | 0.2.5 |
| Attribute | Detail |
|---|---|
| CVE / Advisory ID | CVE-2026-61618 / GHSA-265x-v3qf-ff6p |
| Vulnerability Class | CWE-20: Improper Input Validation |
| CVSS v4.0 Score | 6.9 Medium (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) |
| EPSS Score | 0.37% (31.62nd Percentile) |
| Affected Component | axiom-crypto/snark-verifier (< 0.2.5) |
| Primary Impact | Non-canonical KZG accumulator limb encodings (EVM) and unhandled thread panics (Native) |
| Exploit / KEV Status | No known public exploits / Not listed in CISA KEV |
The product receives input or data, but does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.
An OS command injection vulnerability (CWE-78) exists in the @augment-vir/node package prior to version 31.73.5. The grep() utility function builds a shell command string by interpolating caller-supplied search patterns inside double quotes and executes the string through bash via runShellCommand(). Because bash evaluates command substitution expressions inside double-quoted strings, an attacker controlling the search pattern input can execute arbitrary OS commands with the privileges of the Node.js runtime.
CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.
CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.
CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.
CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.
CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.