Blockchain Papers

Jens Groth, Harjasleen Malvai, Andrew Miller, Yi-Nuo Zhang

No abstract is available for this record.

Yibin Yang

No abstract is available for this record.

Gayathri Govindappa Nalina, Channakrishna Raju

The growth of cloud computing in the healthcare field has led to significant developments, but ensuring the confidentiality and protection of medical records such as electronic health records (EHRs) remains a major concern for healthcare service applications. In cloud computing, the basic authentication provided by most service providers is insufficient to ensure secure access to critical or sensitive resources. Moreover, most of the existing healthcare management systems are ineffective in handling a number of patient data, which leads to single points of failure. To address these issues, elliptic curve cryptography (ECC) with Curve25519 is utilized to enhance security in cloud storage, particularly within healthcare management systems. The ECC with Curve25519 is optimized for efficient and fast scalar multiplication, which reduces computational overhead and enhances performance. The curve parameters are selected to prevent vulnerabilities and ensure security against known attacks. Moreover, it is efficient in maintaining the integrity of patient records, which reduces storage and bandwidth requirements. The ECC with Curve25519 achieves lower Key-Gen, prove, verify, proving key size, and verification key size of 13.7 s, 48 s, 0.608 s, 13.27 Mb, and 123.70 Kb, respectively, in comparison with proxy re-encryption algorithm with zero-knowledge proof (ZKP).

Sultan Almuhammadi

Zero-knowledge proofs (ZKPs) enable a prover to convince a verifier of knowledge of a secret without revealing it. The ZKP for the square-root problem has many applications in network and cloud security, such as user authentication and privacy-preserving cloud storage auditing. Classical protocols for the quadratic residuosity (square-root) relation require multiple iterations to reach negligible soundness error, incurring latency and communication costs that are critical in cloud settings. This paper proposes a new single-round zero-knowledge proof (SR-ZKP) for the square-root problem that achieves the same soundness as iterative schemes by increasing the challenge length. The protocol requires only one execution of a 4-message protocol (request, commit, challenge, response) and can be transformed into a one-message non-interactive ZKP via the Fiat–Shamir heuristic. The completeness, soundness, and zero-knowledge properties of the proposed scheme are formally proven. The results of this study show that the proposed protocol can achieve approximately \(97\%\) reduction in communication overhead and latency, when compared to an 80-round iterative ZKPs with RSA modulus n of size 2048 bits. This provides a substantial advantage for cloud applications.

José Ignacio Peinador Sala

