Datasets:

Anonymous648
/

zkml-audit-benchmark

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][cochannel_in+ci] with a deterministic (cochannel_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

zkml-audit-benchmark

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

Overview

This dataset pairs 4 published zkML research papers with their corresponding frozen codebase snapshots and 56 bug artifacts (20 real-world from expert audits + 36 synthetic for broader coverage). Each artifact describes a single soundness vulnerability — the code edits to inject it, ground-truth labels for scoring, and presence probes for post-injection validation

The benchmark supports two complementary workflows:

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

Documentation

DATASHEET.md — datasheet for this dataset, following Gebru et al. 2021.
CONTRIBUTING.md — how to add new (paper, codebase) pairs and bug artifacts.
CHANGELOG.md — release history and label/codebase corrections.
schema/artifact.v2.schema.json — authoritative JSON schema for bug artifacts.

Positioning vs. Existing Security Benchmarks

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

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

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

Dataset Structure

Configs

Config	Rows	Description
`pairs`	4	One row per (paper, codebase) pair
`artifacts`	56	One row per bug artifact (flattened metadata)

Loading

from datasets import load_dataset

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

Raw Files

Beyond the Parquet tables, the repository includes:

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

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

Data Fields

`pairs` config

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

`artifacts` config

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

Pair Inventory

pair_id	Paper	Venue	Language	Artifacts	Snapshot
`zkllm`	zkLLM: Zero Knowledge Proofs for Large Language Models	ACM CCS 2024	CUDA/C++	13	commit `993311e…`
`zkml`	ZKML: An Optimizing System for ML Inference in Zero-Knowledge Proofs	EuroSys 2024	Rust	14	commit `4378958…` (ddkang/zkml)
`zktorch`	ZKTorch: Compiling ML Inference to Zero-Knowledge Proofs via Parallel Proof Accumulation	arXiv	Rust	15	directory snapshot 2026-04-19
`zkgpt`	zkGPT: An Efficient Non-interactive Zero-knowledge Proof Framework for LLM Inference	USENIX Security 2025	C++	14	Zenodo record 14727819 v1

Artifact Summary

Total artifacts: 56 (14 zkGPT + 13 zkLLM + 14 zkML + 15 zkTorch)
Source breakdown: 20 real (derived from expert audit reports), 36 synthetic (authored for broader coverage)
Each artifact includes declarative code edits, conflict metadata for safe composition, and presence probes for post-injection validation

Reproducibility

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

python scripts/verify_dataset.py

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

python scripts/build_parquet.py

Known Limitations & Assumptions

Paper ↔ codebase mapping uses fixed pair IDs (zkllm, zkml, zktorch, zkgpt) defined in scripts/build_parquet.py.
Non-git snapshots: The zktorch codebase is a directory snapshot dated 2026-04-19 and cannot be pinned to an upstream commit. zkllm and zkml are pinned to Git commits (993311ea… and 4378958… respectively). zkgpt is pinned to Zenodo record 14727819 v1.
Paper licensing: PDFs are included for research reproducibility. The dataset-level CC-BY-4.0 license covers only the curation layer (artifact definitions, schema, scripts). Papers carry their respective publisher terms (ACM, arXiv). Users redistribute at their own responsibility.
Artifact format: Artifacts follow schema/artifact.v2.schema.json. All graded labels live under finding.labels.
Scope: This release covers 4 of the 10 available research papers — specifically those with paired frozen codebases and authored artifacts. Remaining papers may be added in future releases.

Schema Reference

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

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

Citation

If you use this dataset, please cite:

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

License

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

Downloads last month: 67

Number of rows:

Total file size:

32.9 MB