Dataset Viewer
Auto-converted to Parquet Duplicate
artifact_id
string
pair_id
string
source
string
finding_name
string
finding_explanation
string
relevant_code
string
paper_reference
string
edit_count
int32
files_touched
list
semantic_tags
list
requires
list
incompatible
list
artifact_path
string
artifact_sha256
string
zkGPT-001
zkgpt
real
Hyrax Commitment Before LogUp Witness Appended
The fixed code appends the LogUp lookup witness to val[0] before invoking pr.commitInput, so the Hyrax commitment binds the full witness including lookup entries. After injection, commitInput runs before append_to_witness, so the commitment covers only the pre-LogUp witness. A malicious prover can then substitute arbit...
src/neuralNetwork.cpp:375
Protocol 1 Step (1): P commits to aux and L before V derives challenges. All witness material (including lookup auxiliary values) must be bound by the commitment before the verifier proceeds.
1
[ "src/neuralNetwork.cpp" ]
[ "commit_logup_ordering" ]
[]
[]
artifacts/zkgpt/zkGPT-001.json
dd4b25a4eefc2facb16e0dcd899bf9fcf0c1edb0f244a3b6e0fdaa6082a27e25
zkGPT-002
zkgpt
real
Lasso Sum Verification Assert Removed
The Lasso/GKR sumcheck verification at verifier.cpp:826-827 checks that previousSum == g0 + g1 via a C++ assert() every round i != n. The injection deletes this if/assert pair entirely, so no per-round sumcheck check runs. Even when compiled with NDEBUG the original assert would be a no-op, but deleting the lines also ...
src/verifier.cpp:826
Section 2.3 (Lasso lookup protocol for range and exponentiation relations); Section 4.3 leveraging Lasso for non-arithmetic relations; Protocol 1 Step (3) Lasso invoked on range-check and exponentiation tables.
1
[ "src/verifier.cpp" ]
[ "lasso_sum_verification" ]
[]
[]
artifacts/zkgpt/zkGPT-002.json
7ff32d34d21aea1ca65055c3e40c9ba8fd232e10b281f5ba2dbec640f28e2216
zkGPT-003
zkgpt
real
FC Layer Bias Addition Removed
The fully-connected layer initializes val[layer_id][g] with the bias val[0][first_bias_id + co] and registers a uni_gate enforcing that equality before the matmul inner loop. The injection replaces both lines with val[layer_id][g]=0 and removes the uni_gate emplace. The circuit then proves Wx (no bias) instead of Wx+b ...
src/neuralNetwork.cpp:1428
Section 4 (Gadget composition); F-7 of Batch-Reports/v0.10/zkgpt_report.md.
1
[ "src/neuralNetwork.cpp" ]
[ "fc_bias_gate" ]
[]
[]
artifacts/zkgpt/zkGPT-003.json
c5b1e01ad0d77351f12580afaacb42a352bed003d6e413c0e94f61c14391a3fa
zkGPT-004
zkgpt
real
LayerNorm Gamma and Beta Collapsed to Identity
The fixed code seeds gamma with 1 + (i%3) and beta with (i%33)-16 so the committed LayerNorm parameters are non-trivial and bound by the subsequent addRangeBatch calls. The injection replaces both loops with gamma=1 and beta=0 across all channels, turning every LayerNorm into an identity transform. The values are still...
src/neuralNetwork.cpp:452
Section 4.1 (Normalization constraints): y_ij = gamma_j * (x_ij - mu_i)/sigma_i + beta_j; collapsing gamma to 1 and beta to 0 makes the normalization a pure pass-through after the mean/var subtraction.
1
[ "src/neuralNetwork.cpp" ]
[ "layernorm_params" ]
[]
[]
artifacts/zkgpt/zkGPT-004.json
38b63c2e70db3ee57fbb27e20eceecc483df272e52c75922d80137a677e2925c
zkGPT-005
zkgpt
real
FC Weight Matrix Zeroed Instead of Loaded
The fixed readFconWeight seeds each in-range weight mat_values[id][co*channel_in+ci] with a deterministic (co*channel_in+ci)%1024 placeholder (already a mock — flagged by zkgpt_report.md F-4). The injection replaces that with a constant 0, so every committed weight is zero. val_0 (which is val[0][first_fc_id + ...]) is...
src/neuralNetwork.cpp:1538
F-4 of Batch-Reports/v0.10/zkgpt_report.md (Mock weight data); Section 4 (model-binding via commitment).
1
[ "src/neuralNetwork.cpp" ]
[ "weight_initialization" ]
[]
[]
artifacts/zkgpt/zkGPT-005.json
8a8ec453a38549163d08d827e41117aa93e98c4dd12211808222d98b9bbd53ff
zkGPT-006
zkgpt
synthetic
LogUp Out-Of-Range Query Silently Clamped
The fixed LogUp append loop checks each query index against the multiplicity table size; if the index is out of range it prints a warning and uses `continue` to skip incrementing, so out-of-range queries are intentionally left uncounted and verify() later rejects the mismatch. The injection replaces the entire if-block...
src/logup.cpp:72
Section 2.3 (LogUp grand-product requires exact multiplicity counts); any deviation breaks the sumcheck identity that ties query and table multisets.
1
[ "src/logup.cpp" ]
[ "logup_counter_bounds" ]
[]
[]
artifacts/zkgpt/zkGPT-006.json
a966dcf074fe6b0e6ab595e7821836151eb9c3f02e84d045a59071dd9c79dab9
zkGPT-007
zkgpt
synthetic
Verifier Prove Function Short-Circuits To True
verifier::prove is the top-level verification driver — it invokes verifyGKR, verifyLasso, and verifyLookups and ANDs the three results into a final accept/reject. The injection replaces the local `bool ok = true;` at line 192 with `return true;`, so the function returns success before any sub-verifier runs. All GKR, La...
src/verifier.cpp:192
Protocol 1 Step (3-5): the verifier must execute all sumcheck, GKR, and Lasso subprotocols before accepting. Skipping them is a stub.empty_verify per taxonomy.
1
[ "src/verifier.cpp" ]
[ "verifier_prove_entry" ]
[]
[]
artifacts/zkgpt/zkGPT-007.json
f6c6e80d5cec98abd50a7c327bfbda31d8d23172f1a6ab76166aa8f64a275e5c
zkGPT-008
zkgpt
synthetic
LogUp Challenges Hardcoded To Fixed Values
The LogUp grand-product argument draws two challenges per table: gamma (for the random-linear combination of tuple components) and alpha (for the rational-sum reduction). In the fixed code these are sampled via setByCSPRNG() — already a weakness (local PRNG, not transcript-bound), but at least unpredictable. The inject...
src/logup.cpp:167
Section 3 (Technical Overview): Fiat-Shamir transformation requires challenges to be derived from a transcript that commits to all prior prover messages; hardcoded challenges allow adaptive forgery.
1
[ "src/logup.cpp" ]
[ "logup_challenge_derivation" ]
[]
[]
artifacts/zkgpt/zkGPT-008.json
3c6650c856f42765fc2e60b49a5ee8df9be8175600956b22e16d19a6fee15d0d
zkGPT-010
zkgpt
synthetic
GKR Layer Challenge Set To Constant
Inside the GKR per-layer loop, the verifier samples a challenge vector r_u[i][j] via setByCSPRNG() for j in [0, m) and then copies r_v[i][j] = r_u[i][j]. The injection replaces the .setByCSPRNG() call on line 524 with an assignment to Fr(1), so every fresh GKR layer challenge is the constant 1 (and r_v copies it, so it...
src/verifier.cpp:524
Section 4.2 (GKR per-layer sumcheck): the evaluation point for the next layer must be random to invoke Schwartz-Zippel.
1
[ "src/verifier.cpp" ]
[ "gkr_layer_challenges" ]
[]
[]
artifacts/zkgpt/zkGPT-010.json
c72e8ca6f5371c98075b8684c81c20274ac57ce0ba4a26b97ec2b49b7aaaee0d
zkGPT-011
zkgpt
real
Prover Vres Returns Zero Instead Of Output Evaluation
Vres is the prover's evaluation of the final output polynomial at a verifier-sampled random point; its result seeds previousSum for the final GKR sumcheck. The injection replaces `F res = output[0];` with `F res = F_ZERO;`, so Vres always returns 0 regardless of the committed output. Combined with zkGPT's pre-existing ...
src/prover.cpp:562
F-3 of Batch-Reports/v0.10/zkgpt_report.md (Output Not Exposed); Protocol 1 Step (5): verifier must independently provide or check y.
1
[ "src/prover.cpp" ]
[ "vres_output_evaluation" ]
[]
[]
artifacts/zkgpt/zkGPT-011.json
241b9261b5c3531c715ede5866371e4b3a3a7fcf7900acc9e21ab2657ebcac4c
zkGPT-012
zkgpt
synthetic
Range Batch Registration Silently Dropped
addRangeBatch is the entry point every layer uses to register range-check LookupQueries against the global LogUp queries_ vector (callers include LayerNorm gamma/beta, FC weights, attention scales, softmax normalization — 11 call sites across neuralNetwork.cpp). The injection replaces the reserve + push_back loop with ...
src/logup.cpp:42
Section 2.3 (Lasso/LogUp range checks); any commit to a witness that claims bit-width B requires a range-check lookup against [0, 2^B).
1
[ "src/logup.cpp" ]
[ "range_batch_registration" ]
[]
[]
artifacts/zkgpt/zkGPT-012.json
eded79940ea63e3e87143f7573e4110ae8942ffa31cca657318d20e7a99dbfed
zkGPT-013
zkgpt
synthetic
Softmax Exp Table Lookup Query Removed
Softmax is implemented via an approximate exp lookup: the prover computes tj = round(c1 * 2^(e1+eprime+1) * (pmax-pj) / 2^(eprime+1)) and reads E_off = table[tj]. The addExpTableQuery call registers a LogUp query asserting that (tj, table[tj]) is a valid row of the committed exp table. The injection deletes this call, ...
src/neuralNetwork.cpp:1229
Section 4.2 (Softmax via exp approximation): the (input, output) pair must be validated against the committed table to bind the approximation; F-1 of Batch-Reports/v0.10/zkgpt_report.md flags the broader Lasso-incomplete pattern.
1
[ "src/neuralNetwork.cpp" ]
[ "softmax_exp_lookup" ]
[]
[]
artifacts/zkgpt/zkGPT-013.json
ec629cb6e48bcdd64874647cbfd8250943e3b2f76fdcd3ae76d0aca0e7436bf4
zkGPT-014
zkgpt
synthetic
Softmax Scale Factor Evaluates to Unity
The three softmax sub-layers pass pow(1,-8) as the exponential scale parameter. Because 1 raised to any power equals 1, the effective scale is 1.0 instead of the intended pow(2,-8) = 1/256. This inflates all softmax logits by a factor of 256 before the lookup table, pushing values entirely outside the table's represent...
src/neuralNetwork.cpp:354-356
Section 4.1 (Softmax approximation): the exponential is evaluated via a lookup table indexed at scale 2^{-8}; substituting scale 1.0 renders the lookup domain incorrect.
1
[ "src/neuralNetwork.cpp" ]
[ "softmax_scale_factor" ]
[]
[]
artifacts/zkgpt/zkGPT-014.json
747b526fe924507217d1db54ee5eb9158da857641c6a974b6f0c612c86ada578
zkGPT-015
zkgpt
synthetic
Attention Dimension Scaling Factor Removed
The scaled dot-product attention formula is A = softmax(QK^T / sqrt(d))V. The injection replaces the computed 1/sqrt(d) divisor with a constant 1.0, removing dimension-dependent scaling. Without the sqrt(d) normalization, attention logits grow with hidden dimension, pushing softmax toward degenerate one-hot distributio...
src/neuralNetwork.cpp:1182
Section 4.1 (Attention mechanism): A = softmax(QK^T / sqrt(d_k))V; the 1/sqrt(d_k) factor is essential for numerical stability and correct attention distribution.
1
[ "src/neuralNetwork.cpp" ]
[ "attention_scaling_factor" ]
[]
[]
artifacts/zkgpt/zkGPT-015.json
9682c8ab920e2377b81f989cc6ae1973292fff702a05c77e3e17a2b89ba2c689
zkGPT-051
zkgpt
synthetic
GKR Phase-1 Sumcheck Rejection Removed
In the GKR verifier's phase-1 sumcheck, the per-round consistency check cur_claim == previousSum detects a mismatch but the `return false;` that rejects the proof is removed, so a prover whose phase-1 sumcheck does not hold is accepted.
src/verifier.cpp:574-574
Each GKR sumcheck round must reject if the claimed sum is inconsistent.
1
[ "src/verifier.cpp" ]
[ "gkr-sumcheck", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-051.json
f503f9912af3476bba43b66fa5454a6c8209c393e6b6aae9c4f288622f50e255
zkGPT-052
zkgpt
synthetic
GKR Phase-2 Sumcheck Rejection Removed
The phase-2 sumcheck round check poly(0)+poly(1) == previousSum still prints on mismatch, but its `return false;` is removed, so an inconsistent phase-2 sumcheck no longer rejects the proof.
src/verifier.cpp:616-616
The phase-2 sumcheck must reject when the round polynomial is inconsistent.
1
[ "src/verifier.cpp" ]
[ "gkr-sumcheck", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-052.json
ebfe03ea04e590c86479edeacd538c82801126f1069369cea311d282498a3a07
zkGPT-053
zkgpt
synthetic
GKR Final-Value Consistency Rejection Removed
At the end of each GKR layer the verifier compares previousSum to the recomputed final value; its `return false;` is removed, so a layer whose final claim does not match the gate evaluation is accepted.
src/verifier.cpp:644-644
The GKR layer final value must equal the recomputed gate evaluation.
1
[ "src/verifier.cpp" ]
[ "gkr-final", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-053.json
f29d2c6779d6e7dce2325a945378ed0a46426970d77f4d215fd5ffff351405bb
zkGPT-054
zkgpt
synthetic
Sumcheck Base-Case Product Assert Removed
The base-case assert that the folded sumcheck answer equals f(r)*g(r) is removed, so the final product claim of the degree-2 sumcheck is no longer checked.
src/verifier.cpp:455-455
The sumcheck base case must verify the final product equals the folded claim.
1
[ "src/verifier.cpp" ]
[ "sumcheck-base", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-054.json
c3106c8e2857371ba9263de3a2fa682354719f80febeaeb1c07dcd9ca1b30c2c
zkGPT-055
zkgpt
synthetic
GKR Round-Sum Assert Removed
The per-round assert previousSum == g0+g1 (the sumcheck round reconstruction) is removed, so a round polynomial inconsistent with the carried sum is no longer caught.
src/verifier.cpp:827-827
Each sumcheck round must satisfy previousSum = p(0)+p(1).
1
[ "src/verifier.cpp" ]
[ "gkr-sumcheck", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-055.json
113f675780944a673545ea09b3b95795577eccf4792e9cb8defc023facd793bc
zkGPT-056
zkgpt
synthetic
Final Input-Evaluation Binding Assert Removed
The final assert tying the committed input evaluation (eval_in*gr) to the carried sumcheck claim is removed, so the proof's final linkage between the GKR output and the committed input is unchecked.
src/verifier.cpp:870-870
The final GKR claim must bind to the committed input evaluation.
1
[ "src/verifier.cpp" ]
[ "input-binding", "dropped-check" ]
[]
[]
artifacts/zkgpt/zkGPT-056.json
84d4282c0ba1550710059773409407a06a9b66d8d52cced1846e17c39e332b7e
zkLLM-001
zkllm
real
ReLU Prove Body Throws Instead of Proving
The zkReLU::prove() method throws std::runtime_error instead of executing the 5-step protocol (boolean sign check, Hadamard sumcheck, tLookup range proofs). Any pipeline that invokes ReLU produces no proof, leaving all ReLU outputs completely unconstrained.
zkrelu.cu:58
Example 4.2 (Section 4): ReLU with rescaling verified via two tlookup instances — "By requiring the prover to demonstrate Z'+αA ⊂ TX+αTY... and R ⊂ TR, both using Protocol 1, in addition to proving the decomposition as Z = γZ'+R, we can sufficiently validate the correctness of inference through the ReLU function."
1
[ "zkrelu.cu" ]
[ "relu_prove_body" ]
[]
[]
artifacts/zkllm/zkLLM-001.json
f61cc68fee61a06a1b756f1065f93bea784bef39cd6d40efa4127409213211bf
zkLLM-002
zkllm
real
Skip-Connection Linearity Check Removed
The skip-connection prover's local linearity check (sum_xy == z_hat) is removed. The opening proofs at u are still computed and written to <output>.proof, but the commit-time self-check that would catch a com_z ≠ commit(x+y) mismatch is gutted, so a dishonest prover who opens a forged com_z passes this stage locally.
skip-connection.cu:151
Section 3.3 / Section 6.2: all arithmetic tensor operations (including addition) are verified via the sumcheck protocol; Section 6.2 describes proof assembly covering the full computational graph
1
[ "skip-connection.cu" ]
[ "skip_connection_linearity" ]
[]
[]
artifacts/zkllm/zkLLM-002.json
0232cf0aa8e2ecb10a94b383abbd1690a543923035140d1db0a96d919cfdb41c
zkLLM-003
zkllm
real
RMSNorm Inverse Witness Not Absorbed into Transcript
The RMSNorm inverse (1/sqrt(mean(x^2)+eps)) is computed in Python and loaded from rms_inv_temp.bin. The Fiat-Shamir absorb of the inverse witness is removed, so subsequent challenges are not bound to this witness. A malicious prover can substitute any normalization factor without affecting the transcript.
rmsnorm.cu:48
Section 6.1.3: "The compound non-arithmetic operations of square-root and inverse are managed through two sequential tlookup steps."
1
[ "rmsnorm.cu" ]
[ "rmsnorm_witness_absorb" ]
[]
[]
artifacts/zkllm/zkLLM-003.json
e0a72bea43a0533a9f4b94b4cb97b48d9e1581559577cb6a89ff5a05887f24ad
zkLLM-004
zkllm
real
tLookup A/B Commitments Removed
The tLookup protocol's intermediate values A (inverse of shifted S) and B (inverse of shifted table) are computed after beta is drawn but their commit_and_absorb calls are removed. Subsequent challenges for the grand-product check are not bound to A and B, allowing the prover to adaptively choose these inverses after s...
tlookup.cu:401
Protocol 1 (Lines 6–7): prover must commit ⟦S⟧ and ⟦m⟧ before verifier sends challenge β (Line 10); Protocol 2 (Line 22): all auxiliary commitments sent before interactive proof in zkAttn-Prove
1
[ "tlookup.cu" ]
[ "tlookup_AB_commitment" ]
[]
[]
artifacts/zkllm/zkLLM-004.json
9537781e4d4f4eb0dda261d2cfa52e43da35cec4e56a769b034f03c53c0157ab
zkLLM-005
zkllm
real
Fiat-Shamir Transcript Replaced with Local PRNG
The fs_challenge_vec() function is replaced with random_vec(), which uses a process-local std::mt19937 PRNG seeded from std::random_device. Challenges are no longer derived from the Fiat-Shamir transcript, making the proof interactive-only and allowing a malicious prover to predict or replay challenges.
fr-tensor.cu:44
-
1
[ "fr-tensor.cu" ]
[ "fiat_shamir_challenge_dispatch" ]
[]
[]
artifacts/zkllm/zkLLM-005.json
4854e809cf0f0d86d9a70e1a38e66bc71f5e6ff28b9d323ca92f28b42d270c6d
zkLLM-006
zkllm
synthetic
Cross-Stage Commitment Chain Verification Removed
The verify-pipeline chain check `if (!bytes_equal(prev.output_com, curr.input_com)) { ... ++chain_bad; continue; }` at main.cu:302-311 is removed. This is the only check that detects cross-stage commitment substitution: without it, every pair of adjacent stages is counted as chain_ok regardless of whether stage N's out...
main.cu:302
Section 6.2: "proofs are assembled in reverse logical order of the arithmetic circuits, methodically reducing the claimed multilinear extension values of the output y to those associated with the prompt X and the model parameters W."
1
[ "main.cu" ]
[ "pipeline_commitment_chain" ]
[]
[]
artifacts/zkllm/zkLLM-006.json
4d682459c2a0c778f75dad29cbe6986e9a456b9bf4615933cf40a41ef28d5b9d
zkLLM-007
zkllm
synthetic
Stage Proof Transcript Digest Omitted
The write_stage_proof function's final transcript digest write is removed. The .proof file no longer contains the 32-byte sealed digest that binds all absorbs and challenges. A verifier cannot confirm that the proof was generated from a consistent transcript, breaking the pipeline's integrity guarantee.
stage_proof.cuh:215
Section 6.2: proof assembly covering the full computational graph
1
[ "stage_proof.cuh" ]
[ "stage_proof_digest" ]
[]
[]
artifacts/zkllm/zkLLM-007.json
c5b6bbe23602c4d5d63d6b3d47ad585b3d9bcecf10ded0997ad1e6ea22e38725
zkLLM-008
zkllm
real
Softmax Segment Count Reduced (K=3 to K=2)
The zkSoftmax constructor call in self-attn.cu changes the segment base vector from {1<<8, 1<<20, 1<<20} (K=3) to {1<<8, 1<<20} (K=2), removing one piecewise segment. This invalidates the paper's Theorem 7.1 error-bound analysis and changes the approximation domain, producing a weaker softmax approximation with unbound...
self-attn.cu:146
Section 8: "we deployed K = 5 tlookups, each of size 2^16. This setup includes L = 3 least significant segments"; Theorem 7.1 and Eq. (33): error bound depends on K−M−L
1
[ "self-attn.cu" ]
[ "softmax_segmentation" ]
[]
[]
artifacts/zkllm/zkLLM-008.json
356a52a2f1bab4da8a46df4fd64364c1c85b66e77e2f92d94284a480ca946172
zkLLM-011
zkllm
real
Softmax Row-Sum Normalization Check Removed
The softmax proof omits the row-sum normalization check that ensures each row of Y sums to approximately theta within tolerance E. Without this check the prover can output arbitrary softmax values whose rows do not sum to 1, proving a weaker relation than Theorem 7.1 requires.
zksoftmax.cu:206
Section 5.1 Step (4): "an additional check is introduced to ensure the rowwise sums of Y equal 1"; Protocol 2 (Lines 34–35): tlookup-Prove on ŷ against TR; Theorem 7.1 (3): "εattn defines the tolerable error... the sum of each row must lie within [(1−εattn)θ, (1+εattn)θ]"
1
[ "zksoftmax.cu" ]
[ "softmax_row_sum_check" ]
[]
[]
artifacts/zkllm/zkLLM-011.json
6fca532cc7f1b524198362a2b492d7f3729615a361bb2e70f15bfbd1f68dfd0f
zkLLM-012
zkllm
real
Lookup Table Values Not Committed
The lookup table T is initialized deterministically but tLookupRange::commit_table is emptied, so the table is never Hyrax-committed and its commitment is never absorbed into the Fiat-Shamir transcript. tLookupRange is the base for tLookupRangeMapping (SwiGLU table in ffn.cu), the rescaling remainder table (rescaling.c...
tlookup.cu:36
Protocol 1 Line 2: "⟦T⟧ ← Commit(T; 0)" — the paper requires the lookup table T to be committed via tlookup-Setup before use
1
[ "tlookup.cu" ]
[ "tlookup_table_commitment" ]
[]
[]
artifacts/zkllm/zkLLM-012.json
6519a2ef0e012c10dd37922a178c8df6c8e615f7efaa00dade371cc42643870e
zkLLM-013
zkllm
synthetic
Skip-Connection Verifier Body Replaced with return true
verify_skip in main.cu is the entry point for the 'main verify-skip' command. Lines 138-204 contain the Pedersen commitment recomputation, opening checks (for com_x, com_y, com_z), and the MLE-linearity check z_hat == x_hat + y_hat. Replacing that entire block with 'return true;' turns the command into a trivial accept...
main.cu:138
Section 4 (skip-connection / residual protocol): verifier checks three Pedersen openings at a Fiat-Shamir point u and then the MLE linearity z_hat = x_hat + y_hat; the combination reduces the vector equation z = x + y to a single-scalar Schwartz-Zippel argument.
1
[ "main.cu" ]
[ "skip_verifier_body_stub" ]
[]
[]
artifacts/zkllm/zkLLM-013.json
3140ee7b9f85f5bfa63f9925b418416b9ce7071e722f0c9b75ece2d237701317
zkLLM-014
zkllm
synthetic
Rescaling Fiat-Shamir Challenges Replaced with Constant One-Vectors
Rescaling::prove draws three Fiat-Shamir challenge vectors that drive the tLookup range proof on the remainder tensor: 'rescaling/u' and 'rescaling/v' (the sumcheck evaluation points) and 'rescaling/rand_temp' (the two tLookup blinding scalars). Replacing the three fs_challenge_vec(...) calls with constant {1,0,0,0,0,0...
rescaling.cu:52
Section 4.2 (Rescaling / range-check via tLookup) and Protocol 1 (tLookup): the tLookup range proof is sound only when the challenge beta and the sumcheck evaluation point u are drawn from the Fiat-Shamir transcript after the prover commits to the counter polynomial m and the remainder S.
1
[ "rescaling.cu" ]
[ "rescaling_fs_challenge_hardcoded" ]
[]
[]
artifacts/zkllm/zkLLM-014.json
4418fa4822d45d75f93dee8235c14724d48ad54d22bf91a0d9579d353f8a729e
zkLLM-015
zkllm
synthetic
FFN Output Saved at Wrong Rescaling Level
The FFN down-projection produces down_out at scale gamma-squared. The rescaling step computes down_out_ at scale gamma. The injection reverts the save and commit calls to use the unrescaled down_out instead of down_out_, creating a scale mismatch: the committed FFN output is at gamma^2 while the downstream skip-connect...
ffn.cu:137, ffn.cu:152
Section 3.5 (Rescaling): each matrix multiplication doubles the quantization exponent; the rescaling operator must be applied before the result is committed to restore the canonical scale gamma.
2
[ "ffn.cu" ]
[ "ffn_output_rescale_commit" ]
[]
[]
artifacts/zkllm/zkLLM-015.json
bfa9cc2bf2c8c730b4adbd7baf93fd673ec55d23f080217c2d6b7d544669611b
zkML-001
zkml
real
Hardcoded Freivalds Challenge Vector
The Freivalds random-check vector r is replaced with a hardcoded constant instead of being derived from the Halo2 challenge API. A malicious prover can precompute a MatMul forgery that satisfies the deterministic check with 100% probability, breaking the Schwartz-Zippel soundness guarantee.
src/model.rs:210
Section 6.1 (Linear layers): "Freivalds' algorithm... we can take a random vector r and verify that Br = WAr... The random vector r must be generated after the matrix and results are committed."
1
[ "src/model.rs" ]
[ "freivalds_challenge_source" ]
[]
[ "zkML-007" ]
artifacts/zkml/zkML-001.json
6c040a1c2d8ab37c682546c8d66e39bd5c1731b55948ddcc09935c6517036867
zkML-002
zkml
real
Weight Commitment Silently Disabled
The commit_before list that controls which tensors are committed before proving is replaced with an empty vec, silently disabling all weight commitments. A malicious prover can substitute arbitrary model weights without detection.
src/model.rs:501
Section 4.3 (Security): "the knowledge soundness property intuitively means that the prover must know the input and the weights"
1
[ "src/model.rs" ]
[ "weight_commitment_config" ]
[]
[]
artifacts/zkml/zkML-002.json
73681543ad23e6e76d0b9ec38948206952d1f31ff5a078476a036a1980173fe9
zkML-003
zkml
real
Unconstrained AvgPool Divisor
The AvgPool2D divisor is placed in an advice cell without a copy-constraint to the fixed column. The prover can set the divisor to 1, outputting the numerator unchanged and producing arbitrary average-pool results.
src/layers/avg_pool_2d.rs:62
Section 5.1 (Specialized operations, Variable division): "b = c · a + r for r ∈ [0, ..., a). Thus, we can use the polynomial constraint b − c · a − r = 0 and constrain that a − r ∈ [0, ..., N)"
1
[ "src/layers/avg_pool_2d.rs" ]
[ "avgpool_divisor_constraint" ]
[]
[]
artifacts/zkml/zkML-003.json
dd663a3e68737f781f211bcbe7cd8292149e47984dd4ba608117e7fb7e9e8c9a
zkML-004
zkml
real
Unconstrained DivFixed Divisor
The DivFixed layer's divisor is placed in an advice cell without a copy-constraint to the fixed column. The prover can set the divisor to any value, bypassing the compile-time scaling factor and producing arbitrary rescaled outputs.
src/layers/div_fixed.rs:50
Section 5.1 (Specialized operations, Variable division): "b = c · a + r for r ∈ [0, ..., a). Thus, we can use the polynomial constraint b − c · a − r = 0 and constrain that a − r ∈ [0, ..., N)"
1
[ "src/layers/div_fixed.rs" ]
[ "divfixed_divisor_constraint" ]
[]
[]
artifacts/zkml/zkML-004.json
bb75c6c7feec5b10e5746503d8b803fcbdcb166d31a6eae7ada52f8c651aebcd
zkML-005
zkml
synthetic
Dot-Product Partial Sums Left Unaggregated
The dot-product gadget's final AdderChip aggregation step is removed; partial row sums are returned directly without being summed into a single constrained output. The prover can supply arbitrary partial results that do not sum to the correct dot product.
src/gadgets/dot_prod.rs:198
Section 6.1 (Linear layers / dot product): matmul is computed as row-wise dot products; the gadget aggregates partial-row sums via an AdderChip so the single-cell output is bound to the full sum.
1
[ "src/gadgets/dot_prod.rs" ]
[ "dotprod_aggregation" ]
[]
[]
artifacts/zkml/zkML-005.json
b7bc0dc345012435ccc3c8074f43d366b85fdc95963a551dcf06ee046d7ee45b
zkML-006
zkml
synthetic
FC Layer Bias Addition Removed
The fully-connected layer's bias addition branch is removed. Even when a bias tensor is present (tensors.len() == 3), it is silently ignored. The circuit proves a different linear operation (Wx instead of Wx+b) than the model specifies.
src/layers/fc/fc_dpb_vdiv_lookup.rs:89
-
1
[ "src/layers/fc/fc_dpb_vdiv_lookup.rs" ]
[ "fc_bias_addition" ]
[]
[]
artifacts/zkml/zkML-006.json
4fcb4ae745776920d65dbbf7ada6b53b2aef819002b05f92114d6e72686a2de8
zkML-007
zkml
synthetic
RLC Challenge Replaced with Small Constant
The RLC/Freivalds challenge is replaced with the literal constant 42 instead of being drawn from the Halo2 Phase-2 challenge API. Since the challenge is predictable and tiny, the prover can craft witnesses that satisfy the random linear combination check without performing the correct matmul computation. This is a smal...
src/model.rs:210
Section 6.1 (Linear layers): "The random vector r must be generated after the matrix and results are committed."
1
[ "src/model.rs" ]
[ "freivalds_challenge_source" ]
[]
[ "zkML-001" ]
artifacts/zkml/zkML-007.json
e69e6c742b6a05dffd9d715b51ee863b9140987e5a057d8600f2ff54b647b4a6
zkML-008
zkml
synthetic
Softmax Division Remainder Unchecked
The VarDivRound gadget's lookup-based range checks on the remainder r and the (2b - r) term are removed from the rounded-division gate. Without these range checks the prover can supply an arbitrary remainder that wraps around the field, producing any desired softmax or rescale output. The b range-check on line 82 is le...
src/gadgets/var_div.rs:62
Section 5.1 (Variable division): "b = c · a + r for r ∈ [0, ..., a)" — remainder r must be range-checked via lookup
1
[ "src/gadgets/var_div.rs" ]
[ "var_div_range_checks" ]
[]
[]
artifacts/zkml/zkML-008.json
b14cae912768719d46f466664a81ad18684568810eaaeceb08afccaf088b54a2
zkML-010
zkml
synthetic
Non-Linear Lookup Input Expression Zeroed
The non-linearity gadget enforces (inp, outp) ∈ T via a two-column lookup where T maps every in-range input to its activation output. The input-side lookup expression is rewritten from `(s * (inp + shift_val_pos), inp_lookup)` to `(s * 0, inp_lookup)`, which always matches entry 0 of the InputLookup range table and unc...
src/gadgets/nonlinear/non_linearity.rs:50
Section 5.1 (Non-linear operations / lookup-based activations): each activation is proved by a two-column lookup (inp, outp) ∈ T where T is the enumerated (input, f(input)) table; both tuples must be queried for the lookup to bind inp to outp.
1
[ "src/gadgets/nonlinear/non_linearity.rs" ]
[ "non_linearity_lookup_input" ]
[]
[]
artifacts/zkml/zkML-010.json
d8928f8c7c8649bdf4db726017f5e37590233c0b400db8e87e07a33f7302c1c8
zkML-011
zkml
synthetic
Inference Output Not Bound to Public Instance
After running the DAG, ModelCircuit::synthesize exposes two sets of cells as public instance values: (a) the pre-DAG commitments (one cell per tensor index in commit_before/commit_after) and (b) every cell of the inference result tensors. The second loop — the one that calls `constrain_instance` over `result` — is remo...
src/model.rs:898
Section 6.2 (End-to-end soundness): the circuit's claimed output must be exposed as public instance values so the verifier can compare the proven output to the public statement. Without this binding, the ZK proof is a proof of some unspecified output, not the public one.
1
[ "src/model.rs" ]
[ "result_public_instance_binding" ]
[]
[]
artifacts/zkml/zkML-011.json
ddbff450cd263054187f7d108b56ecca6c635a096354d69ba3a2c26b12d0588f
zkML-012
zkml
synthetic
Residual Add Constraint Replaced with Pass-Through
AddChip::gadget_forward normally constructs an AddPairsChip and invokes `add_pairs_chip.forward(...)` to enforce `z = x + y` as an in-circuit gate constraint for every element. The injection replaces the chip call with a pass-through that returns the first input tensor's cells unchanged. Because AddPairsChip is what in...
src/layers/arithmetic/add.rs:46
Section 4 (Gadget composition): every ONNX operator must lower to a gate that constrains its output to its inputs. An operator that returns input[0] unchanged but is reported as an Add in the DAG breaks this invariant.
1
[ "src/layers/arithmetic/add.rs" ]
[ "add_chip_gadget_forward" ]
[]
[]
artifacts/zkml/zkML-012.json
76e20184b4ae2984c6108104471cc6f193622de374bb63311e5e9942e6dfb1ec
zkML-013
zkml
synthetic
Non-Linear Activation Lookup Replaced with No-Op
The non-linearity gadget (ReLU, Sigmoid, Tanh, Exp, Sqrt, GELU, Logistic) normally enforces a two-column Halo2 `meta.lookup("non-linear lookup", ...)` that pins `(inp + shift, outp) ∈ T` where T is the enumerated activation table. The injection removes the entire `meta.lookup` call inside the per-op-column for-loop, le...
src/gadgets/nonlinear/non_linearity.rs:42
Section 5.1 (Lookup-based non-linearities): ReLU/Sigmoid/Tanh/etc. are proved by enumerating f: [min_val, max_val] → F in a lookup table and asserting (inp, outp) ∈ T. Without the meta.lookup call the table exists but is never consulted.
1
[ "src/gadgets/nonlinear/non_linearity.rs" ]
[ "non_linearity_meta_lookup" ]
[]
[ "zkML-010" ]
artifacts/zkml/zkML-013.json
eb6d64a0ffd3835e5ee56ad33db90a071cdd8dffaa2551569fddf1868408094a
zkML-014
zkml
synthetic
Var-Div Divisor Range Check Removed (Overflow Vector)
VarDivRoundChip exposes three range-check lookups covering (a) the remainder r ∈ [0, 2^N), (b) 2b−r ∈ [0, 2^N), and (c) the divisor b ∈ [0, 2^N). All three use the same InputLookup table which enumerates 0..num_rows. The injection deletes only the third lookup — the one that bounds the divisor b itself. The arithmetic ...
src/gadgets/var_div.rs:81
Section 5.1 (Variable division): all three of r, 2b−r, and b must be range-checked against [0, 2^N) for the rounded-division identity to prove the intended quotient. Removing the b-range bound is sufficient to forge.
1
[ "src/gadgets/var_div.rs" ]
[ "var_div_b_range_check" ]
[]
[ "zkML-008" ]
artifacts/zkml/zkML-014.json
a2ebfb429e76aa4ba9b8e527de9fcc09a886bfa62659a2b9b0714e6716ee8120
zkML-015
zkml
synthetic
Selector Constraint Enforcement Disabled by Default
The circuit configuration flag use_selectors controls whether Halo2 selector columns are enabled during synthesis. Selectors mask which rows participate in each constraint gate; without them, constraints apply to all rows including padding rows that contain unconstrained witness values. The injection flips the default ...
src/model.rs:503
Section 5 (Circuit implementation): the Halo2 backend uses selector columns to restrict polynomial constraints to active rows; disabling selectors violates the row-isolation invariant.
1
[ "src/model.rs" ]
[ "selector_constraint_default" ]
[]
[]
artifacts/zkml/zkML-015.json
c43720fba1aa1c634806a81b2abc0385d0f44c543155951d05f203ea6ee6c45f
zkML-053
zkml
synthetic
Max Keeps Only One Per-Pair Range Bound
MaxChip proves a pairwise maximum with an arithmetic gate (inp1 - outp) * (inp2 - outp) = 0, which pins the output to one of the two inputs, plus two range lookups outp - inp1 in [0, N) and outp - inp2 in [0, N) that force the output to be at least as large as each input. The second lookup, outp >= inp2, is removed, so...
src/gadgets/max.rs:61-68
A pairwise max must lower-bound the output by both inputs; keeping only one bound lets the gadget attest a non-maximal output.
1
[ "src/gadgets/max.rs" ]
[ "max_pair_range_bound" ]
[]
[]
artifacts/zkml/zkML-053.json
746bb5db1abdf37324141458261cf3281680c2125e6de7a16c7f06355b4b23a1
zkML-054
zkml
real
Fixed-Point Divisor Not Bound to the Public Scale Factor
The fixed-point division assigns the divisor `div` as a prover-controlled advice value and relies on `region.constrain_equal(div_fixed, div)` to pin it to the committed public scale factor. With that equality removed, the divisor is free: a malicious prover sets any `div`, so the attested quotient (and hence every resc...
src/layers/div_fixed.rs:44-50
The rescaling divisor must equal the committed public scale factor; the fixed-point quotient is only sound if the divisor is constrained, not prover-chosen.
1
[ "src/layers/div_fixed.rs" ]
[ "unconstrained-divisor", "fixed-point-rescale" ]
[]
[]
artifacts/zkml/zkML-054.json
f61e5c4ea273c7cea1393d5feb2c77f10b97424139bb0c8bb60889636dfd4d4b
zkML-055
zkml
real
AvgPool Divisor Unconstrained (window size not bound)
AvgPool divides the window sum by the pool size via a prover-controlled advice `div`, pinned to the public divisor only by `region.constrain_equal(div_fixed, div)`. Removing that equality lets a malicious prover pick any divisor, so the attested average is arbitrary. Audit-derived: the original uiuc-kang-lab/zkml avg_p...
src/layers/avg_pool_2d.rs:54-60
An average-pooling output is only sound if the divisor equals the committed window size; a prover-chosen divisor breaks the attested mean.
1
[ "src/layers/avg_pool_2d.rs" ]
[ "unconstrained-divisor", "fixed-point-rescale" ]
[]
[]
artifacts/zkml/zkML-055.json
d8294575e327c8d5a82d90326c1414150ff4b732ed8fb624242ac6665217bce1
zkML-056
zkml
synthetic
VarDiv Remainder Range Check Dropped
VarDivRound enforces the remainder r in [0,2^N) via a lookup. Removing it lets the prover pick a remainder outside the valid range, so the gate 2a+b=2bc+r admits a forged quotient c and the rounded division output becomes arbitrary.
src/gadgets/var_div.rs:65-70
Rounded fixed-point division is sound only if the remainder is range-checked.
1
[ "src/gadgets/var_div.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-056.json
e4c483a301449550b03d66f6ed591bf9e04183eb6d46988ee1cbbfe4fec63efb
zkML-057
zkml
synthetic
VarDiv Upper-Bound (2b-r) Range Check Dropped
The companion lookup bounding 2b-r in [0,2^N) (i.e. r<=2b) is removed, freeing the remainder's upper bound and letting the quotient be inflated.
src/gadgets/var_div.rs:73-79
Both remainder bounds must be enforced for the division to pin a unique quotient.
1
[ "src/gadgets/var_div.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-057.json
ed9768b1cf068da0ad5874f88feb6cdf1271b5c39e34ee33249cadcd51022523
zkML-058
zkml
synthetic
SqrtBig Output Not Range-Checked
sqrt_big attests y=floor(sqrt(x)). The lookup constraining the claimed sqrt to the valid table is removed, so the prover can claim an out-of-range sqrt value and the attested square root is unconstrained.
src/gadgets/sqrt_big.rs:62-67
A square-root gadget is sound only if the claimed root is range-checked.
1
[ "src/gadgets/sqrt_big.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-058.json
f6e99077d53b4627ba554c062bceb5b2d374b0d521db066574888918828b3e6e
zkML-059
zkml
synthetic
SqrtBig Remainder Not Range-Checked
The remainder lookup in sqrt_big (rem+sqrt in table) is removed, so the remainder term that ties the claimed root to x is free, admitting a forged root/remainder pair.
src/gadgets/sqrt_big.rs:69-75
The sqrt remainder must be range-checked so that x - y^2 lies in the valid interval.
1
[ "src/gadgets/sqrt_big.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-059.json
43b2f581c50894527b9bf271dc2e206b425a838c9f1cad564709b381f80fe7c6
zkML-060
zkml
synthetic
Non-Linear Activation Lookup Dropped
Generic non-linear activations are attested by a lookup mapping input to the tabulated output. Removing the lookup lets the prover claim an arbitrary activation output for any input.
src/gadgets/nonlinear/non_linearity.rs:42-53
Non-linear activation outputs are sound only if bound to the input via the activation lookup table.
1
[ "src/gadgets/nonlinear/non_linearity.rs" ]
[ "activation-lookup", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-060.json
d38436efbac8ee6a06deff629740e490584c0ad95df48a4058ee06946e557306
zkML-061
zkml
synthetic
RLC-Freivalds Output Equality Dropped (FC lookup variant)
The fully-connected RLC-Freivalds check binds the committed output C to the inputs via the single equality r1^T C r2 == (r1^T A)(B r2). Removing this constrain_equal leaves the matmul output C completely unbound to A,B, so any C is accepted.
src/layers/fc/fc_rlc_vdiv_lookup.rs:159-159
The RLC-Freivalds equality is the sole link between the committed matmul output and its inputs.
1
[ "src/layers/fc/fc_rlc_vdiv_lookup.rs" ]
[ "matmul-binding", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-061.json
0a79a5672b15771d5cb0221b5d8087554930a5a1cce48201dfa84a4d08e9e424
zkML-062
zkml
synthetic
RLC-Freivalds Output Equality Dropped (FC relu-div variant)
Same RLC-Freivalds binding equality as the lookup variant, in the relu-div fused FC path; removing it unbinds the attested matmul+activation output from its inputs.
src/layers/fc/fc_rlc_vdiv_relud.rs:159-159
The fused FC path must still enforce the RLC-Freivalds equality to bind its output.
1
[ "src/layers/fc/fc_rlc_vdiv_relud.rs" ]
[ "matmul-binding", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-062.json
e1f27d114ee073bcbd45fd5ece36b5b0425fc877962910b0f87955515ec72c0d
zkML-063
zkml
synthetic
Dot-Product Gate Dropped
The core dot-product constraint sum_i a_i*b_i = out is removed, so the attested inner product, and every matmul/convolution cell built on it, is unconstrained.
src/gadgets/dot_prod.rs:43-62
Matmul and convolution soundness rest on the dot-product gate enforcing the summation.
1
[ "src/gadgets/dot_prod.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-063.json
f5d2d7c7b6f81bf145d6da885619be7555cb847f7fd83825e7c1e24802a4ad2c
zkML-064
zkml
synthetic
Squared-Difference Gate Dropped
The (a-b)^2 = out constraint is removed; variance, L2 distance and normalization terms that rely on it become arbitrary.
src/gadgets/squared_diff.rs:35-49
Squared-difference outputs must be constrained to the squared input gap.
1
[ "src/gadgets/squared_diff.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-064.json
903193069ad3656901cc75da55e0c477627a8e98a59a945be064463bb5ed2516
zkML-065
zkml
synthetic
Adder Gate Dropped
The addition constraint a+b=out is removed, so accumulations (bias adds, residual sums) are unconstrained.
src/gadgets/adder.rs:31-44
Additions must be enforced by the adder gate.
1
[ "src/gadgets/adder.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-065.json
7747edc0692ec3331d1b3d8f15fa455038787f65920b8471437a2745eae85c0e
zkML-066
zkml
synthetic
Pairwise-Multiply Gate Dropped
The pairwise product constraint a*b=out is removed, so elementwise multiplies are unconstrained.
src/gadgets/mul_pairs.rs:35-49
Elementwise products must be enforced by the multiply gate.
1
[ "src/gadgets/mul_pairs.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-066.json
0b02a88035b6444fecef2749bc30f520001ef44aaf8b9c636d23bd93e7dd7bd0
zkML-067
zkml
synthetic
VarDivBig Remainder Range Check Dropped
The large-operand division's remainder range lookup is removed, freeing the remainder and admitting a forged quotient for wide-bitwidth rescales.
src/gadgets/var_div_big.rs:81-85
Wide fixed-point division is sound only if its remainder is range-checked.
1
[ "src/gadgets/var_div_big.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-067.json
2c58e8e044eedaaac80342e1fb52303ae0426b88d54bd0987dd2fed9102f1af0
zkML-068
zkml
synthetic
BiasDivFloorRelu6 Output Lookup Dropped
The fused bias+floor-div+relu6 output lookup that ties the clamped activation to the quotient is removed, so the attested activation output is no longer bound to the computed quotient.
src/gadgets/bias_div_floor_relu6.rs:76-82
The fused activation output must be bound to the quotient via its lookup.
1
[ "src/gadgets/bias_div_floor_relu6.rs" ]
[ "activation-lookup", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-068.json
04f508450ff1b2ff4dd6c55c4160ead7a96ce65b4fe25d0ef42ebf3b65856134
zkML-069
zkml
synthetic
Modulus Range Lookup Dropped (update gadget)
The lookup enforcing mod_res in [0, DIV_VAL) in the update/optimizer gadget is removed, so the modulus term is unconstrained and the rescaled update can be forged.
src/gadgets/update.rs:68-74
The modulus must be range-checked to [0, DIV_VAL).
1
[ "src/gadgets/update.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-069.json
78862d9832968de7abf60defec34b540df556b786b113e75134f7f44460222f2
zkML-070
zkml
synthetic
VarDivBig Arithmetic Gate Dropped
The core 2a+b = 2bc+r division identity gate for the wide-operand path is removed, so the quotient and remainder are no longer tied to the dividend.
src/gadgets/var_div_big.rs:41-73
The division identity gate is the arithmetic backbone of the rounded division.
1
[ "src/gadgets/var_div_big.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-070.json
cd07a7600ff3c9efe44b9d27f4555197999a368df2052eef432fd6d454032ea5
zkML-071
zkml
synthetic
Square Gate Dropped
The x*x=out constraint is removed, so squared terms (used in variance, L2, attention scores) are unconstrained.
src/gadgets/square.rs:30-38
Squaring must be enforced by the square gate.
1
[ "src/gadgets/square.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-071.json
5eba0472656e7022ea8ab75d4396c8d70edfb13b778666d5c2c2da6a55630b1d
zkML-072
zkml
synthetic
Add-Pairs Gate Dropped
The elementwise a+b=out constraint for paired addition is removed, leaving tensor adds unconstrained.
src/gadgets/add_pairs.rs:35-49
Paired additions must be enforced.
1
[ "src/gadgets/add_pairs.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-072.json
4681730027f80b1582d02c987a7c64d6663295ba6cf322e514d1cee917630d4e
zkML-073
zkml
synthetic
Sub-Pairs Gate Dropped
The elementwise a-b=out constraint for paired subtraction is removed, leaving tensor subtractions unconstrained (e.g. residual/mean-centering).
src/gadgets/sub_pairs.rs:35-49
Paired subtractions must be enforced.
1
[ "src/gadgets/sub_pairs.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-073.json
507b8499a1f756916c7284cd4f35d935e70f0b5c477fb08b4fdea12649900f81
zkML-074
zkml
synthetic
Max Pairwise-Equality Gate Dropped
The (c-a)(c-b)=0 gate that forces the claimed max c to equal one of the two inputs is removed, so the attested max need not be either input.
src/gadgets/max.rs:38-50
Pairwise max requires the output to equal one of the inputs.
1
[ "src/gadgets/max.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-074.json
9ec84c4ea149bebb2aa540f1bbeea13aa004ba5466b5fe89dcb7c48d14468fc3
zkML-075
zkml
synthetic
Max Dominance Lookup Dropped
The lookup proving c>=a (c-a in range) for the pairwise max is removed, so the claimed max need not dominate its inputs; combined with any output the max is forgeable.
src/gadgets/max.rs:53-60
The max output must be proven >= each input via the range lookup.
1
[ "src/gadgets/max.rs" ]
[ "comparison", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-075.json
8dbb5e6425e68aa1523dced6835dca4accfc73f88d3c8b25d6553890b81a7b87
zkML-076
zkml
synthetic
Limb Recomposition Gate Dropped
The gate enforcing value == sum_k limb_k * base^k is removed, so the limb decomposition need not reconstruct the original value, breaking every range check that relies on it.
src/gadgets/limb_decomp.rs:52-65
Limb decomposition is sound only if the limbs recompose to the value.
1
[ "src/gadgets/limb_decomp.rs" ]
[ "arith-gate", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-076.json
880a7976521b65330106db4ef21b4718877a8e03cc610379d078ab563d394e31
zkML-077
zkml
synthetic
Limb Range Check Dropped
The per-limb range lookup is removed, so individual limbs can exceed the base, letting the recomposed value alias out of its intended range.
src/gadgets/limb_decomp.rs:71-75
Each limb must be range-checked to the base.
1
[ "src/gadgets/limb_decomp.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zkml/zkML-077.json
a6849f110cf1fa1bdfd9bad611c6a9de2c3b01d0accd774ea2210c60d81d3026
zkTorch-001
zktorch
real
Fold Gamma Hardcoded to One
The Fiat-Shamir fold verification gamma is replaced with Fr::one(). When gamma=1, the Schwartz-Zippel batching check degenerates into a trivial sum, allowing a malicious prover to forge pairing checks across accumulated instances.
src/util/verifier.rs:44
Section 4.2 (Parallel Accumulation): the γ challenge batching multiple proved relations via Schwartz-Zippel must be Fiat-Shamir-derived, not a constant (step 4 of the Accumulation Prover: γ ← ρacc(acc.x, acc'.x, [Ej])).
1
[ "src/util/verifier.rs" ]
[ "fold_gamma_challenge" ]
[]
[]
artifacts/zktorch/zkTorch-001.json
dc5d2b638391560ab78c4e5e4e588b9e9e46b7e9ab5e804a66cbd374775e9971
zkTorch-002
zktorch
synthetic
ONNX Silent Constant Clamping to 2^8
ONNX F32 constants are silently clamped to the range [-2^8, 2^8] (±256) during model loading. Any weight whose scaled magnitude exceeds 256 is truncated without any error or warning, so the circuit proves an inference over a silently corrupted model. With the default scale factor the truncation begins at a raw weight o...
src/onnx.rs:79
-
1
[ "src/onnx.rs" ]
[ "onnx_constant_range" ]
[]
[]
artifacts/zktorch/zkTorch-002.json
d7457e3c5ea03f583c1bf7202602d62230d126ea695d9ce5f40b11196e0d7819
zkTorch-003
zktorch
synthetic
Prover Fiat-Shamir Seed Replaced with Fixed Value
The prover's Fiat-Shamir RNG seed, normally derived by hashing the encoded model, inputs, and outputs via Keccak256, is replaced with a fixed 32-byte seed. The prover can pre-compute challenges and craft witnesses that satisfy the checks for any model/input pair.
src/util/prover.rs:194
Section 2.2 (Interactive Proofs and ZK-SNARKs): non-interactivity via Fiat-Shamir over a compatible interactive protocol; the prover's Keccak256(modelsEncBytes || inputsEncBytes || outputsEncBytes)-seeded RNG is this FS oracle.
1
[ "src/util/prover.rs" ]
[ "prover_fiat_shamir_seed" ]
[]
[]
artifacts/zktorch/zkTorch-003.json
1485ca4ba753d87549d6a246121c4215b0b994ee8e85ddd8eb6d9bf056714a41
zkTorch-004
zktorch
synthetic
Verifier Public Statement Checks Removed
The verifier's public-statement binding assertions (model_digest, graph_digest, output_digest, input_digest, scale_factor_log, cq_range_log, cq_range_lower_log) are all removed. The verifier no longer validates that the proof corresponds to the claimed model, input, or output.
src/util/verifier.rs:268
Section 2.2 (Interactive Proofs and ZK-SNARKs): the verifier must bind the proof to the public instance x = (model, input, output); check_public_statement implements that binding.
1
[ "src/util/verifier.rs" ]
[ "verifier_statement_binding" ]
[]
[ "zkTorch-006" ]
artifacts/zktorch/zkTorch-004.json
18cccad0e331d7337e13176bd0e8e4a6927d46da006a544c460af4db12e027c0
zkTorch-005
zktorch
synthetic
Fake Tensor Fallback for Missing Weights
External-data ONNX tensors previously caused the loader to panic (refusing to fabricate values). This artifact replaces the panic with a silent fake-tensor fallback that fills (shape, data_type) with random F32 values, so the circuit commits to and proves inference over fabricated weights unrelated to the claimed model...
src/onnx.rs:99
-
1
[ "src/onnx.rs" ]
[ "onnx_external_data_fallback" ]
[]
[]
artifacts/zktorch/zkTorch-005.json
814c09cf87184713aa25bbdb79584a413b7e5f91ba9b7e1c9b97d95592800bd6
zkTorch-006
zktorch
synthetic
Verifier Trusts Prover's PublicStatement File
The verifier reads the 'supplied' PublicStatement from CONFIG.prover.public_statement_path instead of CONFIG.verifier.public_statement_path. Because the prover writes that file from the same enc bytes the verifier then recomputes over, every assert_eq! in check_public_statement is tautological — a malicious prover can ...
src/util/verifier.rs:245
Section 2.2 (Interactive Proofs and ZK-SNARKs): verification is w.r.t. a public instance x; Fiat-Shamir binding requires x to be externally specified, not prover-derived.
1
[ "src/util/verifier.rs" ]
[ "verifier_statement_source_path" ]
[]
[ "zkTorch-004" ]
artifacts/zktorch/zkTorch-006.json
c806719779b4f24eccaf2e066d5c5eef532a2f6327638528180ee6dcb338f069
zkTorch-007
zktorch
synthetic
Division Remainder Range Check Removed
The DivConstProofBasicBlock::run() function outputs (div, r, diff) with r and diff fed into CQ range checks downstream. This artifact zeroes the r and diff arrays; after encodeOutputs rederives diff's commitment from r as 2b − r, the CQ lookups see constant polynomials (r=0, diff=2b) and trivially pass. Combined with t...
src/basic_block/div.rs:81
Section 4.4.1 (MatMul): rounded-division relation (2a+b) = 2bc + r with r, 2b−r range-checked via CQ
1
[ "src/basic_block/div.rs" ]
[ "div_remainder_range_check" ]
[]
[]
artifacts/zktorch/zkTorch-007.json
0926123854ffb7d704842ba3457df51583f40788837680b37bf7737066de54a4
zkTorch-008
zktorch
synthetic
Mira Accumulation Gamma Hardcoded
The per-fold-step accumulation challenge acc_gamma in mira_prove() AND mira_verify() is replaced with Fr::one() instead of being derived from the Fiat-Shamir RNG. With gamma=1 on both sides, the Schwartz-Zippel batching of two MatMul accumulators degenerates to a plain sum acc_1 + acc_2, letting a malicious prover subm...
src/basic_block/matmul.rs:211
Section 4.2 (Parallel Accumulation), Accumulation Prover step 4: "γ ← ρacc(acc.x, acc'.x, [Ej])"
2
[ "src/basic_block/matmul.rs" ]
[ "mira_accumulation_gamma" ]
[]
[]
artifacts/zktorch/zkTorch-008.json
5f0187bf4c78d3ddfd69795a7c0ed55f03ff286b1b384464fdb3d850bb9cda19
zkTorch-010
zktorch
synthetic
Division RLC Alpha Challenge Fixed to One
The per-element RLC challenge α in DivConstProofBasicBlock::prove() AND ::verify() is replaced with Fr::one(). With α=1, the Schwartz-Zippel weighting of the polynomial identity 2a_i + b = 2b·div_i + r_i across tensor positions degenerates to a plain sum. A malicious prover can construct elementwise errors e_i with Σ e...
src/basic_block/div.rs:143
Section 4.4.1 (rounded-division): the RLC challenge α batching the polynomial identity (2a+b) = 2bc + r across tensor elements must be Fiat-Shamir-derived, not a constant.
2
[ "src/basic_block/div.rs" ]
[ "div_rlc_alpha" ]
[]
[]
artifacts/zktorch/zkTorch-010.json
eb4ce3e62ab14a2ae26faa2bb9e9e7c45ecf88bcfe9671b7f3c50ba87fdfafb8
zkTorch-011
zktorch
real
Mock Prove Feature Re-enabled
The mock_prove Cargo feature is re-added, set as the default feature, and the release-build guard in src/lib.rs is removed. Every KZG commitment in prove() becomes the fixed generator srs.X1P[0], so every produced proof is trivially forgeable — cryptographic soundness is completely voided for all builds (dev and releas...
Cargo.toml:32
-
2
[ "Cargo.toml", "src/lib.rs" ]
[ "mock_prove_feature", "mock_prove_release_guard" ]
[]
[]
artifacts/zktorch/zkTorch-011.json
4d72da8e436fe1a6b659a0a68d0e567ee62f045a1c718877f2f41bfbadb62a63
zkTorch-012
zktorch
synthetic
Mul Verify Quotient Degree Binding Removed
The first pairing check in MulBasicBlock::verify enforces the polynomial identity f(X)·g(X) − h(X) = Z(X)·t(X) via the pair (-proof.0[0], (srs.X2A[N] − srs.X2A[0]).into()) which binds the quotient polynomial t to the vanishing polynomial Z(X) = X^N − 1. Replacing the second component with srs.X2A[0] removes the Z(X) mu...
src/basic_block/mul.rs:919
Section 4.4.2 (Hadamard Product / MulBasicBlock): elementwise product f(ω^i)·g(ω^i) = h(ω^i) for all i ∈ [N] is proved via the quotient identity f·g − h = Z·t; the pairing pair (t(X), Z(X)) is the binding that forces divisibility by the vanishing polynomial.
1
[ "src/basic_block/mul.rs" ]
[ "mul_vanishing_poly_binding" ]
[]
[]
artifacts/zktorch/zkTorch-012.json
33de50cd8f94b08cfc6427edc33c999341ca54a54b3a6771513ba336235d95f7
zkTorch-013
zktorch
synthetic
BoolCheck Verifier Identity Assertion Removed
BooleanCheckBasicBlock::verify must check at the challenge point ζ that g(ζ)·(1 − g(ζ)) = t(ζ)·Z(ζ), where Z is the vanishing polynomial of the evaluation domain. This is the core algebraic check that every committed value is in {0, 1}. Replacing the assert! at mul.rs-adjacent bool_check.rs:145 with a no-op lets a mali...
src/basic_block/bool_check.rs:145
Section 4.3 (Boolean Check / lookup preamble): a committed polynomial f is in {0,1} on the N-th roots of unity iff f(X)·(1 − f(X)) is divisible by Z(X) = X^N − 1, verified via the identity f(ζ)·(1 − f(ζ)) = t(ζ)·Z(ζ) at a Fiat-Shamir challenge ζ.
1
[ "src/basic_block/bool_check.rs" ]
[ "bool_check_identity_assertion" ]
[]
[]
artifacts/zktorch/zkTorch-013.json
219fb4774a160b0bac989f7d17beba64b307b5cfda3402d896372366f326a700
zkTorch-014
zktorch
synthetic
Sub Verifier Difference Assertion Removed
SubBasicBlock::verify contains a single soundness-critical line that asserts the output commitment equals the difference of the input commitments: assert!(a.g1 - b.g1 == c.g1). This is the only check the verifier performs for the subtraction operator (verify returns vec![] with no pairing checks). Replacing the assert ...
src/basic_block/sub.rs:52
Section 4.4.2 (Linear Operators / Add and Sub): linear-combination basic blocks are verified by directly comparing the output commitment to the prover-claimed linear combination of input commitments — c.g1 == a.g1 ± b.g1 — because the homomorphic KZG structure makes the relation a single-equation pairing-free check.
1
[ "src/basic_block/sub.rs" ]
[ "sub_verify_assertion" ]
[]
[]
artifacts/zktorch/zkTorch-014.json
c1c74179176accf0f6506efbd38a17faa9b19af14c5bf33de238ce37ee37d823
zkTorch-015
zktorch
synthetic
CQ Lookup Table Commitment Binding Removed
CQBasicBlock::verify (non-fold path) computes seven pairing checks. The second check at cq.rs:814 — vec![(model.first().unwrap().g1, srs.X2A[0]), (srs.X1A[0], -T_x_2)] — enforces that T_x_2, the prover-supplied G2 commitment to the lookup table polynomial, equals the G2-side projection of the model's G1 commitment (i.e...
src/basic_block/cq.rs:814
Section 4.5 (CQ Lookups): the lookup table T is part of the public statement (committed at setup time as part of the model). The verifier must enforce that the G2 representation T_x_2 used in pairing checks corresponds to the committed model — otherwise the lookup degree-N polynomial T can be replaced by any prover-cho...
1
[ "src/basic_block/cq.rs" ]
[ "cq_table_commitment_binding" ]
[]
[]
artifacts/zktorch/zkTorch-015.json
82985d40d992f467cbd5b3fae9e1589d3b9278b35367ee55bcffb9210c130a09
zkTorch-016
zktorch
synthetic
BatchAdd Verification Assertion Removed
The BatchAdd layer's verify function checks that the sum of all input commitments equals the output commitment via assert!(inputs_g1 == c_g1). Removing this assertion leaves the addition operation completely unconstrained: a malicious prover can commit to any output regardless of whether it actually sums the inputs, an...
src/basic_block/add.rs:96
Section 4.4 (Arithmetic layers): the verifier checks each layer's commitment relation; for addition, the output commitment must equal the sum of input commitments.
1
[ "src/basic_block/add.rs" ]
[ "batchadd_verification_assertion" ]
[]
[]
artifacts/zktorch/zkTorch-016.json
ab06fa60ddc787f3aeeca13d433fc41fedbe35ae43f1414845befc48778da069
zkTorch-051
zktorch
synthetic
Main Proof Pairing Check Removed
The graph verifier's core soundness check, the batched pairing equation that must equal the identity (multi_pairing == PairingOutput::zero()), is removed, so a proof whose pairing does not verify is accepted and any computation graph output can be attested.
src/graph.rs:398-398
zkTorch: the batched pairing check is the final soundness guard for the whole graph proof.
1
[ "src/graph.rs" ]
[ "pairing-check", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-051.json
5ebe1fdfd7b96a9523e280d90a12389b3aab1a3c99cab30cf517841837371093
zkTorch-052
zktorch
synthetic
Reshape Output Equality Check Removed
Reshape's verify asserts the output equals the structurally reshaped input. Removing it lets the prover supply an arbitrary tensor as the reshape output, breaking the data-movement binding other ops rely on.
src/basic_block/reshape.rs:50-50
A reshape output must equal the permuted/reshaped input.
1
[ "src/basic_block/reshape.rs" ]
[ "data-movement", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-052.json
5513df99997cc62bfbf2e810849e6f0384f5c0062851c98d9242a60499d59c3b
zkTorch-053
zktorch
synthetic
Subtraction Correctness Check Removed
Sub's verify asserts a-b==c at the commitment level. Removing it unbinds the subtraction output, so residual/mean-centering results become arbitrary.
src/basic_block/sub.rs:52-52
Elementwise subtraction output must satisfy a-b=c.
1
[ "src/basic_block/sub.rs" ]
[ "arith-check", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-053.json
42c2d25d2a2cd7a9464dc52d915e6a8fa2c5fe293ec672b9d07842465ab6342f
zkTorch-054
zktorch
synthetic
Division Remainder Relation Check Removed
Div's verify asserts the remainder relation (2b - r) tying the quotient to the dividend. Removing it frees the division remainder, so the attested quotient is no longer pinned to its inputs.
src/basic_block/div.rs:194-194
Division soundness requires the remainder relation to hold.
1
[ "src/basic_block/div.rs" ]
[ "arith-check", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-054.json
ae4cfe69af902d530d1e5a28a44dcea108bb27ba176aec8416c83ddeb13c7887
zkTorch-055
zktorch
synthetic
Range Proof Consistency Check Removed
Range's verify asserts the two proof halves sum to the committed output. Removing it lets the range-proof components be inconsistent with the claimed output, so out-of-range values pass.
src/basic_block/range.rs:102-102
The range proof components must sum to the committed value.
1
[ "src/basic_block/range.rs" ]
[ "range-check", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-055.json
9540409e1749759ecc1a293000c5ae6e7d5a74e633a059e7dd6b26dfff549510
zkTorch-056
zktorch
synthetic
Sum Length Check Removed
Sum's verify asserts the number of summed terms equals the declared length. Removing it lets a prover sum over the wrong number of terms, so the attested reduction omits or double-counts elements.
src/basic_block/sum.rs:166-166
A sum reduction must cover exactly the declared number of terms.
1
[ "src/basic_block/sum.rs" ]
[ "reduction", "dropped-check" ]
[]
[]
artifacts/zktorch/zkTorch-056.json
115762e61fa690c05e9eee8bea509659ca182672841976619d7266353eae4fb9
zkCNN-001
zkcnn
synthetic
Sumcheck Round Consistency Not Enforced
In each round of the GKR sumcheck the verifier must check that the prover's univariate polynomial sums to the running claim, g(0) + g(1) = previousSum, and reject otherwise. Here that round check in phase 1 is downgraded from a hard rejection to a printed warning, so the verifier continues even when the identity fails....
src/verifier.cpp:185-189
zkCNN (Liu, Xie, Zhang, CCS 2021), sumcheck protocol: in every round the verifier checks that the sent polynomial evaluated at 0 and 1 sums to the current claim; dropping this check voids sumcheck soundness.
1
[ "src/verifier.cpp" ]
[ "sumcheck_round_consistency" ]
[]
[]
artifacts/zkcnn/zkCNN-001.json
efc60c95e7f10cac4582759a2e31aae15df9d21ca3dcff31f233ef19a000f7ce
zkCNN-002
zkcnn
synthetic
Layer Predicate Consistency Not Enforced
After both sumcheck phases of a layer the verifier must bind the sumcheck result to the layer's own wiring by checking previousSum == test_value, where test_value is the gate-predicate evaluation getFinalValue over the claimed input and output values. Here that semi-final check is downgraded from a hard rejection to a ...
src/verifier.cpp:239-243
zkCNN (Liu, Xie, Zhang, CCS 2021), GKR layer reduction: the per-layer sumcheck result must equal the gate-predicate evaluation that ties the claim to the circuit wiring; skipping this leaves the layer claim unbound to the circuit.
1
[ "src/verifier.cpp" ]
[ "gkr_layer_predicate_consistency" ]
[]
[]
artifacts/zkcnn/zkCNN-002.json
17fb10e3ef1806119f3ca9aea30df77823a11e727a4a18d5cd9a9bea23f5f6a4
zkCNN-003
zkcnn
synthetic
Input Commitment Opening Not Verified
The soundness of the whole proof rests on the final step binding the claimed input evaluation eval_in to the committed input: the verifier opens the Hyrax polynomial commitment at the point r_u[0] and must reject if the opening does not match. Here that commitment check is skipped, so eval_in is accepted without being ...
src/verifier.cpp:360-363
zkCNN (Liu, Xie, Zhang, CCS 2021), input polynomial commitment: the claimed input evaluation must be verified against the Hyrax commitment opening at the final random point; omitting it unbinds the proof from the committed input.
1
[ "src/verifier.cpp" ]
[ "input_commitment_opening" ]
[]
[]
artifacts/zkcnn/zkCNN-003.json
18b2d97f37721ee86a01193ab3067c9f8b8a5d8ba0185d9ca1db153d1c60c989
zkCNN-004
zkcnn
synthetic
Phase-Two Sumcheck Round Not Enforced
Layers with a second multilinear variable run a second sumcheck phase, and in each of its rounds the verifier must check that the prover's polynomial sums to the running claim, poly(0) + poly(1) = previousSum, and reject otherwise. Here the phase-two round check is downgraded from a hard rejection to a printed warning,...
src/verifier.cpp:219-223
zkCNN (Liu, Xie, Zhang, CCS 2021), sumcheck protocol (second phase over the v-variables): each round must satisfy poly(0)+poly(1)=claim; skipping the rejection voids phase-two soundness.
1
[ "src/verifier.cpp" ]
[ "sumcheck_phase2_consistency" ]
[]
[]
artifacts/zkcnn/zkCNN-004.json
7956ed5d286584b3554093144a6ccd6bea01781ed919f002e6d148d2863e13b5
zkCNN-005
zkcnn
synthetic
Input Evaluation Binding Not Enforced
The first-layer (Liu) reduction ends by binding the committed input evaluation to the accumulated layer claims: the verifier must check eval_in * gr == previousSum, where gr is the sum of the input-wiring beta tables and eval_in is the claimed evaluation of the input layer. Here that semi-final binding check is downgra...
src/verifier.cpp:331-334
zkCNN (Liu, Xie, Zhang, CCS 2021), first-layer claim reduction: the input evaluation must satisfy eval_in * gr = previousSum to bind the committed input to the circuit claims; skipping it unbinds the input evaluation.
1
[ "src/verifier.cpp" ]
[ "input_evaluation_binding" ]
[]
[]
artifacts/zkcnn/zkCNN-005.json
7423627ec9e94e28dd4a07694b70f868b4190b655265bcab3addcd1a63fd20f6
vCNN-001
vcnn
synthetic
Convolution SNARK QAP Pairing Check Downgraded to Warning
The convolution-SNARK online verifier's core soundness check is the QAP divisibility pairing equation e(A,B) == e(alpha,beta)*e(acc,gamma)*e(C,delta). This artifact downgrades the failing branch from `result=false` to a printed warning, so the verifier accepts a proof whose QAP divisibility does not hold, i.e. any conv...
libsnark/zk_proof_systems/ppzksnark/convol_snark/r1cs_conv_ppzksnark.tcc:689-696
vCNN (ePrint 2020/584): the SNARK is sound only if the QAP divisibility pairing check rejects proofs that fail the convolution relation.
1
[ "libsnark/zk_proof_systems/ppzksnark/convol_snark/r1cs_conv_ppzksnark.tcc" ]
[ "qap-pairing-check", "verifier-check-downgraded" ]
[]
[]
artifacts/vcnn/vCNN-001.json
8a6db187b924f61e70e6eb53fbdc13884a6bede82203e0a682e020cb1fc9ce98
vCNN-002
vcnn
synthetic
Proof Well-Formedness (On-Curve) Check Downgraded to Warning
The verifier checks that proof group elements lie on the curve via `proof.is_well_formed()`. This artifact downgrades the failing branch to a warning, so malformed / off-curve proof elements are accepted, enabling subgroup / off-curve forgeries.
libsnark/zk_proof_systems/ppzksnark/convol_snark/r1cs_conv_ppzksnark.tcc:666-673
vCNN (ePrint 2020/584): proof elements must be validated as on-curve before the pairing check.
1
[ "libsnark/zk_proof_systems/ppzksnark/convol_snark/r1cs_conv_ppzksnark.tcc" ]
[ "proof-wellformed-check", "verifier-check-downgraded" ]
[]
[]
artifacts/vcnn/vCNN-002.json
789c18de7634f58f44255ea808b65d2c7f31664e4752e62f3f95832bdefe2ec8
End of preview. Expand in Data Studio

zkml-audit-benchmark

A benchmark dataset for evaluating AI agents on zkML soundness auditing: finding cryptographic vulnerabilities in zero-knowledge machine learning proof implementations.

Overview

This dataset pairs 6 published zkML research papers with their corresponding frozen codebase snapshots and 102 bug artifacts spanning six systems. The evaluated core is 56 artifacts over four systems (20 real-world from expert audits + 36 synthetic for broader coverage); the remaining 46 are a held-out extension: 37 new artifacts on zkGPT, zkML and zkTorch, plus 9 on two further systems (zkCNN, vCNN) that test transfer to code the method was not built on. Each artifact describes a single soundness vulnerability — the code edits to inject it, ground-truth labels for scoring, and presence probes for post-injection validation

The benchmark supports two complementary workflows:

  1. Pair extraction — load a (paper, codebase) pair for an agent to audit.
  2. Test-case generation — sample artifacts and apply their edit logic to the clean codebase, producing flawed codebases with known ground-truth findings.

Documentation

Positioning vs. Existing Security Benchmarks

Several mature benchmarks evaluate code-security tooling, but none target the theory-to-implementation gap that defines zkML soundness. The table below contrasts the design axes that matter for this setting: domain coverage, the granularity of the ground-truth labels, and whether artifacts are paired with the academic claims they implement.

Benchmark Domain Artifact granularity Theory-paired ZKP-aware
Juliet test suite General C/C++/Java security CWE-class injections no no
OWASP Benchmark Web/Java security OWASP-class injections no no
NIST CAVP Standardized crypto implementations Test-vector validation no partial
zkml-audit-benchmark (this dataset) zkML soundness Per-claim soundness gap yes yes

Juliet ships tens of thousands of injected vulnerabilities for general-purpose code, but its labels are generic CWE classes rather than per-paper soundness claims. The OWASP Benchmark is web-application focused, and the NIST Cryptographic Algorithm Validation Program validates implementations of standardized primitives, not bespoke proof-system protocols. By contrast, this benchmark ships paper–codebase pairs together with declarative artifact specifications that re-introduce a precisely characterized soundness gap, making it directly suitable for studying theory-to-practice alignment in zkML.

Dataset Structure

Configs

Config Rows Description
pairs 6 One row per (paper, codebase) pair
artifacts 102 One row per bug artifact (flattened metadata)

Loading

from datasets import load_dataset

pairs = load_dataset("Anonymous648/zkml-audit-benchmark", "pairs")
artifacts = load_dataset("Anonymous648/zkml-audit-benchmark", "artifacts")

Raw Files

Beyond the Parquet tables, the repository includes:

  • papers/{pair_id}.pdf — research paper PDFs
  • codebases/{pair_id}.zip — frozen codebase snapshots (Git LFS)
  • artifacts/{pair_id}/*.json — full artifact JSONs with edit instructions, conflict metadata, and presence probes
  • schema/artifact.v2.schema.json — JSON Schema defining the artifact format

The Parquet tables contain flattened metadata for filtering and loading. The full artifact JSONs (with heterogeneous edit/probe structures) are the authoritative source for test-case generation.

Data Fields

pairs config

Field Type Description
pair_id string Primary key: zkllm, zkml, zktorch, zkgpt, zkcnn, vcnn
paper_title string Full paper title
paper_venue string Publication venue
paper_year int32 Publication year
paper_license string Paper redistribution terms
paper_url string arXiv or publisher URL (empty if unavailable)
paper_path string Relative path to PDF: papers/{pair_id}.pdf
paper_sha256 string SHA256 hash of the PDF
codebase_path string Relative path to zip: codebases/{pair_id}.zip
codebase_dir string Directory name after extraction
codebase_sha256 string SHA256 hash of the zip
codebase_language string Primary implementation language
codebase_frameworks list<string> Key cryptographic frameworks used
codebase_snapshot_note string Commit hash or snapshot date
artifact_count int32 Number of artifacts targeting this pair
notes string Caveats or special build instructions

artifacts config

Field Type Description
artifact_id string Primary key, e.g. zkLLM-001
pair_id string Foreign key → pairs
source string real (from audit) or synthetic (authored for coverage)
finding_name string Short vulnerability title (3–7 words)
finding_explanation string One paragraph: root cause and impact
relevant_code string Comma-separated file:line[-line] references
paper_reference string Section/theorem/protocol citation with optional quote
edit_count int32 Number of code edits to inject this bug
files_touched list<string> Files modified by this artifact's edits
semantic_tags list<string> Semantic labels for conflict detection
requires list<string> Artifact IDs this depends on
incompatible list<string> Artifact IDs incompatible with this one
artifact_path string Relative path to full artifact JSON
artifact_sha256 string SHA256 hash of the artifact JSON

Pair Inventory

pair_id Paper Venue Language Artifacts Snapshot
zkllm zkLLM: Zero Knowledge Proofs for Large Language Models ACM CCS 2024 CUDA/C++ 13 commit 993311e…
zkml ZKML: An Optimizing System for ML Inference in Zero-Knowledge Proofs EuroSys 2024 Rust 39 commit 4378958… (ddkang/zkml)
zktorch ZKTorch: Compiling ML Inference to Zero-Knowledge Proofs via Parallel Proof Accumulation arXiv Rust 21 directory snapshot 2026-04-19
zkgpt zkGPT: An Efficient Non-interactive Zero-knowledge Proof Framework for LLM Inference USENIX Security 2025 C++ 20 Zenodo record 14727819 v1
zkcnn zkCNN: Zero Knowledge Proofs for Convolutional Neural Network Predictions and Accuracy ACM CCS 2021 C++/CUDA 5 upstream source snapshot
vcnn vCNN: Verifiable Convolutional Neural Network Based on zk-SNARKs IEEE TDSC C++ 4 upstream source snapshot (snp-labs/VCNN)

Artifact Summary

  • Total artifacts: 102 across six systems (20 zkGPT + 13 zkLLM + 39 zkML + 21 zkTorch + 5 zkCNN + 4 vCNN)
  • Evaluated core: 56 over four systems (14 zkGPT + 13 zkLLM + 14 zkML + 15 zkTorch); every reported evaluation number is on this core
  • Held-out extension: 46 over five systems (6 zkGPT + 25 zkML + 6 zkTorch + 5 zkCNN + 4 vCNN), including two systems (zkCNN, vCNN) not used to build the taxonomy; these test transfer and are not part of the evaluated core
  • Source breakdown (core): 20 real (derived from expert audit reports), 36 synthetic (authored for broader coverage)
  • Each artifact includes declarative code edits, conflict metadata for safe composition, and presence probes for post-injection validation

Reproducibility

All files are checksummed in MANIFEST.json. To verify integrity:

python scripts/verify_dataset.py

To rebuild the Parquet tables from the in-repo artifact JSONs:

python scripts/build_parquet.py

Known Limitations & Assumptions

  1. Paper ↔ codebase mapping uses fixed pair IDs (zkllm, zkml, zktorch, zkgpt, zkcnn, vcnn) defined in scripts/build_parquet.py.

  2. Non-git snapshots: The zktorch codebase is a directory snapshot dated 2026-04-19 and cannot be pinned to an upstream commit. zkllm and zkml are pinned to Git commits (993311ea… and 4378958… respectively). zkgpt is pinned to Zenodo record 14727819 v1.

  3. Paper licensing: PDFs are included for research reproducibility. The dataset-level CC-BY-4.0 license covers only the curation layer (artifact definitions, schema, scripts). Papers carry their respective publisher terms (ACM, arXiv). Users redistribute at their own responsibility.

  4. Artifact format: Artifacts follow schema/artifact.v2.schema.json. All graded labels live under finding.labels.

  5. Scope: This release covers six (paper, codebase) pairs — those with paired frozen codebases and authored artifacts. Additional pairs may be added in future releases.

Schema Reference

The artifact JSON format is defined by schema/artifact.v2.schema.json. Key structures:

  • finding.labels — the two graded fields (relevant_code, paper_reference)
  • edits — ordered list of code edits to inject the bug
  • conflict_keys — files, regions, and semantic tags for safe composition
  • presence_probes — assertions to verify successful injection

Citation

If you use this dataset, please cite:

@misc{zkml-audit-benchmark,
  title={zkml-audit-benchmark: A Benchmark for AI Agents on zkML Soundness Auditing},
  author={Anonymous},
  year={2026},
  url={https://huggingface.co/datasets/Anonymous648/zkml-audit-benchmark},
}

License

  • Dataset curation layer (artifacts, schema, scripts, documentation): CC-BY-4.0
  • Codebases: retain their original upstream licenses (see each codebase's LICENSE file inside the zip)
  • Papers: subject to respective publisher terms
Downloads last month
63