A Modular DSP Architecture for Extreme-Precision Computation of π Author: José Ignacio Peinador SalaContact: joseignacio.peinador@gmail.comORCID: 0009-0008-1822-3452 🎯 TL;DR: What's This About? Problem: Calculating π at extreme precision hits a "Memory Wall" — parallel algorithms choke on shared memory access. Breakthrough: We discovered that π's calculation can be decomposed using modular arithmetic (mod 6), creating 6 independent computation channels with zero inter-thread communication. Key Insight: This decomposition is grounded in a formal isomorphism with polyphase filter banks in Digital Signal Processing (DSP), a bridge between number theory and engineering established in our companion work. Result: ✅ 100 million digits of π computed with just 6.8 GB RAM (95% parallelisation efficiency) ✅ Shared-Nothing architecture with strictly isolated memory per channel ✅ Stride-6 transition leaf with exact phase correction, compressing recursion depth by 2.6× ✅ Open-source implementation in Python/gmpy2, executable on Google Colab's free tier Why it matters: This architecture transforms an intrinsically memory-bound problem into a CPU-bound one, enabling near-linear scaling on commodity hardware without specialised HPC infrastructure. 📖 Executive Summary This repository hosts the reference implementation and experimental validation of the Hybrid Stride-6 architecture for extreme-precision computation of π. The architecture exploits the arithmetic structure of the Chudnovsky series by decomposing it into six independent modular channels, each processed by a dedicated worker with its own memory space. The decomposition is not an ad hoc optimisation but rests on a rigorous mathematical foundation: the polyphase isomorphism between modular arithmetic on ℤ/6ℤ and multirate signal processing. This isomorphism guarantees perfect reconstruction (no information loss across channels) and orthogonality (no inter-channel interference). The architecture is validated through the 100M Barrier Run: computing 10⁸ digits of π on a resource-constrained Google Colab instance (2 vCPUs, 12 GB RAM) in under 20 minutes, with 95% parallelisation efficiency and a sustained throughput of over 83,000 digits per second. 🏆 Key Contributions 🔬 Theoretical Foundations (Summarised from Companion Work) Polyphase Isomorphism: Formal proof that modular decomposition of integer-indexed series is equivalent to polyphase decimation in DSP Hexagonal Lattice Connection: Geometric motivation via the A₂ lattice (densest circle packing in the plane) Perfect Reconstruction Guarantee: Mathematical proof that the six channels recombine without aliasing or leakage ⚡ Computational Architecture Shared-Nothing Design: Six independent Python processes with strictly isolated memory spaces Stride-6 Transition Leaf: Processes blocks of 6 consecutive terms in a single operation, reducing recursion tree depth by log₂6 ≈ 2.585 Critical Phase Correction: Direct accumulation of the linear term B(k) prevents off-by-one-stride phase errors 📊 Experimental Validation 100M Barrier Run: 100 million digits computed on 12 GB RAM with 95% parallel efficiency Orthogonality Verification: ℓ² norm of channel terms matches norm of original series to machine precision Reference Comparison: All 10⁸ digits match y-cruncher reference values exactly 📈 Performance Highlights 🚀 "The 100M Barrier Run" — Extreme Validation Metric Result Significance Digits Calculated 100,000,000 Exascale-capable architecture Total Time 1,194.32 s (19.90 min) Sustained performance on cloud hardware Parallel Efficiency 95% (1.90× speedup) Near-linear scaling on 2 cores Peak RAM Usage ~6.8 GB Runs within 12 GB Colab limit Throughput 83,729 digits/second Competitive with optimised implementations Numerical Integrity Bit-exact match with y-cruncher Zero cumulative error 🏗️ Architectural Comparison Aspect Monolithic Binary Splitting Hybrid Stride-6 (This Work) y-cruncher (State-of-Art) Memory Pattern Contiguous, saturates bus Local per core, optimises cache Sequential disk I/O Parallel Model Fine-grained synchronisation Embarrassingly parallel (6 processes) Optimised with locks Scalability Memory-bound CPU-bound, linear to 6 cores Disk-speed limited RAM Requirement Entire dataset in memory Working set reduced 6× Uses disk as RAM Design Philosophy Maximise single-thread speed Maximise resource efficiency Maximise absolute speed 🚀 Quick Start & Reproduction 1. Instant Online Experiment (Recommended) Click above to run the complete experimental validation in Google Colab — no installation required! 2. Key Experiments to Reproduce The companion notebook provides step-by-step reproduction of all manuscript claims: Theoretical Foundation: Verify the polyphase decomposition and energy conservation Stride-6 Algorithm: Test parallel computation with arbitrary precision (100k digits) 100M Barrier Run: Reproduce the full-scale benchmark (requires ~7 GB RAM) Performance Analysis: Measure speedup and parallel efficiency ⚙️ Technical Implementation Details The "Stride-6" Computational Engine Unlike conventional Binary Splitting (processes terms individually), our engine implements a compressed transition leaf that calculates the aggregate effect of 6 consecutive terms: def stride6_leaf(k_start): """Calculate compressed transition for block [k, k+5]""" P, Q, B_acc = 1, 1, 0 for m in range(6): n = k_start + m P_n, Q_n, B_n = compute_chudnovsky_term(n) P *= P_n Q *= Q_n B_acc += B_n # Critical phase accumulation T_leaf = Q * B_acc # Correct phase synthesis return P, Q, T_leaf Key Innovation: Direct accumulation of the linear term B(n) prevents phase drift, preserving arithmetic integrity at any scale. Shared-Nothing Architecture Each of the 6 workers operates in complete memory isolation: Independent address spaces (no shared memory locks) Local garbage collection (prevents heap fragmentation) Cache-optimised access patterns (maximises L1/L2 utilisation) Numerical Stability Guarantees Orthogonal decomposition — zero information loss (verified experimentally) Arbitrary precision backend (gmpy2) with proven numerical stability Exact phase correction in the Stride-6 leaf 📚 Citation & Academic Use If this work contributes to your research, please cite: @article{peinador2026modularDSP, title={A Modular DSP Architecture for Extreme-Precision Computation of π}, author={Peinador Sala, José Ignacio}, journal={Zenodo}, year={2026}, doi = {10.5281/zenodo.17768718}, url = {https://github.com/NachoPeinador/Arquitectura-de-Hibridacion-Algoritmica-en-Z-6Z} } The companion theoretical work establishing the polyphase isomorphism is: @article{peinador2026polyphase, title={Polyphase Isomorphism between Modular Arithmetic and Multirate Signal Processing}, author={Peinador Sala, José Ignacio}, year={2026}, publisher={Zenodo}, doi = {10.5281/zenodo.17680023} } 🌐 The Broader Research Programme This architecture is one component of a larger investigation into the computational and physical consequences of the ℤ/6ℤ modular symmetry. Related projects include: Polyphase Isomorphism: Formal mathematical proof of the isomorphism between modular arithmetic and DSP. Modular Substrate Theory: Unified framework for cosmology and hadronic physics. Topological State Preparation: Quantum register initialisation and dissipative protection via ℤ/6ℤ superselection. Common Thread: All projects leverage modular arithmetic (ℤ/6ℤ) as a fundamental organising principle across mathematics, physics, and computation. ⚖️ Licensing & Usage ✅ Academic & Research Use (Free) Available under PolyForm Noncommercial License 1.0.0: Permitted: Academic research, teaching, personal projects, non-commercial forks Requirements: Attribution, license preservation, non-commercial use ⛔ Commercial Use (License Required) Commercial applications require explicit permission, including: Integration into proprietary software products Commercial hardware benchmarking services SaaS platforms and cloud computing services 💼 For Commercial Licensing Inquiries:Contact: joseignacio.peinador@gmail.comSubject: "Commercial License Inquiry — Modular π Architecture" 🌟 Acknowledgments This independent research was enabled by: Infrastructure & Tools Google Colab for democratised computational resources Python ecosystem (gmpy2, NumPy, SciPy, Jupyter) for scientific computing GitHub for open collaboration infrastructure Data & References y-cruncher for validation benchmarks Digital Signal Processing community for foundational theory Community & Inspiration The open-source scientific community for collective knowledge advancement Independent researchers worldwide pushing boundaries outside traditional institutions Last updated: June 2026 | Version: 3.0 | Status: Actively Maintained

