CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-61618

CVE-2026-61618: Improper Input Validation of KZG Accumulator Limbs in snark-verifier

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 18, 2026·12 min read·1 visit

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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).

Code Analysis

Commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70 resolves both the EVM canonicality gap and the native panic condition by introducing strict per-limb bounds verification and fallible decoding paths.

EVM Loader Changes (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")
    });
}

Native Decoder Changes (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.

Fix Completeness Assessment

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 Methodology

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.

Scenario 1: Public Instance Malleability in EVM Verifiers

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.

Scenario 2: Denial of Service Against Native Rust Verifiers

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:

  1. Length Mismatch: Providing an instance array where the indices mapped by accumulator_indices yield fewer than 4 * LIMBS elements, triggering assert_eq!(limbs.len(), 4 * LIMBS).
  2. Off-Curve Coordinates: Providing 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.

Impact Assessment

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:

  1. Cryptographic Canonicality & Replay Protection: In smart contract protocols that rely on hashing the public instance array (e.g., 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.
  2. Service Availability in Off-Chain Infrastructure: Native Rust verification services (such as prover marketplaces, rollup sequencers, or zero-knowledge bridge relayers) that invoke 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.

Remediation & Mitigation

To remediate CVE-2026-61618, development teams must update the snark-verifier library and regenerate any downstream verifier artifacts.

1. Upgrade Rust Dependencies

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.

2. Regenerate and Redeploy EVM Verifier Contracts

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))

3. Interim Workarounds

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.

Official Patches

Axiom CryptoOfficial patch commit enforcing KZG accumulator limb bounds in EVM and native loaders
Axiom Cryptosnark-verifier v0.2.5 release containing the fix for CVE-2026-61618
GitHub Security AdvisoryOfficial vendor security advisory GHSA-265x-v3qf-ff6p

Fix Analysis (1)

Technical Appendix

CVSS Score
6.9/ 10
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 Probability
0.37%
Top 68% most exploited

Affected Systems

axiom-crypto/snark-verifiersnark-verifier (Rust Crate)snark-verifier-sdk (Rust Crate)

Affected Versions Detail

Product
Affected Versions
Fixed Version
snark-verifier
axiom-crypto
< 0.2.50.2.5
snark-verifier-sdk
axiom-crypto
< 0.2.50.2.5
AttributeDetail
CVE / Advisory IDCVE-2026-61618 / GHSA-265x-v3qf-ff6p
Vulnerability ClassCWE-20: Improper Input Validation
CVSS v4.0 Score6.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 Score0.37% (31.62nd Percentile)
Affected Componentaxiom-crypto/snark-verifier (< 0.2.5)
Primary ImpactNon-canonical KZG accumulator limb encodings (EVM) and unhandled thread panics (Native)
Exploit / KEV StatusNo known public exploits / Not listed in CISA KEV

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
CWE-20
Improper Input Validation

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.

Vulnerability Timeline

GitHub Security Advisory GHSA-265x-v3qf-ff6p and CVE-2026-61618 published; snark-verifier v0.2.5 released.
2026-10-30
CVE-2026-61618 NVD record updated with CVSS v4.0 metrics and CWE-20 classification.
2026-11-05

References & Sources

  • [1]GitHub Security Advisory GHSA-265x-v3qf-ff6p
  • [2]Fix Commit d6aaf66d4706f5317cf61d5dbe00c14e7fbdbb70
  • [3]snark-verifier Release v0.2.5
  • [4]CVE.org Record: CVE-2026-61618
  • [5]NVD Detail: CVE-2026-61618
  • [6]CVEProject cvelistV5 JSON Record: CVE-2026-61618

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 2 hours ago•CVE-2026-63496
7.8

CVE-2026-63496: OS Command Injection in @augment-vir/node grep() Helper

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.

Alon Barad
Alon Barad
3 views•8 min read
•about 14 hours ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

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.

Amit Schendel
Amit Schendel
9 views•9 min read
•about 15 hours ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

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.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 16 hours ago•CVE-2026-14265
7.5

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

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.

Amit Schendel
Amit Schendel
6 views•10 min read
•about 17 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

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.

Amit Schendel
Amit Schendel
7 views•9 min read
•about 18 hours ago•CVE-2026-62336
8.5

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

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.

Amit Schendel
Amit Schendel
6 views•10 min read