Jul 2026· Annual International Computer Software and Applications Conference· pp. 2729-2734· 0 citations· 14 references
Abstract
Zero-Knowledge Proofs (ZKP) provide strong data privacy and rely on the principle of proving a statement without revealing the underlying data. However, the ZK-SNARK system has a scalability problem while generating proofs. Systems like PLONK take longer to generate a proof with increasing size of the input data. EHR(Electronic Health Records) may present a short proving time but large size data sine when they contain images and genomics it could take more time to generate a proof. ZK-Rollup systems provide scalability by batching the transactions in off-chain mode; however, they also suffer from longer proving time with large data. In this paper, we propose an approach to generate KZG commitments from healthcare FHIR records and then use these values to generate single validity ZKP. In this way, we can not only reduce the proving time, but also ensure data integrity and data correctness.
Zero-knowledge machine learning (zkML) enables a server to perform verifiable inference while keeping model parameters private from the client. However, existing zkML systems incur prohibitive proof-generation costs. We observe that proof generation exhibits limited parallelism; that is, prover time does not decrease significantly as the number of threads increases. This limitation is because existing systems rely on monolithic proof computation, constructing a single proof for the entire machine learning model. We introduce zkComposer, a modular proof-construction framework that unlocks an additional dimension of parallelism, in addition to the parallelism in existing proof kernels. zkComposer decomposes the zkML proof of correct inference into independent sub-proofs, each covering a subset of the computation for inference e.g., each independent sub-proof can cover a subset of contiguous layers in the ML model. Adjacent sub-proofs are cryptographically linked through shared commitments to the activations from the boundary layer. zkComposer provides the same guarantees as the monolithic proof without requiring additional linking proofs or changes to the underlying cryptographic primitives. We implement zkComposer and evaluate it on three CNNs and GPT-2. We show that, on CNN workloads, zkComposer reduces prover time and response time by up to 3.25x relative to zkCNN [1]. On GPT-2, zkComposer reduces these times by up to 4.83x relative to zkGPT [2], when partitioning along the model layers. When partitioning across both model layers and input sequences in GPT-2, we show that zkComposer reduces prover time and response time by up to 6.84x relative to zkGPT [2].
Pawan Kumar Sanjaya, Christina Giannoula, Valdy Oktavian et al.· 0 citations
Existing Capture-the-Flag (CTF) platforms trust a single organizer, offer limited auditability, and are vulnerable to infrastructure-level manipulation. We propose zk–MPSFV, a zk-SNARK-based, multi-phase sub-flag verification scheme that replaces centralized scoring with an on-chain, zero-knowledge, publicly verifiable scoreboard. Challenges are decomposed into sub-challenges arranged as a directed acyclic graph (DAG): a team unlocks the next step only after proving completion of all parent nodes. Sub-flags and decryption keys are jointly generated by n organizers and released via an off-chain ($t, n$) Shamir–BLS threshold signature produced through multi-party computation (MPC), preventing any single organizer from leaking or altering keys. Teams submit zk-PLONK proofs that the contract verifies, timestamps, and records immutably. Under standard assumptions (collision-resistant hashing, SNARK soundness/zero-knowledge, IND-CCA2 ECIES, and at least t honest organizers), we prove that zk–MPSFV achieves the stated security goals, including DAG-gated progress, anti-replay, and threshold-robust organizer security, while out-of-band flag sharing remains out of scope. On a three-organizer testbed with 30 simulated teams, setup costs 0.45 ms per sub-flag, proof generation averages 5.34 s on an 8-core system, and on-chain verification costs $\approx$ 170kL2 gas on zkSync Era with a median fee of 1.33 $\times 10^{-6}$ ETH (about ${\$}$0.0046 at ${\$}$3,435/ETH). Stress replays sustain $\approx$ 7 proof transactions/s up to 5000 proofs; extrapolating to 50,000 proofs (1000 teams $\times$ 50 submissions) yields $\approx$ 0.0665 ETH (about ${\$}$200–${\$}$228) and $\approx$ 2 hours of settlement time. Overall, zk-MPSFV is practical for small- to mid-scale, audit-ready progression CTFs.
S. Khanji, Behzad Abdolmaleki, John A. Clark et al.· IEEE Computer Security Found...· 0 citations
PANDA is a scalable system that uses zero-knowledge proofs to prove the robustness and fairness properties of a model without revealing its private parameters, and can generate proofs of local robustness for neural networks with more than 2.9M parameters in 5 minutes, and can verify them in 10 seconds.
Youwei Zhong, Ben Merbaum, Timos Antonopoulos et al.· 0 citations
This SoK model federated learning as an append-only transcript of submissions, admissions, aggregation, and finalization events, and formalize verifiability as a collection of integrity claims issued by clients and the aggregator, and checked by different verifier classes.
Andrea Rizzini, Marco Esposito, Tommaso Gagliardoni et al.· Proceedings on Privacy Enhan...· 0 citations
Network verification checks whether forwarding behavior satisfies intended invariants. In interdomain settings, data-plane verification is challenging because forwarding configurations are private, while post-incident review requires repeatable, version-specific checking without costly online coordination. We present AegisPath, it replaces centralized verification with distributed witness generation to protect AS-local configurations, decouples witness generation from repeated auditing through a commit-and-prove design, uses zero-knowledge proofs to answer queries without revealing forwarding paths, and supports incremental updates. Experiments show that offline Secure Multi-Party Computation (SMPC) witness generation takes from thousands to over 104 seconds, online Zero-Knowledge (ZK) auditing remains sub-second, and incremental maintenance yields substantial speedups over full re-computation.
Mingjun Fang, Shuhao Zheng, Zonglun Li et al.· Asia-Pacific Workshop on Net...· 0 citations
Zero-knowledge proofs (ZKPs) are increasingly used in blockchain systems, privacy-preserving applications, and verifiable cloud computation, but their practical deployment is still constrained by the cost of proof generation. This cost is especially important when proof generation is provided as a cloud-side service, where prover latency directly affects service throughput and resource efficiency. Existing heterogeneous provers mainly follow an operator-centric design, offloading selected GPU-friendly kernels while leaving the overall proving pipeline fragmented across fine-grained execution boundaries. This approach is effective at reducing the cost of major operators, but it also changes the bottleneck structure of modern proving: once dominant kernels are accelerated, end-to-end inefficiency increasingly arises from fragmented cross-stage execution, including host-device transitions, intermediate-state materialization, and CPU-side coordination overhead. In this paper, we argue that the key systems problem is no longer simply which operator to accelerate next, but what the right runtime execution unit should be for heterogeneous ZKP proving. To this end, we propose region-centric execution, a locality-aware runtime abstraction that groups tightly dependent computations into larger execution units based on dependency locality, state continuity, and boundary cost. Building on this abstraction, we design execution mechanisms that preserve deviceresident state, delay unnecessary materialization, coordinate dependent computations within a region, and reduce excessive boundary crossings. We implement our design on top of a Plonky2-based GPU prover and evaluate it on four representative workloads. Region-centric execution improves end-to-end proving performance by $1.36 \times$ on average and up to $1.52 \times$ over an operator-centric baseline, with the gains coming primarily from lower coordination overhead and reduced host-device transfer cost rather than uniformly faster GPU kernels.
Weiliang Ma, Qian Xiong, Yu-Fan Bai et al.· Fall Joint Computer Conferen...· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
