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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.