Tarsha Kurdi, Mamone

We present ZK IR, a novel 32-bit instruction set architecture (ISA) specifically designed for efficient zero-knowledge proof generation using STARK protocols. Unlike existing zkVMs that adapt general-purpose ISAs like RISC-V, ZK IR is designed from first principles to minimize proving overhead while maintaining compatibility with modern compiler toolchains. Our key contribution is a rigorous analysis demonstrating that a pure 32-bit register architecture with software-based multi-precision arithmetic outperforms designs with wider registers or specialized field arithmetic units. We achieve approximately 2× reduction in constraint count compared to naive approaches. ZK IR uses the Baby Bear field (31-bit prime) with Plonky3 for proving, and provides an LLVM-based compiler infrastructure enabling developers to write ZK applications in Rust, C, and C++.

Chen Yuan, Ruiqi Zhu

List decoding of codes can be seen as the generalization of unique decoding of codes while list decoding over finite fields has been extensively studied, extending these results to more general algebraic structures such as Galois rings remains an important challenge. Due to recent progress in zero knowledge systems, there is a growing demand to investigate the proximity gap of codes over Galois rings in Yizhou Yao(2025). The proximity gap is closely related to the decoding capability of codes. It was shown in Eli Ben-Sasson(2020) that the proximity gap for RS codes over finite field can be improved to $1-\sqrt{r}$ if one consider list decoding instead of unique decoding. However, we know very little about RS codes over Galois ring which might hinder the development of zero knowledge proof system for ring-based arithmetic circuit. In this work, we first extend the list decoding procedure of Guruswami and Sudan to Reed-Solomon codes over Galois rings, which shows that RS codes with rate $r$ can be list decoded up to radius $1-\sqrt{r}$. Then, we investigate the list decoding of folded Reed-Solomon codes over Galois rings. We show that the list decoding radius of folded Reed-Solomon codes can reach the Singlton bound as its counterpart over finite field. We also extend the deterministic pruning method of Vikrant Ashvinkumar(2026) to Galois rings, showing how to prune the affine free module obtained from the linear-algebraic decoder and recover the candidate codewords. Finally, we improve the list size of our folded Reed-Solomon code to $O(1/\varepsilon^2)$ by extending recent work in Shashank Srivastava(2025) to Galois Rings. By developing the recent work of Yeyuan Chen(2025), we show that folded Reed-Solomon codes over Galois rings satisfy the relaxed generalized Singleton bound in the average-radius sense with optimal list size $O(1/\varepsilon)$.

Haoming Li, Fangxin Liu, Chenyang Guan, Zongwu Wang · 6 authors

Barrett's algorithm is one of the most widely used methods for performing modular multiplication, a critical nonlinear operation in modern privacy computing techniques such as homomorphic encryption (HE) and zero-knowledge proofs (ZKP). Since modular multiplication dominates the processing time in these applications, computational complexity and memory limitations significantly impact performance. Computing-in-Memory (CiM) is a promising approach to tackle this problem. However, existing schemes currently suffer from two main problems: 1) Most works focus on low bit-width modular multiplication, which is inadequate for mainstream cryptographic algorithms such as elliptic curve cryptography (ECC) and the RSA algorithm, both of which require high bit-width operations; 2) Recent efforts targeting large number modular multiplication rely on inefficient in-memory logic operations, resulting in high scaling costs for larger bit-widths and increased latency. To address these issues, we propose LaMoS, an efficient SRAM-based CiM design for large-number modular multiplication, offering high scalability and area efficiency. First, we analyze the Barrett's modular multiplication method and map the workload onto SRAM CiM macros for high bit-width cases. Additionally, we develop an efficient CiM architecture and dataflow to optimize large-number modular multiplication. Finally, we refine the mapping scheme for better scalability in high bit-width scenarios using workload grouping. Experimental results show that LaMoS achieves a $7.02\times$ speedup and reduces high bit-width scaling costs compared to existing SRAM-based CiM designs.

