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 | d43bd9a9250be8713ca385ecc72700155c95614e6030b912a644b5e22f9a2de7 |
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 | 1a136b9d5789ca0ab40dc069097e0f0793218ce4e037671c21ff0aba8bda72ce |
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 | 3c45e388532ef68247dd0f1bea4a6a0aea5e8cfd7fe623762e4be8cd315d7f1d |
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 | 198a900ac85c1504d81b269c30fb8239dd558d5dd5fe90effeef39205607cf75 |
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 | 1eb1b9eae9b97b79c41868f14c2f14303b6309df739789d5a70e5871c25dba71 |
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 | 9788706cda9bb05a67a3d829710ebe82a986ed9e2d85fb45be2f3d40678fce10 |
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 | 328c755f95b141ffc80978fcddbbe668bd755c39ec5f1db57a63c9101da2cc80 |
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 | 3e070cd5f6a45242214ec30e313992a83374d0bd6a2557af5b6e72e11d8729e6 |
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 | 4ed78a23cbd8392dcaf0d842a66e75cbe5bdefe92dddff564e384fa49b37f27c |
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 | fbc5e1116831835278971655c69b0cff62d3e653a51ae653d0ecca3f0a6c779f |
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 | 7e676d9d6f771df690928d3824a25d671f8222750131738a289d04c5b68ebf7d |
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 | 05bb0e40590233526f7f38e7a0711f3737e8eafc72b49d5e6806678008c704a9 |
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 | 3497370374ba97f0293837b693d118e3749f32025819add21e95f27ddf8a6744 |
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 | b3b68a31e52929e52b0f9871255020106690b831c153ff5c89cc8099e7fea24c |
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 | ea0806298ee4a573af3797a64ff1605788f2ed1819582e9a10e6ebc60f9155ad |
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 | aa2e9106118ed05dde58a5abac5eeed626df15e524262355a1ed705ff3961ad5 |
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 | 1f0beba261f02ada858940062a06f5e54b893d396f87142bbc10876b0d93e423 |
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 | 71fca19dcbf5cb6856cc31386b8313685370ca0c47408f3881e3cb0d499f7070 |
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 | 9fde15e0db8729e5344003ce2e552c2be4fe12218d8257198b77159a0a9756d6 |
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 | 42be157c3f583b49102caa171e269b756c03e381c793ee39f2b7ad0a1980dcc9 |
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 | 7e52355dadf8b85dc3785337dc8d4dcbaabed55d2221fdcfd3a9d868f6b343ee |
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 | d9a9b898b6d9c2e5548cd20a06078af97051d252d7a28f3c158c2ac73834301a |
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 | 516048347f6405bdce6746fe292cc2d7405519a22d7ed95e29bc928f8c8e00f6 |
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 | 36d371ecad36d7bac9d052ca44fd6fd28fb54147ce9d874b67ccc61d25457e98 |
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 | 6c11cbc54c4e8e3c96aa565cbf7e9a4a13b948ad581ecedc4fe3b8dde42b1f2c |
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 | 10a5ce2028f31a4a1d561e2a770b821f1e08f18b077c5655450196e683bd6049 |
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 | 2e90448309148efe738604e499b90b233f18be656084a269be92abb233239827 |
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 | 092696152b9141136bda956e494e0136f58082edfef2c750ad98ee6f963af007 |
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 | 3c66b05c2efd13e7b1263c39856b4953be27e54a66c740de8bb7fab0a25a6715 |
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 | a446b3a09d5aba59e154bbe8d05dd48ef9b66d8b22f2f1883cdbebff76dc3c93 |
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 | 414dc525609f057f990170c4e13b990ac53bda9fbb90586252ec3961dcdefb65 |
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 | 10eedf495816597cb95d74aed88959bf32db3e7017c705397102ee231753fd48 |
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 | c15cc00e82bde002ae161475b2e6b2e8c41daeb1d3fae516fbf3261a4e6cf06e |
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 | 456567d9293758a85e0bad8e9dc1f864571cc9cd93cebf2a9edb9e139b02549c |
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 | d8cc31785873bb331a81f85c8566de939897bed3be293dc08709f319145d627b |
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 | f315e546c92cde6f1ae9e15c523877463c30fb26909a403e88da21b1c9b7ce0f |
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 | daf38ec12f4cdd9d256515237ec5cc2ea3b66d4e699b8066ebb254b9aa839198 |
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 | a5ed1c56830489a8a7b2d51bed3caea3ba383e6bb4ee19c8361947a115b3d86c |
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 | 65c7394c84f4eeee4e16b068a8e8b21b3df498db29cae08c7ed5ffdd1e554f22 |
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 | 1d6bfa0bfe823303f640245e69b60963f7396bc1e63763bb9453264476ec269d |
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 | 0385b612341be2b77ac09f7cb05f63776e196e946b9ad86714969dd2e5a44305 |
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 | 047283727b278ab955bf03b4dd11fd1190c8f6d767aebeb0c196dcff0b8bfb7a |
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 | 31b7811258b0ee1ccaedfc247f7ce67ecd6b0dd16f2695c584649dc65773a4ac |
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 | 20a39d6cef8fecfa72f36387f423b3a9f2350225f13cb18067527b658bd0bfae |
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 | 9aa23dd10ca8b43a3c341898f9d54e77c2f06c25d4b98c56506f96540c8940e0 |
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 | 9fd0252e691156f658f49ed82852cf0d3033db7e1ebd8ae25bb4b3743dff70aa |
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 | 8f456653304f8700617b4cacaa2f0f96f4be6c65effdced15225674e5059b354 |
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 | 6175a26abf5c1dba3c8f1733f22aa10a0186826dbbeb0e13d5ecbb3223913fd4 |
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 | 97cdc9ed8240e70fc60b2de6e016c461b26723d17a9ce427bba9ee1383a38e7f |
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 | faaa03638ef31b975facbbaf733d7a1793a34792d423e441ac48bfb0b2e90aba |
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 | 4c25d72ba20401938861a45f56775f3678c1c6afcf166bbf97e910f1d7d01389 |
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 | 4d28ea9be1c107ea6b7d0e2028ee3597863cc223f8909173a1654e3085d746f2 |
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 | 69509c0caca77614284bc84d95c51bd23e393e4af075ce85679db4eb479b5bc8 |
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 | 368f0c68c17d0854960864abb49067cfc6485d0f164f9ea20b95b49aa3782434 |
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 | 0094c74ebac46b7bb5050c8a4bf2b1c358d87138c3ea5198340ac0c3e19845b0 |
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 | 7570df6ad7517beff21003050f7c6f454dd7384c5e901a53dfd8b9d3146c0942 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.