Jadwal Sholat

Memuat jadwal sholatโ€ฆ

Ilmu Komputer & AI editorial

Open AccessOA2026

Lie to Me: Finding Bugs in ZK DSL Toolchains with Adversarial Witness Injection

Liezz: A Testing Framework that Exposes Soundness Bugs in Circom, Corset, Gnark, and Noir via Witness Splicing
Sebastian Watzinger; Christoph Hochrainer; Valentin Wรผstholz; Maria Christakisยท 2026ยท DOI 10.48550/arXiv.2608.30648

The core problem

Zero-knowledge domain-specific language (ZK DSL) toolchains compile programs into constraint systems and generate witnesses for cryptographic proofs. A central correctness requirement is **soundness**: the enforced constraints must be at least as strong as the source-program semantics. If a toolchain bug weakens the constraints, a prover can produce a proof for an invalid execution. Such soundness bugs are notoriously hard to detect because they are invisible to valid-execution testing: every valid execution still behaves correctly, so differential and regression tests on valid inputs pass.

The paper introduces **Liezz**, a testing framework that generates ZK DSL programs and exposes soundness bugs through *adversarial witness injection*. The key insight is that a correct toolchain must reject any witness that does not correspond to a valid execution. Liezz constructs such invalid witnesses by construction and checks whether the toolchain accepts them. Acceptance is a soundness bug.

Formally, for a deterministic program and two public input assignments with different outputs , Liezz splices the witness of one execution with the output of the other. Th

Innovation

Liezz was applied to four ZK DSL toolchains: **Circom, Corset, Gnark, and Noir**. The evaluation reports **13 bugs**, of which **seven have soundness impact**. Several of these bugs are reachable only through generated standard-library calls, demonstrating the value of parameterized library-call generation.

The central comparative result is that, under the same testing budget, a valid-execution baseline does **not** expose any of the soundness failures revealed by accepted injected witnesses. In other words, adversarial witness injection reaches failures that valid-execution testing misses entirely. This is consistent with the theoretical motivation: soundness bugs leave all valid executions correct, so they are invisible to tests that only run valid executions.

The reported numbers can be summarized as:

| Metric | Value |
|---|---|
| Toolchains supported | 4 (Circom, Corset, Gnark, Noir) |
| Bugs found | 13 |
| Bugs with soundness impact | 7 |
| Soundness failures found by valid-execution baseline | 0 |

The result that several bugs require generated standard-library calls is significant for practitioners: library gadgets are a high-value attack surface, and they are often unde

Zero-knowledge domain-specific language (ZK DSL) toolchains compile programs into constraint systems and generate witnesses for cryptographic proofs. A central correctness requirement is **soundness**: the enforced constraints must be at least as strong as the source-program semantics. If a toolchain bug weakens the constraints, a prover can produce a proof for an invalid execution. Such soundness bugs are notoriously hard to detect because they are invisible to valid-execution testing: every valid execution still behaves correctly, so differential and regression tests on valid inputs pass.
The paper introduces **Liezz**, a testing framework that generates ZK DSL programs and exposes soundness bugs through *adversarial witness injection*. The key insight is that a correct toolchain must reject any witness that does not correspond to a valid execution. Liezz constructs such invalid witnesses by construction and checks whether the toolchain accepts them. Acceptance is a soundness bug.

Why it matters

The paper's core contribution is a shift in testing philosophy for ZK DSL toolchains: instead of testing that valid programs behave correctly, Liezz tests that invalid witnesses are rejected. This is a *soundness-oriented* oracle, and it is strictly stronger than valid-execution testing for the class of bugs where constraints are weaker than source semantics.

The construction

with is invalid by construction, so acceptance is unambiguous evidence of a missing constraint. Controlled divergence and multiple splicing strategies are engineering choices that preserve enough consistency for the toolchain to reach the vulnerable constraint-checking path. Without this consistency, a toolchain might reject the witness for unrelated reasons, producing false negatives.

The support for **Circom, Corset, Gnark, and Noir** shows the approach generalizes across distinct DSLs and constraint-system backends. The finding that several bugs are reachable only through generated standard-library calls suggests that library-level constraint generation deserves dedicated fuzzing effort. The zero-detection result of the valid-execution baseline under the same budget is a strong empirical argument that adversarial witness injection is not merely a complementary technique but a necessary one for soundness assurance.

Limitations follow from the design: Liezz targets deterministic programs, and its effectiveness depends on the availability of two input assignments with divergent outputs. Programs with non-deterministic or under-constrained outputs may require different divergence strategies. Nonetheless, the framework provides a practical, automated path to finding soundness bugs that would otherwise remain invisible until exploited. For toolchain maintainers, integrating adversarial witness injection into CI pipelines is a concrete next step; for researchers, extending splicing strategies to richer constraint systems and non-deterministic programs is a natural direction.

Who should read this

CS practitioners and researchers

Opening member contentโ€ฆ