Xiangyu Ma, Zhibo Guan, Xiaoyu Wang, Yuxin Yang · 7 authors

Driven by the increasing demand for multi-party data computation, Private Set Intersection (PSI) has become a pivotal technique for secure data sharing and privacy preservation. Although several efficient two-party PSI protocols have been developed, multi-party scenarios continue to suffer from limited computational efficiency and inadequate security guarantees. To address this engineering challenge, this study aims to enhance the performance and security of multi-party PSI protocols. We introduce SM-MPSI, a multi-party PSI protocol built upon national cryptographic standards. This protocol integrates SM2 and SM3 cryptographic mechanisms, employs non-interactive zero-knowledge proofs for identity authentication, and leverages domestic secure cryptographic chips to accelerate core algorithms. Experimental comparisons with existing mainstream protocols demonstrate significant improvements in computational efficiency and system scalability, while preserving robust security guarantees. Furthermore, SM-MPSI achieves enhanced communication efficiency and reduced resource consumption in multi-party scenarios. This research offers technical contributions toward advancing China's efforts in independent innovation in privacy-preserving computing and cryptographic technologies, thereby laying a solid foundation for strengthening national cybersecurity capabilities.

Kadhim Abdulfadhil Gatea

This paper addresses the challenge of designing secure and private digital credentialing systems by leveraging advanced mathematical primitives from applied cryptography. The core of our proposed solution is the application of Zero-Knowledge Proofs (ZKPs), a class of cryptographic protocols that allows for the verification of assertions without disclosing the underlying secret data. We introduce a formal, layered architecture that demonstrates how the mathematical properties of ZKPs can be systematically translated into a robust, large-scale information system. The framework's design is validated against the complex requirements of the academic domain, which serves as a rigorous testbed for our architectural approach. The primary contribution is a blueprint for integrating complex cryptographic protocols into practical system design, demonstrating how mathematical guarantees of privacy can be preserved in a distributed and verifiable manner. This work provides a novel contribution at the intersection of applied cryptography, system architecture, and information security.

Gerasimov, Dmitrii A.

ChipmunkRing, a practical post-quantum ring signature construction tailored for blockchain environments. Building on our Chipmunk lattice-based cryptographic framework, this implementation delivers compact digital signatures ranging from 20.5 to 279.7KB, with rapid signing operations completing in 1.1-15.1ms and efficient validation processes requiring only 0.4-4.5ms for participant groups of 2-64 members. The cornerstone of our approach is Acorn Verification-a streamlined zero-knowledge protocol that supersedes the classical Fiat-Shamir methodology. This innovation enables linear O(n) authentication complexity using concise 96-byte cryptographic proofs per participant, yielding a remarkable 17.7x performance enhancement for 32-member rings when compared to conventional techniques. Our work includes rigorous mathematical security demonstrations confirming 112-bit post-quantum protection (NIST Level 1), extensive computational benchmarking, and comprehensive support for both standard anonymity sets and collaborative threshold constructions with flexible participation requirements.

Tarunesh Verma, Yichao Yuan, Nishil Talati, Todd Austin

Zero-Knowledge Proofs (ZKP) are protocols which construct cryptographic proofs to demonstrate knowledge of a secret input in a computation without revealing any information about the secret. ZKPs enable novel applications in private and verifiable computing such as anonymized cryptocurrencies and blockchain scaling and have seen adoption in several real-world systems. Prior work has accelerated ZKPs on GPUs by leveraging the inherent parallelism in core computation kernels like Multi-Scalar Multiplication (MSM). However, we find that a systematic characterization of execution bottlenecks in ZKPs, as well as their scalability on modern GPU architectures, is missing in the literature. This paper presents ZKProphet, a comprehensive performance study of Zero-Knowledge Proofs on GPUs. Following massive speedups of MSM, we find that ZKPs are bottlenecked by kernels like Number-Theoretic Transform (NTT), as they account for up to 90% of the proof generation latency on GPUs when paired with optimized MSM implementations. Available NTT implementations under-utilize GPU compute resources and often do not employ architectural features like asynchronous compute and memory operations. We observe that the arithmetic operations underlying ZKPs execute exclusively on the GPU's 32-bit integer pipeline and exhibit limited instruction-level parallelism due to data dependencies. Their performance is thus limited by the available integer compute units. While one way to scale the performance of ZKPs is adding more compute units, we discuss how runtime parameter tuning for optimizations like precomputed inputs and alternative data representations can extract additional speedup. With this work, we provide the ZKP community a roadmap to scale performance on GPUs and construct definitive GPU-accelerated ZKPs for their application requirements and available hardware resources.

Cheng Chen, Gangqiang Yang, Hongchao Zhou, Hailiang Xiong · 6 authors

Zero-knowledge Proof (ZKP), is an effective cryptographic primitive that allows one party to verify the correctness of a given statement without disclosing any additional information. It plays a central role in applications such as blockchain transactions and cryptocurrencies. However, implementations of ZKP suffer from the most time-consuming task called Multi-Scalar Multiplication (MSM). Existing works and evaluation criteria primarily emphasize speed enhancement, but overlook optimizations of area overhead. In this paper, a FPGA-based accelerator FusionMSM is designed to reduce the overall latency but also improve area overhead. We attribute the bottleneck of MSM to a three-layer pyramid, including the finite field arithmetic, point operations on elliptic curves and scheduling. For modular arithmetic, we propose an efficient and non-Montgomery modular multiplier by utilizing hybrid multiplication strategy and optimizing multi-bit LUT-based modular reduction. It obtains 1.11 x less area cost and 2.00 x speed-up versus the modular multipliers used in ZKP acceleration works. For point operations, we design a unified and fully pipelined point addition unit, which can run at 500 MHz, the highest frequency in the reported works. On top of that, we present a greedy mechanism to resolve potential collisions, which can reduce the idle cycles of the point addition unit and improve its utilization. As far as we know, FusionMSM achieves the best performance compared to other FPGA-based and ASIC-based works for the input sizes from 218 to 226. For the degree of 220, FusionMSM only needs 12.4% of time in Hardcaml, 24.54% of time in PipeMSM on FPGA, and 36.41% of time in ASIC-based work PipeZK. It also utilizes less resources, resulting in a 90.93% reduction in URAMs, 35.24% reduction in FFs and 47.59% reduction in CARRY8s. Compared to GPU-based implementations, FusionMSM delivers comparable performance but with a lower power of 24.5 W.

L. Domven, Aliyu Danladi Hina, A. M. Kwami, C. M. Miri · 5 authors

This study proposes a secure mobile voting system that integrates elliptic curve cryptography (ECC) with secure multiparty computation (SMPC) to guarantee vote confidentiality, integrity, and verifiability. Designed to enable scalable, privacy-preserving elections via mobile devices, the system authenticates voters using registered numbers and records ballots as encrypted points on an elliptic curve. Encrypted votes are published on a public bulletin board alongside zero-knowledge proofs to ensure their validity. To safeguard decryption, Shamir’s secret sharing distributes keys among trusted authorities, enabling collective tallying without exposing individual votes. The system incorporates ECC-based secret sharing, homomorphic encryption, and zero-knowledge proofs, leveraging the hardness of the elliptic curve discrete logarithm problem (ECDLP) for robust security. Both experimental and theoretical evaluations demonstrate that ECC significantly improves computational efficiency and scalability, making the system well-suited for resource-constrained environments. Overall, the integration of ECC and SMPC offers a practical, efficient, and secure framework for mobile elections, effectively balancing privacy, security, and performance.

Hao Cheng, Georgios Fotiadis, Johann Großschädl, Daniel Page

Non-degenerate bilinear maps on elliptic curves, commonly referred to as pairings, have many applications including short signature schemes, zero-knowledge proofs and remote attestation protocols. Computing a state-of-the-art pairing at the 128-bit security level, such as the optimal ate pairing over the curve BLS12-381, is very costly due to the high complexity of some of its sub-operations: most notable are the Miller loop and final exponentiation. In the past ten years, a few optimized pairing implementations have been introduced in the literature, but none of those took advantage of the vector (SIMD) extensions of state-of-the-art Intel and AMD CPUs, especially AVX-512; this is surprising, because doing so offers the potential to reach significant speed-ups. Consequently, the questions of 1) how computation of the optimal ate pairing can be effectively vectorized, and 2) what execution time such a vectorized implementation can achieve are still open. This paper addresses said questions by introducing a carefully-optimized AVX-512 implementation of the optimal ate pairing on BLS12-381. A central feature of the implementation is the use of 8-way Integer Fused Multiply-Add (IFMA) instructions, which are capable to execute eight 52 x 52-bit multiplications in a SIMD-parallel fashion. We introduce new vectorization strategies and describe optimizations of existing ones to speed up arithmetic operations in the extension fields Fp4 , Fp6 , and Fp12 as well as certain higher-level functions. Furthermore, we discuss some parallelization bottlenecks and how they impact execution time. We benchmarked our pairing software, which we call avxbls, on an Intel Core i3-1005G1 (“Ice Lake”) CPU and found that it needs 1, 265, 314 clock cycles (resp. 1, 195, 236 clock cycles) for the full pairing, with the Granger-Scott cyclotomic squaring (resp. compressed cyclotomic squaring) being used in the final exponentiation. For comparison, the non-vectorized (i.e., scalar) x64 assembly implementation from the widely-used blst library has an execution time of 2, 351, 615 cycles, which is 1.86 times (resp. 1.97 times) slower. avxbls also outperforms Longa’s implementation (CHES 2023) by almost the same factor. The practical importance of these results is amplified by Intel’s recent announcement to support AVX10, which includes IFMA instructions, in all future CPUs.

Florian Hirner, Florian Krieger, Constantin Piber, Sujoy Sinha Roy

Zero-knowledge proofs (ZKPs) are cryptographic protocols that enable one party to prove the validity of a statement without revealing any information beyond its truth. Central building blocks in many ZKPs are polynomial commitment schemes (PCS) where constructions with linear-time provers are especially attractive. Two such examples are Brakedown and its extension Orion, which enable linear-time and quantum-resistant proving by leveraging linear-time encodable Spielman codes. However, these PCS operate over large datasets, creating significant computational bottlenecks. For example, committing to and proving a degree 228 polynomial requires around 1.1 GB of data while taking 463 seconds on a high-end server CPU.This work addresses the performance bottleneck in Orion-like PCS by optimizing their most critical operations: Spielman encoding and Merkle commitments. These operations involve Gigabytes of data and suffer from random off-chip memory access patterns that drastically reduce off-chip bandwidth. We resolve this issue and introduce inverted expander graphs to eliminate random writes and reduce off-chip memory accesses by over 50%. Additionally, we propose an on-the-fly graph sampling method that avoids streaming large auxiliary data by generating expander graphs dynamically on-chip. We also provide a formal security proof for our proposed graph transformation. Beyond encoding, we accelerate Merkle Tree construction over large data sets through a scalable multi-pass SHA3 pipeline. Finally, we reutilize existing hardware components used in commitment to accelerate the so-called proximity and consistency checks during proof generation.Building upon these concepts, we present the first hardware architecture for PCS – with linear prover time – on an Xilinx Alveo U280 FPGA. In addition, we discuss the practical challenges of manually partitioning, placing, and routing our large-scale architecture to efficiently map it to the multi-SLR and HBM-equipped FPGA. The final implementation achieves a speedup of two orders of magnitude for full proof generation, covering commitment and proving steps. When combined with Virgo as an outer CP-SNARK protocol, our accelerator reduces end-to-end latency by up to 3.85x – close to the theoretical maximum of 3.9x.

Umut Turusbekova, Gulmira Bekmanova, Aizhan Nazyrova, Artem Bykov · 5 authors

Designing secure electronic voting systems that truly protect voter privacy, ensure vote accuracy, and allow independent verification continues to pose serious difficulties. Many current cryptographic approaches require excessive computational resources and use encryption keys that are too large for practical implementation. This paper proposes modifications to the Chaum, Pedersen and Cramer, Franklin, Schoenmakers, and Yung voting protocols by integrating elliptic curve cryptography (ECC), which offers stronger security per bit and more compact key representations. The use of ECC allows for reduced parameter sizes while maintaining resistance against known attacks, including those targeting the discrete logarithm problem. We present detailed adaptations of these protocols on elliptic curves and demonstrate how they preserve core security properties such as vote secrecy, universal verifiability, and resistance to double voting under a more efficient cryptographic framework. Our findings contribute to the development of scalable, high-assurance e-voting mechanisms suitable for modern digital infrastructures. The presented modifications significantly enhance the scalability and efficiency of e-voting systems without compromising cryptographic strength.

Ruslan Kysil, István András Seres, Péter Kutas, Nándor Kelecsényi

This work explores the application and efficient deployment of (standardized) post-quantum (PQ) digital signature algorithms in the blockchain environment. Specifically, we implement and evaluate four PQ signatures in the Ethereum Virtual Machine: W-OTS+ , XMSS, SPHINCS+, and MAYO. We focus on optimizing the gas costs of the verification algorithms as that is the signature schemes’ only algorithm executed on-chain, thus incurring financial costs (transaction fees) for the users. Hence, the verification algorithm is the signature schemes’ main bottleneck for decentralized applications. We examine two methods to verify post-quantum digital signatures on-chain. Our practical performance evaluation shows that full on-chain verification is often prohibitively costly. Naysayer proofs (FC’24) allow a novel optimistic verification mode. We observe that the Naysayer verification mode is generally the cheapest, at the cost of additional trust assumptions. We release our implementation called poqeth as an open-source library.

Evgeniya Ishchukova, Sergei Petrenko, A. Petrenko, Konstantin Gnidko · 5 authors

Today, blockchain technologies are a separate, rapidly developing area. With rapid development, they open up a number of scientific problems. One of these problems is the problem of reliability, which is primarily associated with the use of cryptographic primitives. The threat of the emergence of quantum computers is now widely discussed, in connection with which the direction of post-quantum cryptography is actively developing. Nevertheless, the most popular blockchain platforms (such as Bitcoin and Ethereum) use asymmetric cryptography based on elliptic curves. Here, cryptographic primitives for blockchain systems are divided into four groups according to their functionality: keyless, single-key, dual-key, and hybrid. The main attention in the work is paid to the most significant cryptographic primitives for blockchain systems: keyless and single-key. This manuscript discusses possible scenarios in which, during practical implementation, the mathematical foundations embedded in the algorithms for generating a digital signature and encrypting data using algorithms based on elliptic curves are violated. In this case, vulnerabilities arise that can lead to the compromise of a private key or a substitution of a digital signature. We consider cases of vulnerabilities in a blockchain system due to incorrect use of a cryptographic primitive, describe the problem, formulate the problem statement, and assess its complexity for each case. For each case, strict calculations of the maximum computational costs are given when the conditions of the case under consideration are met. Among other things, we present a new version of the encryption algorithm for data stored in blockchain systems or transmitted between blockchain systems using elliptic curves. This algorithm is not the main blockchain algorithm and is not included in the core of modern blockchain systems. This algorithm allows the use of the same keys that system users have in order to store sensitive user data in an open blockchain database in encrypted form. At the same time, possible vulnerabilities that may arise from incorrect implementation of this algorithm are considered. The scenarios formulated in the article can be used to test the reliability of both newly created blockchain platforms and to study long-existing ones.

П.Д. Павел

Существующие типовые модели аутентификации с использованием цифровых удостоверений носят абстрактный характер. Для конкретизации модели аутентификации с использованием цифровых удостоверений предлагаются: алгоритм эмиссии цифровых удостоверений; алгоритм аутентификации на основе доказательства с нулевым разглашением. Производится количественная оценка раскрытых данных удостоверений в результате: предложенного алгоритма аутентификации на основе доказательства с нулевым разглашением; аутентификации с полным раскрытием атрибутов; аутентификации с частичным раскрытием атрибутов. Полученные результаты оценок анализируются и делаются соответствующие выводы. Existing standard authentication models using digital credentials tend to be abstract. To refine the authentication model using digital credentials, the following are proposed: a digital credential issuance algorithm and an authentication algorithm based on zero-knowledge proof. A quantitative assessment is conducted on the amount of disclosed credential data resulting from the proposed zero-knowledge proof-based authentication algorithm, authentication with full attribute disclosure, and authentication with partial attribute disclosure. The assessment results are analyzed, and relevant conclusions are drawn.

Agathe Beaugrand

Arguments à divulgation nulle de connaissance efficaces et succincts dans le cadre du chiffrement CL et applications Le schéma de chiffrement CL est un système de chiffrement à clé publique linéairement homomorphe, proposé en 2015 par Castagnos et Laguillaumie. Il repose sur l’utilisation de groupes de classes de corps quadratiques imaginaires. Ces groupes finis ont la particularité d’être considérés d’ordre inconnu, c’est-à-dire que l’ordre d’un tel groupe est difficile à déterminer de manière algorithmique. Cet ordre inconnu est un atout précieux pour les applications cryptographiques, et est central dans la construction du chiffrement CL. Cependant, il est aussi à l’origine d’importantes difficultés techniques liées à la manipulation de chiffrés CL. Dans ce contexte, la construction d’arguments, et à fortiori d’arguments de connaissance, à divulgation nulle de connaissance est particulièrement exigeante, et constitue un défi majeur à relever. En effet, les techniques classiques permettant d’améliorer l’efficacité des preuves dans le cas d’un groupe d’ordre premier, et en particulier celles liées à la robustesse, s’adaptent mal au cas de l’ordre inconnu. Les arguments de connaissance existants sont donc souvent peu efficaces, avec des coûts de communication et de calcul élevés. Dans cette thèse, nous concevons de nouveaux protocoles à divulgation nulle de connaissance spécifiquement adaptés au cadre du chiffrement CL, afin d’obtenir des preuves plus courtes et efficaces que les protocoles existants. Nos protocoles reposent sur deux outils principaux : le premier est l’hypothèse C-rough, introduite par Braun, Damgard et Orlandi en 2023. Cette hypothèse algorithmique spécifique au cadre de CL stipule qu’il est difficile de décider si l’ordre d’un groupe de classes engendré par l’algorithme d’initialisation de CL possède des facteurs premiers plus petit qu’un seuil C. Le second est un concept novateur appelé extractabilité partielle, qui correspond à une notion affaiblie de robustesse de la connaissance. Cette notion est particulièrement adaptée au cadre de CL, car elle permet de traiter séparément les textes clairs et les aléas apparaissant dans les chiffrés CL. En particulier, elle permet d’exploiter les techniques du cas de l’ordre premier pour obtenir de l’information sur les textes clairs – définis modulo un nombre premier connu – même si les aléas sont définis modulo un entier composé et, surtout, inconnu. Grâce à ces deux outils, nous construisons des protocoles à divulgation nulle de connaissance permettant de prouver, d’une part, des énoncés classiques, comme le fait qu’un chiffré CL est bien formé, et d’autre part, des énoncés plus spécifiques, tels que le mélange aléatoire de chiffrés. Les preuves à divulgation nulle de connaissance sont essentielles à la sécurité des protocoles de calcul multipartite, en particulier face à des adversaires malveillants, car elles permettent de garantir que les participants se comportent conformément au protocole. Ainsi, disposer de preuves efficaces pour le chiffrement CL représente une étape fondamentale dans la construction de protocoles de calcul distribué pratiques et sûrs utilisant CL. En application de nos techniques, nous présentons un protocole, sûr en présence d’un adversaire malveillant, qui réalise la fonctionnalité “PSI-sum” – une variante de l’intersection privée d’ensembles. Cet exemple pratique met en évidence l’intérêt du chiffrement CL comme bloc de base pour réaliser des fonctionnalités avancées de calcul multipartite.

Yancheng Zhang, Mengxin Zheng, Xun Chen, Jingtong Hu · 8 authors

In the context of cloud computing, services are held on cloud servers, where the clients send their data to the server and obtain the results returned by server. However, the computation, data and results are prone to tampering due to the vulnerabilities on the server side. Thus, verifying the integrity of computation is important in the client-server setting. The cryptographic method known as Zero-Knowledge Proof (ZKP) is renowned for facilitating private and verifiable computing. ZKP allows the client to validate that the results from the server are computed correctly without violating the privacy of the server’s intellectual property. Zero-Knowledge Succinct NonInteractive Argument of Knowledge (zkSNARKs), in particular, has been widely applied in various applications like blockchain and verifiable machine learning. Despite their popularity, existing zkSNARKs approaches remain highly computationally intensive. For instance, even basic operations like matrix multiplication require an extensive number of constraints, resulting in significant overhead. In addressing this challenge, we introduce $z k V C$, which optimizes the ZKP computation for matrix multiplication, enabling rapid proof generation on the server side and efficient verification on the client side. zkVC integrates optimized ZKP modules, such as Constraint-reduced Polynomial Circuit (CRPC) and Prefix-Sum Query (PSQ), collectively yielding a more than $\mathbf{1 2}$-fold increase in proof speed over prior methods. The code is available at https://github.com/UCF-Lou-Lab-PET/zkformer.

Alhad Daftardar, Jianqiao Mo, Joey Ah-kiow, Benedikt Bünz · 7 authors

Zero-Knowledge Proofs (ZKPs) are a rapidly growing technique for privacy-preserving and verifiable computation.ZKPs enable one party (a prover: P) to prove to another (a verifier: V) that a statement is true or correct without revealing any additional information.This powerful capability has led to ZKPs being applied and proposed for application in blockchain technologies, verifiable machine learning, and electronic voting.However, ZKPs have yet to see widespread, ubiquitous adoption due to the exceptionally high computational complexity of the proving process.Naturally, there has been recent work to accelerate ZKP primitives and protocols using GPUs and ASICs.However, the protocols considered so far face one of two challenges: they require a trusted setup for each new application or generate large proofs with high verification costs, limiting their applicability in scenarios with numerous verifiers or strict verification time constraints.HyperPlonk is a state-of-theart ZKP protocol that supports both one-time, universal setup and small proof sizes/verification costs expected by publicly verifiable, consensus-based systems (e.g., blockchain).While HyperPlonk's setup and verifier properties are highly desirable, the proving phase is costly.A HyperPlonk prover must compute on large bitwidths (e.g., 255-381b) and polynomials (e.g., of degree 2 24 ), employs computationally (e.g., MSM) and bandwidth (e.g., SumCheck) intensive kernels, and the complete protocol comprises many steps, each constituting distinct kernels.We present an accelerator, zkSpeed, to

Rares Ifrim, Decebal Popescu

Popular technologies such as blockchain and zero-knowledge proof, which have already entered the enterprise space, heavily use cryptography as the core of their protocol stack. One of the most used systems in this regard is Elliptic Curve Cryptography, precisely the point multiplication operation, which provides the security assumption for all applications that use this system. As this operation is computationally intensive, one solution is to offload it to specialized accelerators to provide better throughput and increased efficiency. In this paper, we explore the use of Field Programmable Gate Arrays (FPGAs) and the High-Level Synthesis framework of AMD Vitis in designing an elliptic curve point arithmetic unit (point adder) for the secp256k1 curve. We show how task-level parallel programming and data streaming are used in designing a RISC processor-like architecture to provide pipeline parallelism and increase the throughput of the point adder unit. We also show how to efficiently use the proposed processor architecture by designing a point multiplication scheduler capable of scheduling multiple batches of elliptic curve points to utilize the point adder unit efficiently. Finally, we evaluate our design on an AMD-Xilinx Alveo-family FPGA and show that our point arithmetic processor has better throughput and frequency than related work.