• [digest] 2026 Week 42

    From IACR ePrint Archive@noreply@example.invalid to sci.crypt on Mon Oct 19 02:27:47 2026
    From Newsgroup: sci.crypt

    ## In this issue
    1. [2026/246] Highly Efficient and Round-Optimal Asymmetric PAKE
    2. [2026/262] Fuzzy Private Set Intersection under Density- ...
    3. [2026/991] DDYF: Differential Dolev-Yao Fuzzing of ...
    4. [2026/1706] Cryptanalysis of rCyQuantum public key encryption ...
    5. [2026/2029] It's Not Just a Phase: Understanding Function ...
    6. [2026/2109] Attacking CRT-RSA with Small Exponents via ...
    7. [2026/2423] Magnetar: High-speed post-quantum RV64 zkVM from ...
    8. [2026/2432] Lattice Bingo: Asynchrony and One-Shot Adaptivity ...
    9. [2026/2447] A methodology to derive security specifications for ...
    10. [2026/2449] Optimal Threshold Implementations of all bijective ...
    11. [2026/2451] Extended biprojective APN functions
    12. [2026/2463] Tree-BTE: Batched Threshold Encryption using ...
    13. [2026/2466] Trustless Bitcoin Vaults
    14. [2026/2471] Connecting Cryptanalytic Distinguishers through ...
    15. [2026/2476] On the Hardness of Finding Permutation ...
    16. [2026/2477] Secret Sharing from Non-Extractable Randomness
    17. [2026/2478] Hardware-Level Mitigation of Micro-Architectural ...
    18. [2026/2479] Committing Security of Forkcipher-based AEAD
    19. [2026/2480] Post-Quantum Certificate-Based PSK Provisioning for ...
    20. [2026/2481] Polygero: Proximity Testing From Polynomial Challenges
    21. [2026/2482] Edabits Generation with Quasi-Linear Communication ...
    22. [2026/2483] Uniform Sharing in Multiple Stages: Towards Second- ...
    23. [2026/2484] Unveiling the Cost: Gas-Efficient Output-Private ...
    24. [2026/2485] Tulva: Practical Asynchronous Threshold FHE
    25. [2026/2486] Heterogeneous CPUrCoNPU Implementation of the AIMer ...
    26. [2026/2487] A Hybrid BP-SAT Attack on MILENAGE: Combining the ...
    27. [2026/2488] Yoshan: Algebraic-Circuit Co-Synthesis and Search ...
    28. [2026/2489] FAEST on GPUs: Addressing Field Multiplication as a ...
    29. [2026/2490] Reaction Attack on CKKS Deployments with ...
    30. [2026/2491] Shift-Invariant Permutations with Polynomial ...
    31. [2026/2492] Exploring Fault Injection Attacks on HQC and BIKE ...
    32. [2026/2493] Robust ECDSA Threshold Signing at Scale
    33. [2026/2494] Speeding up Sumcheck using Algebraic Geometry
    34. [2026/2495] Issuer-Independent Decentralized Exchange for E-Cash
    35. [2026/2496] Structural Cryptanalysis of the Eevee AEAD Family
    36. [2026/2497] SecAgg++: A Post-Quantum Privacy Preserving ...
    37. [2026/2498] Noise-Tolerant Quantum One-Time Programs Using ...
    38. [2026/2499] GhostFaceMPC: Privacy-Preserving Face Recognition ...
    39. [2026/2500] Threshold Post-Quantum E-Voting from Lattice ...
    40. [2026/2501] Aerie: Efficient Aggregation of Falcon Signatures
    41. [2026/2502] Shorter Hash-Based Signatures via Guarded Sharing ...
    42. [2026/2503] SwiftAuth: Conditional Privacy-Preserving UAV ...
    43. [2026/2504] Byzantine Broadcast in $\widetilde{O}(n^2)$ ...
    44. [2026/2505] AVX-512 Acceleration of SQIsign 3.0 Verification
    45. [2026/2506] Efficient Two-Dimensional Representation Evaluation ...
    46. [2026/2507] safeRNSgcd: Accelerating Falcon key generation with ...
    47. [2026/2508] Power Analysis on SQIsign via Ideal Reconstruction ...
    48. [2026/2509] Sparse Secrets, Dense Problems: Efficiently Masking ...
    49. [2026/2510] Secure Compilation of Probabilistic Side-Channel ...
    50. [2026/2511] I Want to Ride My BIKE: Customizing Bit-Flipping ...
    51. [2026/2512] SLEEK: Sparse Quasi-Cyclic Codes with Closed-Form ...
    52. [2026/2513] Fully Homomorphic Encryption for Small Batches of ...
    53. [2026/2514] Analysis of the Multi-Key Optimization for SPECK
    54. [2026/2515] CHAMP: Cayley HAshing with Matrix Products
    55. [2026/2516] Watermarking Proofs with Provenance-Binding ZK-SNARKs
    56. [2026/2517] Zippel: A Language, Compiler, Runtime, and Analyzer ...
    57. [2026/2518] Associated-Data Correlations in Eevee: ...
    58. [2026/2519] DPA-style Attacks on VOLE-in-the-Head Signature Schemes
    59. [2026/2520] GPU Acceleration for Boyar-Peralta Algorithm in ...
    60. [2026/2521] EN4acient Fixed-Point Implementation of Mitaka
    61. [2026/2522] Superspecial points on Humbert surfaces and the ...
    ## 2026/246
    * Title: Highly Efficient and Round-Optimal Asymmetric PAKE
    * Authors: Zachary Barbanell, Jiayu Xu
    * [Permalink](https://eprint.iacr.org/2026/246)
    * [Download](https://eprint.iacr.org/2026/246.pdf)
    ### Abstract
    An asymmetric Password-Authenticated Key Exchange (aPAKE) protocol allows a client, who holds a raw password, and a server, who holds a one-way mapping of the password, to jointly establish a cryptographically strong session key, without an authenticated channel. The standard security definition for aPAKE is in the Universal Composability (UC) framework. Despite its great potential of being used in practice, existing aPAKE protocols are either not round-optimal, computationally inefficient, or not proven secure.
    In this work, we present two aPAKE protocols that are 1 simultaneous round, UC-secure, have reasonable computational costs, and rely on mild cryptographic assumptions. Our first protocol is in the Random Oracle Model and the Algebraic Group Model (ROM+AGM), secure under the CDH assumption, and has computational cost comparable to the most efficient aPAKE protocols in the literature (1 simultaneous round or not). Our second protocol is in the ROM only and secure under the DDH assumption, and also has significantly lower computational cost than the only other UC-secure 1 simultaneous round aPAKE protocol. Interestingly, even our second protocol does not rely on the gap Diffie-Hellman assumption, which requires creative application of the forking lemma.
    ## 2026/262
    * Title: Fuzzy Private Set Intersection under Density-Bounded Assumptions
    * Authors: Seunghun Paik, Jae Hong Seo
    * [Permalink](https://eprint.iacr.org/2026/262)
    * [Download](https://eprint.iacr.org/2026/262.pdf)
    ### Abstract
    This paper presents a new fuzzy private set intersection (FPSI) protocol, a two-party protocol to securely identify similar items across private sets. Our design departs from the prevailing separation-based paradigm---e.g., ``apart by $2\delta$'' or the disjoint projection assumption---which either incurs exponential overhead in dimensionality or requires high dimensionality to justify the assumption. Instead, we address this tension by explicitly allowing collisions within $\delta$-balls, but requiring that their multiplicity be bounded per axis. We formalize this new structural property as $C$-max collision. We theoretically analyze its plausibility on several common distributions, e.g., the uniform distribution, and real datasets, and provide an efficient algorithm to verify this assumption.
    Under the $C$-max collision property, we propose an efficient FPSI protocol for $\ell_{\infty}$ distance that supports both low- and high-dimensional regimes. Our construction is based on a novel abstraction that views FPSI as an oblivious intersection of membership tags, which natively handles axis-wise matching multiplicity. We capture its requirements through a new functionality called oblivious selected set intersection, along with its instantiation based on symmetric key techniques. Assuming the $C$-max collision property on the receiver's set, our protocol achieves computation/communication complexities scaling linearly with both parties' set sizes for a fixed $C$. We implement our protocol and conduct extensive evaluation. While a direct comparison is infeasible, ours achieves online efficiency comparable to state-of-the-art separation-based FPSI protocols in both low- and high-dimensional regimes.
    ## 2026/991
    * Title: DDYF: Differential Dolev-Yao Fuzzing of Cryptographic Protocols
    * Authors: Tom Gouville, Lucca Hirschi, Steve Kremer
    * [Permalink](https://eprint.iacr.org/2026/991)
    * [Download](https://eprint.iacr.org/2026/991.pdf)
    ### Abstract
    Symbolic formal verification of cryptographic protocols based on the Dolev-Yao (DY) attacker modelrCoan active attacker with full network control and perfect cryptographyrCois well-established for finding design-level logical flaws in cryptographic protocols. Building on this, Dolev-Yao Fuzzing (DYF) enriches fuzzing with this attacker model to uncover logical bugs at the implementation level. In contrast to bit-level fuzzers
    (e.g., AFL), DYF leverages a formal model of messages and cryptography to generate structured, adversarial executions, such as replaying and re-signing a modified payload.
    However, a significant limitation of DYF is the requirement to precisely model properties to check at runtime (e.g., session parameter agreement). Defining these properties is labor-intensive and inherently non-exhaustive, often necessitating complex instrumentation of the Programs Under Test. Consequently, typically only a subset of logical attacks is detected.
    We address this limitation by introducing Differential Dolev-Yao Fuzzing (DDYF) based on a differential oracle to compare executions across different protocol implementations. By interpreting discrepancies through the DY model, it identifies semantic differences indicative of bugs or vulnerabilities, effectively minimizing false positives.
    We propose a generic design for DDYF, implement it within the PUFFIN DY fuzzer, and evaluate it on four major TLS implementations and two SSH implementations. Our results demonstrate that DDYF can detect vulnerabilities that evade state-of-the-art fuzzers, specifically those requiring DY attacker capabilities (missed by bit-level differential fuzzers) or complex objective oracles (missed by DYF). DDYF also uncovered numerous new RFC violations in OpenSSL, BoringSSL, wolfSSL, LibreSSL, libssh, and wolfSSH, which are by-design hardly detectable with non-differential oracles.
    ## 2026/1706
    * Title: Cryptanalysis of rCyQuantum public key encryption scheme with four states keyrCO
    * Authors: Nithik R
    * [Permalink](https://eprint.iacr.org/2026/1706)
    * [Download](https://eprint.iacr.org/2026/1706.pdf)
    ### Abstract
    Liu et al. (2022 Phys. Scr. 97 045102) propose a quantum public key encryption scheme in which a qubit message is encrypted by a controlled-NOT gate driven by a four-state public key, followed by measurement of the message register, and claim information-theoretic security. I show that the encryption map reduces exactly to \( |M\rangle \mapsto R_{\theta}X^{m}|M\rangle \), where the outcome \(m\) is published. \(R_{\theta}\) is diagonal and the ciphertext reproduces the computational-basis distribution \((|\alpha|^2,|\beta|^2)\) of the plaintext, while the plaintexts \(|0\rangle\) and \(|1\rangle\) are perfectly distinguishable. The claim of information-theoretic security is therefore invalid.
    ## 2026/2029
    * Title: It's Not Just a Phase: Understanding Function Dependence in MPC Preprocessing (Extended Version)
    * Authors: Andreas Br|+ggemann, Kasra Edalatnejad, Jan Filipp, Philipp Kusterer, Thomas Schneider
    * [Permalink](https://eprint.iacr.org/2026/2029)
    * [Download](https://eprint.iacr.org/2026/2029.pdf)
    ### Abstract
    Secure multiparty computation (MPC) is a key enabling technology for privacy-preserving applications. To achieve low latency after inputs are provided, many efficient protocols utilize preprocessing, and the landscape of preprocessing approaches is growing and diverse. Some recent works use variants of function-dependent preprocessing, leveraging additional knowledge on the function to be computed for even better performance. While the existing literature primarily focuses on performance, it is mostly overlooked that there exist different kinds of function dependence and what practical implications they have. We systematize the different flavors of function dependence, relating them to practical requirements beyond efficiency.
    ## 2026/2109
    * Title: Attacking CRT-RSA with Small Exponents via Unravelled Linearization
    * Authors: Zhaopeng Ding, Yanshuo Zhang, Zhaopeng Dai, Ziyang Yan, Ying Chen
    * [Permalink](https://eprint.iacr.org/2026/2109)
    * [Download](https://eprint.iacr.org/2026/2109.pdf)
    ### Abstract
    We develop a new Coppersmith lattice attack on balanced CRT-RSA with small CRT exponents $d_p, d_q$ using unravelled linearization. The new attack matches the practical effectiveness of the TakayasurCoLurCoPeng attack (JoC 2019) while using lattices of roughly half the dimension. In contrast to their attack, for which there is a noticeable gap between the theoretical predictions and experimental results, our theoretical estimates closely match the experimental results for all tested parameter sets. Our analysis further shows that the asymptotic bound remains $d_p,d_q<N^{0.122}$, so the new attack does not achieve the asymptotic improvement anticipated by Takayasu, Lu, and Peng. Nevertheless, performing LLL reduction on lower-dimensional lattices substantially reduces the running time, allowing us to attack much larger $d_p,d_q$ in practice.
    Furthermore, through elegant variable substitutions, we extend our attack to two most significant bit (MSB) leakage models, obtaining the first attack exploiting MSB leakage of $p+q$ and an improved attack exploiting MSB leakage of $d_p,d_q$. In both models, the asymptotic bounds improve as the amount of leakage increases and recover the TakayasurCoLurCoPeng bound in the absence of leakage.
    ## 2026/2423
    * Title: Magnetar: High-speed post-quantum RV64 zkVM from standard hashes
    * Authors: Srinath Setty
    * [Permalink](https://eprint.iacr.org/2026/2423)
    * [Download](https://eprint.iacr.org/2026/2423.pdf)
    ### Abstract
    We describe the design, implementation, and experimental evaluation of Magnetar, a transparent proof system for RV64I program executions (i.e., a zkVM). Magnetar is the first zkVM to simultaneously satisfy the following three properties:
    1. General-purpose proving. Magnetar proves programs compiled to the general-purpose RV64I ISA. An implementation of the Ethereum Virtual Machine (EVM) written in Rust or Go can therefore run inside Magnetar, yielding a zkEVM for proving executions of existing EVM smart contracts.
    2. Hash-based, post-quantum security. MagnetarrCOs cryptographic security is rooted in standard hash functions (e.g., SHA-256 or SHA-3).
    3. Efficient recursion. MagnetarrCOs verification work is dominated by evaluating standard hash functions. MagnetarrCOs proof engine, BinarySpartan, is well-suited for such bit-oriented computations, so verifying a proof is itself an efficient proving workload.
    Unlike prior general-purpose zkVMs, Magnetar does not rely on circuit-friendly algebraic hash functions such as Poseidon or Poseidon2, elliptic-curve or lattice assumptions, or a conjectured ReedrCoSolomon proximity gap. Even prior zkVMs commonly described as hash-based rely on elliptic-curve or lattice assumptions in their core proving machinery, provide only about 100 bits of security, or rest on conjectured soundness; some do more than one of these.
    Finally, we implement Magnetar in Rust and experimentally evaluate it. We find that, at 120 bits of provable security and with 12 performance cores on an M4 Max MacBook Pro, Magnetar proves 2^{22}-cycle executions at 7.2rCo8.7 million cycles per second, with proofs of about 600 KiB that verify in 11rCo13 ms. Across 15 application workloads, MagnetarrCOs proving throughput is 24rCo66|u that of SP1 Hypercube, a hash-and-more-based zkVM; 12rCo37|u that of Jolt-Dory, a curve-based zkVM; and 6rCo20|u that of Jolt-Akita, a lattice-based zkVM, with geometric-mean speedups of about 39|u, 18|u, and 9.6|u, respectively. An optimized Magnetar proves 222-cycle executions at 9.5rCo12.8 million cycles per second, which increases each geometric-mean speedup by about 1.3|u. MagnetarrCOs proofs are about 4.6|u smaller than SP1 HypercuberCOs; JoltrCOs proofs are under 100 KiB, but they rely on elliptic-curve or lattice assumptions.
    ## 2026/2432
    * Title: Lattice Bingo: Asynchrony and One-Shot Adaptivity in Verifiable Secret Sharing via Erasure Code Commitments
    * Authors: Ittai Abraham, Aniket Kate, Aditi Partap, Ertem Nusret Tas
    * [Permalink](https://eprint.iacr.org/2026/2432)
    * [Download](https://eprint.iacr.org/2026/2432.pdf)
    ### Abstract
    Asynchronous verifiable secret sharing (AVSS) allows a dealer to distribute a secret among parties while preserving privacy and consistent reconstruction, despite Byzantine faults and arbitrary message delays. It is a fundamental building block for Byzantine agreement, distributed key generation, and secure multiparty computation. Packed AVSS protocols share many secrets together to reduce communication per secret. The best known AVSS protocols achieve quadratic communication while sharing linearly many secrets. In particular, Bingo (Abraham et al., CRYPTO 2023) shares a batch of $\Theta(k)$ secrets among $k$ parties using $O(\lambda k^2)$ words of communication, while also achieving adaptive security, but relies on assumptions that are not post-quantum secure. Known post-quantum alternatives have higher worst-case communication for comparable batch sizes or require substantially larger batches to achieve linear amortized communication.
    We present Lattice Bingo, a lattice-based packed AVSS protocol with quadratic communication and linear packing. For every constant $\epsilon>0$, it shares $\Theta(k)$ secrets among $k\geq(3+\epsilon)f$ parties, tolerates $f$ Byzantine parties, and uses $O(k^2\operatorname{poly}(\lambda))$ words of communication. It additionally achieves one-shot adaptive secrecy: the adversary may adaptively choose its corruption and reconstruction requests based on the public transcript observed so far, but must submit these requests together in a single batch.
    Our main technical contribution is a commitment scheme for two-dimensional linear codes based on the PowerBASIS assumption. We combine PowerBASIS commitments with the linear code based secret sharing of Applebaum, Nir, and Pinkas, replacing the ReedrCoSolomon encoding and KZG commitments used in Bingo. Our commitment supports proof interpolation, enabling parties to recover missing shares and their opening proofs. It additionally achieves a notion that we call one-shot simulation hiding. Together, these properties allow us to adapt BingorCOs framework to obtain Lattice Bingo with the same efficiency and one-shot adaptive security.
    ## 2026/2447
    * Title: A methodology to derive security specifications for complex electronic systems
    * Authors: Sylvain Guilley, Ritu Ranjan Shrivstwa, Ville Yli-M|nyry
    * [Permalink](https://eprint.iacr.org/2026/2447)
    * [Download](https://eprint.iacr.org/2026/2447.pdf)
    ### Abstract
    Modern electronic systems are becoming increas-
    ingly complex and must satisfy demanding performance, power,
    and area (PPA) constraints. Consider for instance artificial
    intelligence chips, aiming at datacenters running LLMs or at
    automotive perception, which manipulate massive data streams.
    Beyond performance considerations, these systems must also
    provide increasingly strong security and dependability guaran-
    tees. Indeed, when electronic systems are based on chiplets, for
    instance, the supply chain gets longer and therefore brings a
    larger number of threats. Also, those systems are very versatile,
    in that they can run varied multi-tenant applications. Therefore,
    defining what security features are required in this context with
    numerous stakes is not trivial.
    Existing scholarly research is very relevant when the security
    problem is well defined. The resulting scientific papers accord-
    ingly dig very deep: this modus operandi has proved productive in
    exploring new problems, and actually allowed to come up with
    innovative solutions. For instance, in the field of side-channel
    attacks, varied mitigations alongside with metrics to evaluate
    them have been devised. Increasing sophistication resulted from
    this research, as external considerations have been injected into
    the problem (typically, aspects such as attack order, impact
    of combinatorial glitches, etc.). Therefore, we face today the
    question of selecting the most suitable technology amongst the
    proliferation of state-of-the-art techniques.
    In addition, in complex systems, we encounter another prob-
    lem, namely that of defining the security problem(s). A fruitful
    approach in this respect is a risk based approach. Specifically,
    the application of a risk-oriented methodology allows to reason
    on the security rationale. It proceeds as follows. First, the
    system missions are listed. Then for each of them, the necessary
    assets are deduced. A threat analysis allows to identify how
    assets are threatened, and eventually, security requirements can
    be enunciated. At this stage, the task of matching relevant
    countermeasures becomes straightforward.
    This paper illustrates the methodology by deriving security
    specifications for datacenter and automotive chiplets. The considered missions are (secure) provisioning, trimming, debugging,
    booting, and remote attestation.
    ## 2026/2449
    * Title: Optimal Threshold Implementations of all bijective 4-bit S-boxes and new Infinite Families
    * Authors: Enrico Piccione, Yevhen Perehuda, Gregor Leander, Patrick Felke
    * [Permalink](https://eprint.iacr.org/2026/2449)
    * [Download](https://eprint.iacr.org/2026/2449.pdf)
    ### Abstract
    Threshold implementations (TIs) are now an established class of side-channel countermeasures. Their underlying idea is simple and compelling: under mild, practical assumptions, they provide protection against glitches and allow composability. Yet our understanding of one-stage TIs with a minimal number of shares remains limited, both for cryptographically relevant familiesrCoparticularly power functionsrCoand for concrete small functions. In particular, until now, except for Feistel-constructions, no optimal TI had been found for families of mathematically well-structured and cryptographically non-trivial functions, especially power functions. In small dimensions, many functions - particularly cryptographically interesting ones rCo were not known to admit an optimal TI. This was especially true for the 4-bit S-boxes frequently used in practical lightweight ciphers. Optimal refers to share-optimal, direct one-stage, uniform, first-order TI. Here, we introduce new families of TIs, including the first infinite families of cryptographically nontrivial power permutations. Moreover, every four-bit permutation of algebraic degree t admits a direct, uniform TI with t+1 shares and no fresh randomness. Those results prove several previous conjectures and claims wrong. Since such permutations are widely used in symmetric ciphers, our constructions offer new implementation options.
    $\textbf{Note:}$ The threshold implementations presented in this paper are available at: https://github.com/enripicc/Optimal-Threshold-Implementations-for-3-4-and-5-bits-permutations
    ## 2026/2451
    * Title: Extended biprojective APN functions
    * Authors: Nadiia Ichanska, Nikolay Kaleyski
    * [Permalink](https://eprint.iacr.org/2026/2451)
    * [Download](https://eprint.iacr.org/2026/2451.pdf)
    ### Abstract
    Almost perfect nonlinear (APN) functions provide optimal resistance to differential cryptanalysis in characteristic two, and constructing new infinite families inequivalent to the known ones remains an important problem in the study of cryptographic functions. We introduce extended biprojective functions, obtained by augmenting biprojective polynomials with truncated trace terms, and establish a new infinite family of quadratic APN functions. To investigate these constructions, we develop an efficient APN test based on the ranks of binary matrices and employ it in exhaustive searches in dimensions up to 28. Using ortho-derivative differential spectra to distinguish CCZ-equivalence classes, we identify APN functions inequivalent to known families and uncover a systematic pattern across dimensions, leading to conjectures on further infinite families of quadratic APN functions.
    ## 2026/2463
    * Title: Tree-BTE: Batched Threshold Encryption using Additive Homomorphism
    * Authors: Amit Agarwal, Sourav Das, Babak Poorebrahim Gilkalaye, Benny Pinkas, Peter Rindal
    * [Permalink](https://eprint.iacr.org/2026/2463)
    * [Download](https://eprint.iacr.org/2026/2463.pdf)
    ### Abstract
    Batched threshold encryption (BTE) enables a committee of servers to jointly decrypt any chosen subset of ciphertexts from a large pool, while all remaining ciphertexts stay private. BTE is a key building block for encrypted mempools, where transactions are encrypted until block inclusion to mitigate maximal extractable value (MEV). We give a new tree-based BTE construction from two simple building blocks which support additive homomorphism: a symmetric-key encryption scheme that is homomorphic over key and message space, and a thresholdizable public-key encryption scheme that is homomorphic over message space. These building blocks can be instantiated under a wide variety of assumptions including DDH, DCR, LWR and even LWE for post-quantum security.
    In our scheme, each ciphertext is associated with an index from an appropriate index space. We implement the DDH-based instantiation. Given an aggregated batch of 1,000 messages over a small 1024 sized index space, each server performs about 41~ms of single-thread computation, including a 100-of-300 threshold decryption.
    We also partially implement an RLWE-based post-quantum instantiation over a \(2^{128}\) sized index space for negligible collision probability among indices. A batch of 1024 messages uses approximately 0.89 MB per ciphertext and 20 seconds of single-thread decryption per server.
    ## 2026/2466
    * Title: Trustless Bitcoin Vaults
    * Authors: Lukas Aumayr, Xinshu Dong, Runchao Han, Srivatsan Sridhar, David Tse, Nikhil Vanjani
    * [Permalink](https://eprint.iacr.org/2026/2466)
    * [Download](https://eprint.iacr.org/2026/2466.pdf)
    ### Abstract
    Bitcoin (BTC) is the largest crypto asset, yet the Bitcoin blockchain offers few applications in which BTC can be used. A standard approach to make BTC useful is bridging: BTC is deposited on the Bitcoin chain and a wrapped asset is minted on a chain such as Ethereum, where it can be used in smart contract applications. Unfortunately, all Bitcoin bridges to date require trust assumptions on a centralized party or a committee running the bridge to enable withdrawals of the deposited BTC, including state-of-the-art BitVM bridges.
    In this paper, we observe that while bridges are application-agnostic, most BTC holders are interested in collateral-based applications, where BTC is deposited as collateral, and only the depositor or a set of known counterparties can withdraw the asset. For this class of applications, we propose a primitive, Trustless Bitcoin Vaults, that guarantees that the BTC depositor or the counterparties can withdraw the deposited BTC following only the logic of the application smart contract without trusting any third party. We present a protocol that achieves the security guarantees of this primitive and instantiate it for a lending application where the deposited BTC is used as collateral to borrow against a set of liquidators on the Aave v4 smart contracts on Ethereum. Our mainnet experiments show that at the current Bitcoin price and fee rate, a deposit costs about \$0.7 in fees while a withdrawal costs at most \$7.7. Our construction is built on recent advances in efficient proof verification for Bitcoin.
    ## 2026/2471
    * Title: Connecting Cryptanalytic Distinguishers through Divisibility
    * Authors: Hosein Hadipour
    * [Permalink](https://eprint.iacr.org/2026/2471)
    * [Download](https://eprint.iacr.org/2026/2471.pdf)
    ### Abstract
    Integral distinguishers can reveal more than a zero-sum property: the number of ones in an output component may be divisible by a high power of $2$, rather than merely being even. To exploit this divisibility, we relate linear, integral, differential-linear, and restricted differential sums through two-way conversions with explicit divisibility guarantees and data complexity, recovering established links as special cases. We derive exact random-permutation probabilities and rigorous bounds to quantify the distinguishing strength while accounting for dependencies between output conditions.
    To discover these properties, we develop automated MILP/SAT models that use complete-round Walsh coefficients or combine Walsh and ultrametric representations to obtain stronger bounds. These weighted models prove finite divisibility even when compatible trails exist, beyond what trail-existence tests alone can establish. For differential-linear sums, we show that combining differential and linear propagation with local DLCT zeros can give false zero-correlation claims. We address this limitation with exact mix-basis models that establish zero correlation and finite divisibility.
    To complement these symbolic methods, we provide a black-box algorithm using exact histograms and the fast Walsh-Hadamard transform to search all output masks for selected input conditions and identify zeros and finite divisibility properties.
    Our MILP/SAT models significantly improve the divisibility bounds reported by Beyne and Verbauwhede in 674 cases across the SIMON family, as well as for PRESENT, without trail enumeration and at unchanged data complexity, e.g., from $2^5$ to $2^{11}$ on 9-round SIMON32 and from $2^6$ to $2^{22}$ on 10-round SIMON48. To our knowledge, we are the first to prove higher divisibility for 8-round SPECK and for BEANIE, with new bounds for GIFT-64 and Ascon and exact counts for SKINNY-64. Our black-box searches reveal new properties on RC5, ChiLow-32, KeeLoq, and KATAN32, including output-bit combinations missed by single-bit searches, and lead us to introduce probabilistic divisibility.
    ## 2026/2476
    * Title: On the Hardness of Finding Permutation Automorphisms of Linear Codes
    * Authors: Michele Battagliola, Giuseppe D'Alconzo, Laura Mattiuz, Paolo Santini, Federica Zanetti
    * [Permalink](https://eprint.iacr.org/2026/2476)
    * [Download](https://eprint.iacr.org/2026/2476.pdf)
    ### Abstract
    We study the hardness of finding permutation automorphisms of linear codes. We look into three main problems: $\mathsf{AUT}$, $\mathsf{AUT}$-$\mathsf{Gen}$ and $\mathsf{AUT}$-$\mathsf{Count}$ which, respectively, ask to find a non-trivial automorphism, a generating set and the order of the automorphism group.
    We give polynomial time reductions from $\mathsf{AUT}$ to $\mathsf{ISO}$ (the problem of finding a permutation isomorphism between two linear codes), and from $\mathsf{ISO}$ to $\mathsf{AUT}$-$\mathsf{Gen}$ and $\mathsf{AUT}$-$\mathsf{Count}$. This shows that $\mathsf{AUT}$-$\mathsf{Gen}$ and $\mathsf{AUT}$-$\mathsf{Count}$ are unlikely to be easy in the worst case, since all known solvers for $\mathsf{ISO}$ take exponential time if the hull dimension (the subspace given by the intersection between the code and its dual) is large enough.
    Furthermore, we give a reduction from $\mathsf{AUT}$-$\mathsf{Gen}$ to the problem of finding generators for the automorphism group of a graph, which we refer to as $\mathsf{GraphAUT}$-$\mathsf{Gen}$.
    Up to some polynomial factors, the reduction runs in time $O(n^{h})$, with $n$ being the code length and $h$ the hull dimension: for $h = O\big(\log(n)\big)$, this implies that $\mathsf{AUT}$-$\mathsf{Gen}$ can be solved in worst case quasi-polynomial time.
    We also give a simpler version of the reduction, running in time which is exponential in the worst case (arguably, only for rather contrived codes), even for small $h$. However, heuristically, the algorithm is on average extremely efficient for small $h$. We use it as a concrete solver and show that a proof-of-concept implementation is significantly faster than the built-in implementations of Leon's and Feulner's algorithms provided by $\texttt{Magma}$ and $\texttt{Sagemath}$.
    ## 2026/2477
    * Title: Secret Sharing from Non-Extractable Randomness
    * Authors: Divesh Aggarwal
    * [Permalink](https://eprint.iacr.org/2026/2477)
    * [Download](https://eprint.iacr.org/2026/2477.pdf)
    ### Abstract
    Bosley and Dodis (TCC 2007) proved that a class of imperfect randomness sources that suffices for information-theoretic encryption of messages longer than the logarithm of the key length must admit deterministic extraction of nearly uniform bits, and asked whether the same is true of two-out-of-two secret sharing. Aggarwal, Chung, Obremski, and Ribeiro (TCC 2022) gave a positive answer for schemes that are in addition leakage-resilient or non-malleable; the original question remained open.
    We answer it in the negative. For every $b\ge2$ we construct a class of flat sources on $\{0,1\}^{b+2}$, each of min-entropy at least $b$, together with a perfectly correct and perfectly private two-out-of-two scheme that shares a $b$-bit secret into two $(b+1)$-bit shares using any source in the class, and we show that every deterministic map from $\{0,1\}^{b+2}$ to $\{0,1\}$ is at statistical distance at least $1/6$ from uniform on some source in the class. This implies that sharing a long enough secret does not require extractable randomness. The proof is a short parity argument. The idea of the construction extends to other thresholds: for two-out-of-$n$ and $r$-out-of-$r$ sharing we give perfect schemes with $(b+1)$-bit shares, private for classes of flat sources from which no single bit can be extracted with error below $1/(4n-2)$ and $1/(2(2^r-1))$, respectively.
    ## 2026/2478
    * Title: Hardware-Level Mitigation of Micro-Architectural Leakages in Embedded Processors
    * Authors: Niels Wieser, Nicolai M|+ller, Amir Moradi
    * [Permalink](https://eprint.iacr.org/2026/2478)
    * [Download](https://eprint.iacr.org/2026/2478.pdf)
    ### Abstract
    Cryptographic software, with its inherent flexibility and adaptability, has become essential for meeting todayrCOs rapidly evolving security requirements, despite offering lower performance than dedicated hardware accelerators. However, Side-Channel Analysis (SCA) complicates its secure execution on physical hardware, making robust protection a central challenge. While the masking countermeasure offers provable security guarantees in theory, its effectiveness is often undermined by the processorrCOs micro-architecture. In response, formal adversary models have been adapted to account for micro-architectural leakage under generic (but over-conservative) assumptions on the hardware. Consequently, achieving security under such a generic model requires compilers to produce less performant software. To bridge this gap, secure hardware-software co-design assumes a precisely specified hardware leakage behavior, enabling the specification of constraints for secure compilation. While this approach reduces the overhead required to counteract these effects, it does not entirely remove it.
    This work follows a more fundamental paradigm: instead of managing leakage in software, we aim at eliminating it at its source. Conceptually, we propose architectural changes to general-purpose processors at the Register-Transfer Level (RTL) that remove the root causes of micro-architectural leakages. The application of these changes enables the secure execution of masked software without introducing micro-architectural leakage under the Robust but Relaxed (RR) d-probing model, thereby removing the need for complex, security-aware compilers and hardware-specific workarounds in the software. While our countermeasures can be applied to many micro-architectures, we formally prove the security of each countermeasure individually and integrate them into the Ibex processor, whose security we evaluate as a whole through tool-assisted leakage assessment of the full netlist and physical experiments on a Field Programmable Gate Array (FPGA).
    ## 2026/2479
    * Title: Committing Security of Forkcipher-based AEAD
    * Authors: Samir Kundu, Sougata Mandal, Hrithik Nandi
    * [Permalink](https://eprint.iacr.org/2026/2479)
    * [Download](https://eprint.iacr.org/2026/2479.pdf)
    ### Abstract
    Authenticated Encryption with Associated Data (AEAD) provides confidentiality and integrity, but traditional security notions do not prevent ciphertexts from decrypting correctly under multiple keys. This motivates committing security, which requires ciphertexts to bind to their encryption inputs uniquely. Recent analyses revealed commitment failures in several forkcipher-based AEAD schemes, leaving open the question of whether these failures are inherent to forkciphers or design specific. We provide a comprehensive committing security analysis of existing forkcipher-based AEAD constructions, filling this gap by establishing both negative and positive results. Our analysis shows that while some designs inherently fail to achieve strong commitment, others achieve meaningful commitment guarantees, demonstrating that forkciphers can serve as a foundation for committing-secure AEAD schemes. We derive tight bounds for commitment notions for existing constructions. As a key technical contribution, we formalize a forkcipher-based hash construction and prove its collision resistance, which serves as a foundation for our security analysis.
    ## 2026/2480
    * Title: Post-Quantum Certificate-Based PSK Provisioning for WireGuard via Mutual TLS, DTLS, and QUIC: Design and Performance Study
    * Authors: Che Hang Ng, Emil K|+nstner, Bastian K|+ppers, Theodor Schnitzler, Misha Glazunov
    * [Permalink](https://eprint.iacr.org/2026/2480)
    * [Download](https://eprint.iacr.org/2026/2480.pdf)
    ### Abstract
    We present an architecture that provides WireGuardrCOs resistance against future quantum adversaries. By preserving the core protocol, our approach minimizes deployment effort and adds certificate-based identities to WireGuard peers. To achieve Post-Quantum (PQ) resistance, we establish an external mutually authenticated control channel built on the TLS 1.3 handshake and layered on top of TCP, UDP, or QUIC. Its key establishment includes Module-Lattice-Based Key-Encapsulation Mechanism (ML-KEM). An auxiliary shared secret is derived from the exported keying material of the resulting session and injected into WireGuardrCOs native Pre-Shared Key (PSK) interface; this derivation is identical for all three transports. To support scalable deployment, the control channel is authenticated with X.509 certificates issued by a Public Key Infrastructure (PKI), using the Module-Lattice-Based Digital Signature Algorithm (ML-DSA) for PQ certificate signing. We develop a Tamarin model of the composition layer and symbolically analyze the secrecy, binding, and provisioning-order properties of the interface between TLS 1.3 handshake and WireGuard, identifying the critical conditions necessary for secure deployment. Finally, we evaluate the design to quantify handshake latency and CPU time for classical, pure PQ and hybrid key establishment, classical and ML-DSA certificates, and the three transports, comparing it against an existing PQ WireGuard baseline achieving state-of-the-art results.
    ## 2026/2481
    * Title: Polygero: Proximity Testing From Polynomial Challenges
    * Authors: Matteo Frigo, abhi shelat
    * [Permalink](https://eprint.iacr.org/2026/2481)
    * [Download](https://eprint.iacr.org/2026/2481.pdf)
    ### Abstract
    We present a new proximity test for Reed--Solomon codes that admits a higher-agreement regime with soundness approaching the field's bit length.
    All prior work in this area [AHIV2017,BCIKS2020,BCHKS2025] uses the idea of *scalar* batching in which the verifier provides a scalar challenge for each codeword, and the prover must supply a codeword equivalent to the combination, and the verifier tests it at randomly opened columns.
    Our main insight is to instead use a low-degree polynomial challenge for each codeword. We prove that the low-dimensional spaces generated by polynomial challenges become maximum distance separable (MDS) after deleting a few coordinates, and this phenomenon leads to a new kind of proximity gap that we can exploit.
    This insight enables a simpler, in fact elementary counting proof for soundness of the proximity tests. We do not need the Polishchuk--Spielman lemma or Guruswami--Sudan decoding.
    The same technique proves soundness of Polygero, a Ligero-inspired IOP~[AHIV17], beyond the unique-decoding regime. Through recursion, Polygero produces proofs with a number of field elements logarithmic in the witness size, independently of the number of linear constraints. It does not require roots of unity in the finite field or out-of-domain sampling.
    The soundness analysis, including the extractor and the recursive composition, and every reported parameter schedule are machine-checked in Lean.
    ## 2026/2482
    * Title: Edabits Generation with Quasi-Linear Communication Complexity
    * Authors: Alexander Bienstock, Daniel Escudero, Qijia Fan, Fengrun Liu, Yifan Song
    * [Permalink](https://eprint.iacr.org/2026/2482)
    * [Download](https://eprint.iacr.org/2026/2482.pdf)
    ### Abstract
    The work of (Escudero et al., CRYPTO 2020) introduces the so-called edabits, which are defined as a secret sharing of an integer over an arithmetic domain, together with its bit decomposition secret shared over a binary domain. In the same work, it is shown how edabits can be used to securely evaluate advanced primitives such as comparison, bit decomposition, and truncation, which are essential building blocks in more complex applications such as privacy-preserving machine learning and beyond. Edabits are general and can be defined over any secret-sharing scheme or corruption model. Such flexibility, coupled with their wide range of applications, makes edabits a powerful target correlation.
    Escudero et al.~introduced a protocol to generate edabits that works in the arithmetic black-box (ABB) model, that is, it is agnostic to the concrete secret-sharing scheme and even works both for fields $\mathbb{F}_p$ and rings $\mathbb{Z}_{2^\ell}$, as well as both for honest majority $t<n/2$ and dishonest majority $t<n$. Unfortunately, the communication complexity of their approach grows as $\Omega(n^2\ell)$ bits with $\ell$ being the bit-length of an element in the arithmetic domain. This becomes a bottleneck in larger protocols since most MPC primitives such as multiplications or openings can be done with linear communication of $O(n\ell)$ bits.
    In this work we present a novel approach for generating edabits in the ABB model that achieves \emph{quasi-linear} communication complexity of $O(n\ell\log n)$ bits, for the setting where $t<n(1-\epsilon)$ for a constant $\epsilon>0$. This includes the honest majority case $t<n/2$, but also dishonest majority with an (arbitrarily small) constant fraction of honest parties. Our result is achieved via novel applications of randomness extraction methods, as well as better edabit aggregation for the binary components. Along the way and of independent interest, we improve the communication complexity of dabit generation (dabits are bits shared in both binary and arithmetic domains) from $\Omega(n^2\ell)$ bits achieved in (Rotaru and Wood, INDOCRYPT 2019), to linear $O(n\ell)$ bits.
    ## 2026/2483
    * Title: Uniform Sharing in Multiple Stages: Towards Second-Order Security
    * Authors: Aein Rezaei Shahmirzadi, Artemii Ovchinnikov, Siemen Dhooghe
    * [Permalink](https://eprint.iacr.org/2026/2483)
    * [Download](https://eprint.iacr.org/2026/2483.pdf)
    ### Abstract
    Mitigating SiderCaChannel Analysis (SCA) of cryptographic implementations relies heavily on masking schemes; however, achieving efficient and straightforward hardware realizations remains challenging. While Threshold Implementation (TI) provides provable security against glitches in hardware, it incurs significant area overhead due to the large number of shares required to protect nonrCalinear functions. Successor schemes achieve the same security order with a minimal number of shares, but often rely on a high amount of perrCacycle randomness, especially at higher orders. Recent optimizations such as NullFresh and MultiStage attain minimal share counts without additional randomness; however, they lack a generalized methodology for higherrCaorder security. In particular, although MultiStage enables automated generation of lowrCarandomness masked designs, it is currently limited to firstrCaorder protection.
    In this work, we bridge this gap by introducing an automated masking technique for arbitrary functions that guarantees secondrCaorder security in the glitchrCaextended probing model. Building upon the MultiStage approach, our method preserves the efficiency of NullFresh by minimizing requirements for fresh masks, while overcoming structural limitations of previous schemes. We demonstrate the feasibility of the approach on the lightweight block ciphers PRINCE, Midori, and SKINNY. The resulting designs are formally verified using SILVER and PROLEAD, and experimentally evaluated on FPGA using TVLA.
    ## 2026/2484
    * Title: Unveiling the Cost: Gas-Efficient Output-Private Distributed VRFs on Ethereum
    * Authors: Ahmet Ramazan A-f-#rta+f, Arda Bu-fra |uzer
    * [Permalink](https://eprint.iacr.org/2026/2484)
    * [Download](https://eprint.iacr.org/2026/2484.pdf)
    ### Abstract
    Unbiased and publicly verifiable randomness is a fundamen-
    tal component of Web3 security, and output-private distributed verifiable random functions (DVRFs) extend this guarantee by keeping the gener-
    ated randomness hidden from chain observers until the requester chooses
    to reveal it. Two constructions currently realize output privacy under dif- ferent algebraic regimes: FlexiRand, whose on-chain verification rests on bilinear pairings, and IcyVeil, a pairing-free design whose verification re- duces to a constant number of group operations. While it is folklore that pairing-free verification should be cheaper on the Ethereum Virtual Ma-
    chine (EVM), the actual on-chain cost of output-private randomness has
    never been measured for either scheme. In this paper, we present the first
    EVM implementations of both constructions. Both verifiers are served by
    a single coordinator contract realizing the common blindrCoevaluaterCopre- verify lifecycle, so that every measured difference is attributable solely
    to the verification arithmetic. The isolated verification is 57% cheaper in execution gas for the pairing-free scheme (51,561 against 118,541 gas);
    over the full request lifecycle, whose remaining stages are shared, the ad- vantage is about 11%. This on-chain saving comes with a cost off chain:
    the pairing-free schemerCOs distributed evaluation requires roughly 2.5 to
    8.2 times more aggregate committee compute across committee configu-
    rations (n, t), a gap absorbed comfortably by EthereumrCOs block time and
    one that narrows further once the committee executes concurrently. We
    report both axes, separating one-time distributed key generation (DKG)
    cost from IcyVeilrCOs consumable preprocessing, and reconcile the on-chain
    and off-chain ratios, which point in opposite directions. All contracts, harnesses, and raw measurements are publicly available.
    ## 2026/2485
    * Title: Tulva: Practical Asynchronous Threshold FHE
    * Authors: Valerio Cini, Antonio Guimar|ues, Russell W. F. Lai, Micha+e Osadnik, Ivy K. Y. Woo
    * [Permalink](https://eprint.iacr.org/2026/2485)
    * [Download](https://eprint.iacr.org/2026/2485.pdf)
    ### Abstract
    Fully homomorphic encryption (FHE) allows arbitrary computation over encrypted data, but its secret key presents a single point of failure which limits its applications. Threshold FHE patches this gap by distributing the secret key to $K$ parties, requiring a threshold $t \leq K$ of them to cooperate for decryption. We focus on the asynchronous setting where a ciphertext can be decrypted by collecting decryption shares from any $t$ parties who do not need to coordinate or even be online simultaneously. Asynchronous schemes are sought in applications such as privacy-preserving Ethereum Virtual Machines (EVM), processing of long-lived private data with quorum-based decryption and the thresholdisation of any cryptographic primitive in general.
    We present Tulva, a practical threshold FHE scheme which equips a base FHE scheme with an asynchronous threshold decryption mechanism in a modular way. Our scheme simultaneously (1) is compatible with virtually any base FHE scheme and leaves its ciphertexts unchanged apart from an appended random tag, (2) supports a wide range of threshold profiles $(t,K)$ and ring degrees $\geq 256$ with 6--25 bits partial decryption per plaintext bit, and (3) achieves security in the presence of partial decryption queries on challenge ciphertexts based on the standard LWE assumption.
    We provide an open-source implementation, benchmark its threshold decryption performance and evaluate the end-to-end costs for typical privacy-preserving EVM use cases. For 16-out-of-512 threshold and a publicly preprocessed ciphertext, computing secret-dependent partial decryption and public share combination requires only 3.7ms and 0.5ms, respectively, on commodity hardware. Compared with the state-of-the-art synchronous scheme [Zyskind et al., CCS'25], we replace their ciphertext-independent yet interactive preparation of secret-correlated randomness with a public, ciphertext-dependent 0.5s preprocessing step, eliminate interaction in the online phase while maintaining similar decryption time on the same machine, and support 32$\times$ more total users.
    ## 2026/2486
    * Title: Heterogeneous CPUrCoNPU Implementation of the AIMer Post-Quantum Signature for Low Latency on a Mobile SoC
    * Authors: Myoungsu Shin, Jihoon Jang, Hanbeom Shin, Insung Kim, Dongjae Lee, Donggeun Kwon
    * [Permalink](https://eprint.iacr.org/2026/2486)
    * [Download](https://eprint.iacr.org/2026/2486.pdf)
    ### Abstract
    Signatures in the MPC-in-the-head paradigm rest only on a symmetric primitive, but their signing is slow, because it computes hash functions and a linear map for every simulated party of every repetition. We show that the Hexagon NPU of Snapdragon SoCs shortens one complete signing operation of AIMer, the MPC-in- the-head signature that the Korean post-quantum cryptography competition selected. Prior work speeds up such signatures on one CPU core, accelerates post-quantum arithmetic on GPUs for batches of operations, and reports only single post-quantum functions for mobile NPUs. Our implementation divides each signing operation along its dependency graph. The NPU computes the hashing and the per-party linear map of the last repetitions, which need no secret key, and the CPU keeps the secret key and the two hashes that absorb the repetitions in index order. A fast AArch64 implementation serves both as the CPU part and as the baseline, and it signs 4.5 to 6.1 times faster than the reference implementation on one core. On a Snapdragon 8 Gen 3 tablet, one core with the NPU signs 1.30 to 1.42 times faster than two cores and 1.74 to 1.97 times faster than one core for the three short-signature parameter sets. The same configuration uses 13 to 27 % less energy per signing operation than two cores. On Snapdragon 8 Elite and 8 Gen 2 phones, one core with the NPU signs 1.28 to 1.35 and 1.74 to 1.82 times faster than two cores.
    ## 2026/2487
    * Title: A Hybrid BP-SAT Attack on MILENAGE: Combining the Complementary Strengths of Algebraic and Soft-Analytical Side-Channel Attacks
    * Authors: Elena Dubrova, S||nke Jendral, Linus Backlund, Mats N|nslund
    * [Permalink](https://eprint.iacr.org/2026/2487)
    * [Download](https://eprint.iacr.org/2026/2487.pdf)
    ### Abstract
    Profiled side-channel attacks combine noisy leakage predictions with the mathematical relations imposed by the target algorithm to recover secrets from a small number of observations. Two established approaches are algebraic side-channel analysis (ASCA), which encodes leakage predictions and algorithmic relations as a Boolean satisfiability (SAT) problem, and soft-analytical side-channel analysis (SASCA), which performs probabilistic inference over a factor graph using belief propagation (BP). We evaluate both on the AES-based MILENAGE authentication algorithm deployed on USIM cards, targeting the first AES-128 invocation on $\mathit{RAND}\oplus\mathit{OPc}$ under the subscriber key $K$, where $\mathit{OPc}$ is an operator-specific secret unknown to the attacker. Neural networks predict posterior probability distributions over the AES S-box output byte values across multiple rounds and these predictions are supplied to ASCA and SASCA to recover $K$ and $\mathit{OPc}$ from a single trace. SASCA recovers both secrets in 87.7% of attacks, but converges to an incorrect $\mathit{OPc}$ in 6.1% of cases despite recovering $K$ correctly. ASCA enforces global consistency and resolves this ambiguity, but it succeeds in only 34% of attacks under a 1-hour timeout and our constraint-selection strategy. Motivated by these complementary failure modes, we combine the two into a hybrid attack in which BP refines the neural network predictions before they are supplied to the SAT solver. The hybrid approach recovers both secrets in 93.8% of single-trace attacks, resolving all cases where SASCA recovers $K$ correctly but $\mathit{OPc}$ incorrectly. It has a higher success rate and a lower average runtime than either method alone, despite performing more work per attack. Finally, we suggest a countermeasure, based on masking each AES round key with an independent, per-device secret, that reduces an attacker's advantage over guessing $K$ and $\mathit{OPc}$ to zero bits, and confirm empirically that it defeats the hybrid attack in all evaluated cases.
    ## 2026/2488
    * Title: Yoshan: Algebraic-Circuit Co-Synthesis and Search Methodology of Hardware-Efficient S-Boxes
    * Authors: Robert Hanhan, Binyamin Alony, Itamar Levi
    * [Permalink](https://eprint.iacr.org/2026/2488)
    * [Download](https://eprint.iacr.org/2026/2488.pdf)
    ### Abstract
    Choosing a hardware S-box means balancing cryptanalytic strength (differential uniformity +|, linearity L, and algebraic degree) against circuit cost (AND count and AND depth D). Under masking, non-linear gates dominate silicon area, registers, and fresh randomness, while D sets pipeline latency. As a result, automated searches have largely retreated to quadratic permutations (D = 1), whose slow degree growth forces high cipher round counts. We present Yoshan, a co-synthesis engine that optimizes an S-box permutation and its gate-level circuit together across n ree {5,6,7,8}. Inside a quality-diversity archive, Yoshan seeds search with subfield towers, Feistel/Misty/MM networks, affine wrappers, CCZ graph automorphisms, and bilinear or shear constructions. It then evolves circuits via cryptographically guided DAG rewrites and exploratory differentiable Piling-Up seeding and crossover with Hungarian LSAP projection, before compressing them with SMT sub-DAG shaving, stage-preserving CSE, exact depth-1 SAT, and four-tier inverse compilation. Every archived circuit is exported gate for gate to SystemVerilog and certified by exhaustive simulation and a Z3 miter. Across 31,337 certified netlists (30,986 distinct permutations) in 56 (n,+|,L,deg) profiles, EA invariants and an exact affine-equivalence solver against a 712-entry catalogue (power maps, 5- and 6-bit quadratic/quartic classifications, Feistel/MISTY/Bridge structures, two-point-swapped power maps, and cipher S-boxes) partition the archive into known catalogue classes (Category A, 2,681 permutations) and permutations certified EAseparated from it (Category B, 28,305 permutations; 12 benchmark classes YSHn,i). All 30 benchmark S-boxes and their explicit inverses are synthesized gate-exactly in 45nm CMOS (unmasked and pipelined d = 2 DOM) and traced from seed to final netlist. For known classes, we obtain a gate-exact depth-3 AES-class pair (42 AND, 101 XOR; inverse 42 AND, 106 XOR at D = 3) and a provably AND-optimal 5-AND, D =1 circuit for the 5-bit Q71 class (+| = 4,L = 16). When the lookup table can vary, we find a 12-AND 6-bit degree-5 S-box YSH6,5 (+| = 6,L = 24,+# = 14), a 5-AND, D =2 5-bit quartic S-box YSH5,2 in both directions, and 28- and 18-AND 8-bit degree-7 S-boxes, all compared against the best published circuits.
    ## 2026/2489
    * Title: FAEST on GPUs: Addressing Field Multiplication as a Bottleneck
    * Authors: Minseop Choi
    * [Permalink](https://eprint.iacr.org/2026/2489)
    * [Download](https://eprint.iacr.org/2026/2489.pdf)
    ### Abstract
    FAEST is a post-quantum signature scheme that combines VOLE-in-the-Head with QuickSilver to prove knowledge of a secret key. It relies on well-established symmetric primitives and offers small public keys, but signing and verification are computationally expensive. We present an NVIDIA GPU implementation of the key-generation core and the QuickSilver procedures OWFProve and OWFVerify for the standard and EM constructions in both s and f variants. Profiling shows that once AES is accelerated by hardware, field multiplication in QuickSilver becomes the largest cost throughout this parameter grid. In FAEST-128f, field multiplication takes about 82% of signing time. To address this bottleneck in our GPU implementation of FAEST, we use PTX clmad for native carry-less arithmetic and Karatsuba to reduce the number of limb products. The clmad build improves throughput across all twelve OWFProve and OWFVerify paths, and its advantage grows with the field width. On an RTX A5000, PTX clmad raises standard OWFProve throughput to 1.99x, 2.45x, and 2.82x that of the software-multiplication build at 128, 192, and 256 bits, respectively. Together, PTX clmad and Karatsuba deliver 26.6x the throughput of the software-multiplication build in the field-multiplication-heavy kernel of standard 256-bit OWFProve. When all OWFProve stages are included, the combined build reaches 2.9x and 3.1x the software throughput for standard and EM at 256 bits, respectively. These results establish native carry-less arithmetic as a key design choice for GPU implementations of FAEST, with Karatsuba providing an additional improvement for 256-bit proving.
    ## 2026/2490
    * Title: Reaction Attack on CKKS Deployments with Asymptotically Optimal Query Complexity
    * Authors: Song Bian, Hyeongmin Choe, Jiseung Kim, Changmin Lee
    * [Permalink](https://eprint.iacr.org/2026/2490)
    * [Download](https://eprint.iacr.org/2026/2490.pdf)
    ### Abstract
    We study a protocol-level reaction leakage in CKKS deployments where public coefficient-to-slot (C2S) evaluation keys are combined with a client's 1-bit validity response. Under this deployment surface, a malicious evaluator can recover a ternary secret key using asymptotically optimal $O(\mathcal{H})$ reaction queries, where $\mathcal{H}$ is the entropy of the secret key.
    The attack does not break RLWE or CKKS IND-CPA security. Instead, it exploits the interaction between client-side validity reactions and public homomorphic linear transformations. A shift of a public encryption key yields a ciphertext whose plaintext is a function of the secret key; the public ${\sf C2S}$ layer then repacks this information to construct a ciphertext whose validity depends strictly on whether a targeted secret coefficient matches a guessed value. Furthermore, each submitted query is independently randomized with a fresh encryption of zero, so that each resulting malicious ciphertext appears entirely distinct, thereby allowing the attack to simply evade trivial detection mechanisms on the client side.
    We implemented the full end-to-end attack in Lattigo v6.2.0 and recovered the full secret key across four parameter sets drawn from standard CKKS presets.
    For uniform ternary secrets, the attack uses
    $O(N)$ queries and is within a factor $2/\log_2 3 < 2$ of the oracle-only entropy lower bound. For sparse ternary secrets, a tailored variant further reduces the number of queries in practice. Our results show that observable validity reactions form a practical key-recovery channel in CKKS deployments exposing this surface, even when the underlying cryptographic assumptions remain intact.
    ## 2026/2491
    * Title: Shift-Invariant Permutations with Polynomial Composition: Construction and Algebraic Structure
    * Authors: Cheng Lyu, Dabin Zheng, Mu Yuan, Lei Hu
    * [Permalink](https://eprint.iacr.org/2026/2491)
    * [Download](https://eprint.iacr.org/2026/2491.pdf)
    ### Abstract
    Shift-invariant permutations of \(\mathbb F_2^n\) are particularly attractive in symmetric cryptography because of their regularity and implementation efficiency. Constructing such permutations with an explicit algebraic structure remains a challenging problem. In this paper, we study a family of shift-invariant transformations of \(\mathbb F_2^n\) constructed from a recursively defined sequence of mappings \(\{\gamma_j\}_{j\ge 0}\) associated with landscapes. First, we prove that, under an explicit dimension condition relating \(n\) to the support of the landscape, the sequence \(\{\gamma_j\}_{j\ge 0}\) has the polynomial composition property if and only if the corresponding landscape is quasi-conserved on \(\mathbb F_2^n\) with a nonzero special index. Then, we determine the eventual zero or periodic behavior of \(\{\gamma_j\}_{j\ge0}\), including the exact index at which the sequence either first vanishes or becomes periodic, together with the least eventual period, and establish linear independence until the first linear relation occurs. When the polynomial composition property holds, we establish an explicit isomorphism between the group of permutation elements in the monoid generated by these mappings and the unit group of a quotient ring \(\mathbb F_2[z]/\langle p(z)\rangle\), where \(p(z)\) is a monomial or a binomial determined by the landscape. This framework reduces the tasks of testing bijectivity, computing iterates, and determining compositional inverses and orders of permutation elements to polynomial computations. Finally, we apply the results to mappings represented by binomials and trinomials in the quotient ring, obtaining explicit criteria and formulas, and tabulate more than one hundred representative constructions of shift-invariant permutations, recovering and unifying several previously studied families.
    ## 2026/2492
    * Title: Exploring Fault Injection Attacks on HQC and BIKE Beyond Fujisaki-Okamoto Verification
    * Authors: Thales B. Paiva, Lucas C. Cardoso, Keerthi Kamalakshan, Hariprasad Valsaraj Kelassery, Marcos A. Simplicio Jr., Shivam Bhasin
    * [Permalink](https://eprint.iacr.org/2026/2492)
    * [Download](https://eprint.iacr.org/2026/2492.pdf)
    ### Abstract
    Fault injection attacks have been extensively studied in the context of post-quantum cryptography, yet existing analyses on code-based KEMs largely focus on faults targeting the Fujisaki-Okamoto transform. This work presents new fault injection attacks against BIKE and HQC that operate beyond this commonly protected component and target less obvious instructions within the decapsulation process. The proposed attacks achieve full key recovery using only valid ciphertexts under NIST Level 1 parameters, requiring 17392 and approximately 3 million decapsulation queries for HQC and BIKE, respectively. In addition, we introduce a general approach to identify effective fault locations by analyzing decoder behavior under perturbed conditions. The attacks are experimentally validated on an STM32H7 microcontroller using laser fault injection, demonstrating high repeatability. These results reveal a broader attack surface and provide a foundation for more efficient fault attack analyses in future work.
    ## 2026/2493
    * Title: Robust ECDSA Threshold Signing at Scale
    * Authors: Carsten Baum, Anders Dalskov
    * [Permalink](https://eprint.iacr.org/2026/2493)
    * [Download](https://eprint.iacr.org/2026/2493.pdf)
    ### Abstract
    This work presents an efficient, scalable, and robust threshold ECDSA signing protocol for the $t\leq (n-1)/3$ scenario, making it suitable for e.g., bridging consensus from one Blockchain to another. Our construction allows to batch-compute pre-processing material for efficient online signing. While our protocol is based on established ideas for (Verifiable) Secret Sharing, we optimize it to scale efficiently both in terms of computation and communication with a large number of signers. We therefore combine efficient batching techniques for sharing (Fitzi & Hirt, PODC 2006), randomness extraction (Beerliova-Trubiniova & Hirt, TCC 2008) and share opening (Damg|Nrd & Nielsen, CRYPTO 2007) with recent advances in efficient Zero-Knowledge proofs (Attema & Cramer, CRYPTO 2020). We implement and evaluate the protocol experimentally and show that it is practical for large number of parties $n$.
    ## 2026/2494
    * Title: Speeding up Sumcheck using Algebraic Geometry
    * Authors: Rahul Dalal, Benedikt Bunz, Tamir Hemo, Ron D. Rothblum
    * [Permalink](https://eprint.iacr.org/2026/2494)
    * [Download](https://eprint.iacr.org/2026/2494.pdf)
    ### Abstract
    The sumcheck protocol, a ubiquitous component of modern proof-systems, enables proving the sum of evaluations of a low-degree multivariate polynomial. In theory, sumcheck has been generalized from polynomials to (tensors of) any multiplication code, a code whose pointwise products of codewords lie in a related product code. All practical systems nonetheless specifically use polynomials. For proof-systems over binary fields that target Boolean circuits, this choice has a real cost: the product of two binary messages under Reed--Solomon is no longer binary. As a result, the prover's work in the first, and most expensive, round of sumcheck (the so-called univariate skip) grows by a logarithmic factor.
    We present a new concrete multiplication code based on algebraic geometry that is binary-preserving: the product of two encoded binary messages is again a binary message. Specifically, we construct an explicit multiplication code over $\mathbb{F}_{2^{128}}$ that carries $64$-bit messages to binary product messages of length $222$, and whose product code has relative distance greater than $1-2^{-119}$. The part of the product message that the prover actually sends in sumcheck is more than $3 \times$ smaller than with Reed--Solomon, as used in practice. The code comes from a genus-$95$ curve over $\mathbb{F}_2$ with $64$ rational points, built as a $(\mathbb{Z}/2)^3$ Artin--Schreier cover of a genus-$4$ curve.
    We implemented the resulting protocol, which we call the AG skip, inside the Flock proof-system. For $2^{32}$ constraints, it speeds up the skip round by $2.36\times$ and the whole zerocheck, which was the prover's most expensive component, by $1.65\times$.
    ## 2026/2495
    * Title: Issuer-Independent Decentralized Exchange for E-Cash
    * Authors: Roozbeh Sarenche, Omid Mirzamohammadi
    * [Permalink](https://eprint.iacr.org/2026/2495)
    * [Download](https://eprint.iacr.org/2026/2495.pdf)
    ### Abstract
    Despite decades of cryptographic advances, electronic cash (e-cash) remains largely confined to payments and lacks the broader decentralized financial applications built around cryptocurrencies. As a step toward broadening its application layer, we present an issuer-independent e-cash exchange in which a liquidity provider holds inventories of two independently issued e-cash currencies and users trade between them without requiring either issuer to participate in individual swaps.
    Our design combines a blockchain settlement layer, which automates the exchange and makes its execution publicly verifiable, with an exchange-compatible e-cash protocol. Classical e-cash must be adapted to this setting in two respects: payments must become publicly verifiable by the exchange, and the additional privacy risks created by public execution must be addressed. We formalize these new privacy requirements and construct a compact e-cash realization with publicly verifiable payments and aggregate anonymous reissue. We prove the security and privacy properties of the resulting exchange protocol under the stated cryptographic and issuer-functionality assumptions.
    ## 2026/2496
    * Title: Structural Cryptanalysis of the Eevee AEAD Family
    * Authors: Shuping Mao, Peng Wang, Jiadong Han, Tingting Guo, Yan Jia, Ying Chen
    * [Permalink](https://eprint.iacr.org/2026/2496)
    * [Download](https://eprint.iacr.org/2026/2496.pdf)
    ### Abstract
    Eevee is a family of three AEAD modes, Umbreon, Jolteon, and Espeon, proposed at CCS 2023 for IoT-to-cloud secure computation. We analyze structural flaws in the algorithms of the supplied full-version specification and the proof steps underlying their online authenticated-encryption claims. An AD-free, two-encryption prefix distinguisher has advantage $1-2^{-n}$ in the ideal-forkcipher model, contradicting the specified online ideal object. Independently, the separable associated-data transform yields a four-encryption nonce-misuse distinguisher with advantage $1-2^{-n}$, a deterministic AD-only forgery, and nonempty-message forgeries obtained from cross-domain state differences. These attacks contradict the advertised nonce-misuse bounds of Umbreon and Espeon. With nonce-respecting encryption queries, one two-block Jolteon encryption permits a fresh one-block forgery with the same tag, while Espeon's short-message path permits arbitrary AD substitution. We trace these counterexamples to failures of online-prefix consistency, conditional transcript distributions, domain separation, and checksum freshness in the original proof. The authenticity attacks follow from deterministic identities, and the privacy counterexamples persist with an ideal forkcipher. We derive corresponding requirements for AD processing and message finalization, and briefly summarize supporting checks of the published C routines. The central failures concern the mode design and cannot be resolved solely by correcting implementation encodings.
    ## 2026/2497
    * Title: SecAgg++: A Post-Quantum Privacy Preserving Federated Learning Protocol
    * Authors: Alessandro Perez, Giulia Cavicchioni, Silvio Cretti, Riccardo Longo, Alessandro Tomasi, Silvio Ranise
    * [Permalink](https://eprint.iacr.org/2026/2497)
    * [Download](https://eprint.iacr.org/2026/2497.pdf)
    ### Abstract
    Secure aggregation is a fundamental building block for privacy-preserving federated learning, yet most existing masking-based secure aggregation protocols do not provide post-quantum security. In this work, we present SecAgg++, a masking-based post-quantum secure aggregation protocol for the single-server setting. SecAgg++ integrates post-quantum cryptographic primitives while preserving the communication and computational efficiency of classical frameworks such as SecAgg and SecAgg+, and supports client dropout handling through an efficient recovery procedure.
    ## 2026/2498
    * Title: Noise-Tolerant Quantum One-Time Programs Using Stateless Trusted Hardware, Revisited
    * Authors: Prabhanjan Ananth, Divyanshu Bhardwaj
    * [Permalink](https://eprint.iacr.org/2026/2498)
    * [Download](https://eprint.iacr.org/2026/2498.pdf)
    ### Abstract
    A quantum one-time program scheme is a functionality-preserving compiler that transforms a program into a quantum state that can be used to obtain only one output of the program. Our goal is to design quantum one-time programs that can be realized on existing quantum technologies. Our contributions are two-fold:
    1. We design a BB84 state-based quantum one-time program scheme in the stateless trusted hardware model that is resilient to single-qubit corruption errors and detectable erasure errors. To illustrate, under independent noise with a 90% detectable erasure rate and a 3% Pauli Y-error rate on surviving qubits, a signature token of 39,801 BB84 qubits achieves forging probability at most $\small 2^{-128}$ against at most $\small 2^{32}$ classical verification queries, with honest failure probability below $\small 10^{-6}$. Prior to our work, [Behera, Sattath, and Shinar TQC'22] studied a BB84 state-based quantum one-time program scheme resilient to independent single-qubit corruption errors; our construction treats detectable erasures separately.
    2. We give two extensions to our scheme. First, we study the setting wherein the same trusted hardware can be reused across different independently generated quantum one-time programs. Second, we study the setting wherein multiple trusted hardware devices are used and the security holds as long as at least one of them is not compromised.
    ## 2026/2499
    * Title: GhostFaceMPC: Privacy-Preserving Face Recognition with Multi-Party Computation
    * Authors: Davide Carnemolla, Dario Catalano, Mario Di Raimondo
    * [Permalink](https://eprint.iacr.org/2026/2499)
    * [Download](https://eprint.iacr.org/2026/2499.pdf)
    ### Abstract
    Facial recognition has become central to modern authentication systems, security frameworks, and personalized services. However, its widespread adoption is hindered by severe privacy risks, particularly surrounding unauthorized access to sensitive biometric data. To address these challenges, this paper presents GhostFaceMPC, the first end-to-end, privacy-preserving face recognition system to evaluate a deep convolutional neural network extractor and matching under secure multi-party computation. GhostFaceMPC enables secure processing of facial data across all stages of a face recognition process, from feature extraction and storage to matching, without exposing raw images or biometric embeddings at any stage.
    We introduce a multi-party computation-friendly quantization of the GhostFaceNet model and circuit optimizations that make face recognition under multi-party computation practical. The code is available at https://github.com/crypto-unict/GhostFaceMPC.
    ## 2026/2500
    * Title: Threshold Post-Quantum E-Voting from Lattice Commitments
    * Authors: Jalal Alizadeh
    * [Permalink](https://eprint.iacr.org/2026/2500)
    * [Download](https://eprint.iacr.org/2026/2500.pdf)
    ### Abstract
    Lattice-based homomorphic e-voting protocols built on commitments, such as EVOLVE, keep ballots private against all but one authority and the tally verifiable even if all authorities collude, but need every authority for tallying. We present T-EVOLVE, in which votes are Shamir-shared over the commitment message space: any t of n authorities complete the tally, privacy holds against t-1 colluding authorities, and verifiability against all of them. The voter proves that her committed shares form a Reed-Solomon codeword whose value at zero is a valid vote; the parity checks cost no communication, and tallying interpolates public column sums without norm growth. Complaints of authorities, including those about ciphertexts that do not decrypt, are publicly verifiable given an encryption scheme with publicly verifiable opening; we define its interface and show that it can be instantiated under LWE. We prove privacy, verifiability, individual verifiability and robustness in the classical random oracle model; the verifiability reduction for the efficient instantiation is not tight. In a C implementation, a voter's yes/no ballot for four authorities takes 109 KB without encryption overhead and signatures, and an authority aggregates 10^4 ballots in about three minutes on one core.
    ## 2026/2501
    * Title: Aerie: Efficient Aggregation of Falcon Signatures
    * Authors: Alberto Centelles, Quang Dao, Mohammadtaghi Badakhshan, Justin Thaler
    * [Permalink](https://eprint.iacr.org/2026/2501)
    * [Download](https://eprint.iacr.org/2026/2501.pdf)
    ### Abstract
    The post-quantum signatures selected by NIST are ten to over a hundred times larger than the elliptic-curve signatures they replace. Moreover, unlike the BLS signatures that blockchains use to aggregate validator votes, they do not aggregate natively. Both problems can be addressed with a SNARK: a short proof that a batch of signatures is valid, replacing the signatures themselves.
    The prevailing approach, central to Ethereum's roadmap, pairs hash-based signatures with hash-based SNARKs. This is slow because the prover must prove many hash evaluations per signature. We instead aggregate lattice-based signatures with a lattice-based SNARK.
    We present Aerie, a proof system for aggregating Falcon-512 and Falcon-1024 signatures. By retaining each signature's short random salt in the aggregate, Aerie lets the verifier compute the hashes directly. The proof then covers only algebraic and norm checks. Aerie combines protocols tailored to these checks with the Akita polynomial commitment scheme. Unlike prior Falcon aggregation schemes, it also proves that the signatures satisfy Falcon's byte-format requirements.
    On an Apple M4 Max laptop without GPU acceleration, Aerie aggregates 32,768 Falcon-512 signatures, roughly the number of validator votes in one Ethereum slot, in 0.65 seconds. A single proof covers the whole batch, with no recursion. The aggregate is 42.1 bytes per signature including the salts, or about 66 KiB in total if the signatures share one salt. It verifies in 54 milliseconds on one core, 10|u faster than checking the signatures individually. On one core, proving takes only about 8|u as long as individual verification. We prove knowledge soundness of Aerie in the classical random-oracle model and derive aggregate unforgeability from Falcon's security.
    ## 2026/2502
    * Title: Shorter Hash-Based Signatures via Guarded Sharing in a DAG Model
    * Authors: Chongxu Ren, Hongbo Yu
    * [Permalink](https://eprint.iacr.org/2026/2502)
    * [Download](https://eprint.iacr.org/2026/2502.pdf)
    ### Abstract
    Stateless hash-based signatures are among the most important post-quantum signature schemes. Although they have been standardized by NIST, they still have large signatures. Within these constructions, the few-time signature component is receiving increasing attention. Recent work has introduced new techniques, including rejection sampling, forced pruning, bucket thinning, and hash chains.
    In this work, we continue to improve few-time signatures with a new technique, guarded sharing. Our construction moves beyond the previous tree-based model to a DAG-based signature. By combining guarded sharing with bucket thinning, hash chains, and rejection sampling, we obtain a new signature scheme called BGS-CC.
    Our construction further improves on the state-of-the-art few-time signature BPORS-C+BFP. Most notably, for 128-bit security and a small use quota of $Q=2^{24}$, it yields complete signatures of 2,228 bytes. To our knowledge, this is the first SPHINCS-based stateless signature to be shorter than the 2,420-byte signatures of the standardized module-lattice scheme ML-DSA-44.
    ## 2026/2503
    * Title: SwiftAuth: Conditional Privacy-Preserving UAV Authentication with Multi-Source Credential Aggregation and Non-Interactive Authorization
    * Authors: Mingwei Zeng, Qingyang Zhang, Jie Cui, Hong Zhong, Fengqun Wang
    * [Permalink](https://eprint.iacr.org/2026/2503)
    * [Download](https://eprint.iacr.org/2026/2503.pdf)
    ### Abstract
    To address the challenges of interactive credential issuance and conditional privacy-preserving authentication for dynamic terminals accessing multiple third-party services, we propose an traceable and aggregatable tagged witness signature (TA-TWS). Building upon this scheme, we design an efficient and privacy-preserving anonymous authentication framework, termed SwiftAuth.
    SwiftAuth decouples the issuerrCOs authorization phase from the userrCOs credential acquisition process in traditional anonymous authentication systems by introducing an asynchronous credential distribution mechanism. This allows issuers to generate authorization components even when users are offline, while ensuring that only the designated user can derive the complete access credential.
    Furthermore, during the authentication phase, SwiftAuth reduces communication and verification overhead in concurrent multi-service access by compressing multiple credentials into a constant-size representation, and supports verifier-side batch verification across users. In addition, it provides conditional privacy by integrating a regulatory trapdoor, ensuring default anonymity for legitimate users while enabling authorities to trace malicious actors upon protocol violations.
    Finally, we formally prove that the proposed TA-TWS achieves unforgeability and witness hiding. Extensive experiments were conducted on multiple resource-constrained devices, and Aliyun servers, using the MIRACL Core cryptographic library, demonstrate the practicality and efficiency of our approach.
    ## 2026/2504
    * Title: Byzantine Broadcast in $\widetilde{O}(n^2)$ Communication
    * Authors: Yuval Efron, Jovan Komatovic, Ling ren
    * [Permalink](https://eprint.iacr.org/2026/2504)
    * [Download](https://eprint.iacr.org/2026/2504.pdf)
    ### Abstract
    We present a deterministic $n$-party Byzantine broadcast protocol secure against $t<n$ faults, with communication complexity $O(n^2\log^4(n)\lambda)$ and $O(t)$ rounds (where $\lambda$ is a security parameter), improving upon the seminal Dolev--Strong protocol from 1983.
    ## 2026/2505
    * Title: AVX-512 Acceleration of SQIsign 3.0 Verification
    * Authors: Yunqi Wen, Xuzhe Liu, Zhi Hu, Saiyu Wang, Chang-An Zhao
    * [Permalink](https://eprint.iacr.org/2026/2505)
    * [Download](https://eprint.iacr.org/2026/2505.pdf)
    ### Abstract
    SQIsign is a compact isogeny-based signature scheme.
    We present a low-latency AVX-512 implementation of complete SQIsign 3.0 verification at security levels I, III, and V. Our implementation provides vectorized curve-side verification, including the Superglue transition, and introduces dynamic-programming strategies for the degree-$2^\ell$ and theta-model $(2,2)$-isogeny chains. The strategies account for batched point evaluation and the preparation of SIMD data. On an Intel Core i7-11800H running native Ubuntu 24.04, the complete verifiers achieve $2.14\times$, $2.08\times$, and $2.34\times$ speedups, respectively, over the SQIsign 3.0 Broadwell reference verifiers (the optimized 64-bit assembly implementation).
    ## 2026/2506
    * Title: Efficient Two-Dimensional Representation Evaluation via Dual Isogenies with Applications to Isogeny-Based Cryptography
    * Authors: Jianming Lin, Saiyu Wang, Chang-An Zhao, Yuhao Zheng
    * [Permalink](https://eprint.iacr.org/2026/2506)
    * [Download](https://eprint.iacr.org/2026/2506.pdf)
    ### Abstract
    The evaluation of two-dimensional isogeny representations is a fundamental operation in many isogeny-based cryptographic schemes, notably the public-key encryption schemes POK\'{E} (Eurocrypt 2025) and PIKE (PKC 2026), as well as the digital signature schemes SQIsign2D-West (Asiacrypt 2024) and SQIsign2DPush (Eurocrypt 2026). However, existing two-dimensional evaluation algorithms rely on time-consuming discrete logarithm computations and torsion-basis generation, creating a severe performance bottleneck for the entire protocol.
    In this paper, we propose a novel algorithm for evaluating two-dimensional representations by leveraging the properties of dual isogenies, thereby eliminating the need for costly discrete logarithms. We apply this methodology to significantly accelerate some isogeny-based protocols, including POK\'{E}, SQIsign2D, and their variants.
    We provide optimized C implementations for the speed-optimized variants of POK\'{E} and SQIsign2D using our proposed method. Experimental benchmarks demonstrate that the fast variants of POK\'{E} combined with our new techniques achieve computational speedups of up to $3.47\times$ in terms of CPU clock cycles compared to POK\'{E} at the NIST-I security level.
    Additionally, our explicit analysis and implementation results confirm that the signing phase of SQIsign2DPush (resp. the NIST post-quantum cryptography standardization candidate SQIsign-v3.0), when using our method, achieves a performance improvement of up to $11.24\%$ (resp. $5.02$\%) across the three NIST security levels.
    ## 2026/2507
    * Title: safeRNSgcd: Accelerating Falcon key generation with RNS in SafeGCD
    * Authors: Cesare Huang, Bo-Yin Yang
    * [Permalink](https://eprint.iacr.org/2026/2507)
    * [Download](https://eprint.iacr.org/2026/2507.pdf)
    ### Abstract
    The deepest level of Falcon's NTRU solver needs only one B|-zout
    coefficient from two large integer resultants already represented in a
    residue number system (RNS). We give $\mathtt{safeRNSgcd}$, which computes
    this coefficient while keeping the large states in RNS. Its central
    insight is that centered explicit CRT can recover the exact low bits
    needed by SafeGCD batches using single-word fixed-point arithmetic.
    Integrated into $\mathtt{ntrugen}$, our
    C implementation reduces inversion and private-key basis-generation
    costs on a Raspberry Pi 5 and two x86-64 processors, compared with
    original $\mathtt{ntrugen}$ and a variant omitting the unused coefficient.
    ## 2026/2508
    * Title: Power Analysis on SQIsign via Ideal Reconstruction from Quaternion Leakages
    * Authors: Won Kim, Jaeho Jeon, JeongHwan Lee, Suseong Lee, Young-Sik Kim, Changmin Lee
    * [Permalink](https://eprint.iacr.org/2026/2508)
    * [Download](https://eprint.iacr.org/2026/2508.pdf)
    ### Abstract
    SQIsign is an isogeny-based signature scheme, which is one of the Round-3 candidates for NIST's additional post-quantum digital signature standardization.
    NIST considers resistance to side-channel attacks as one important factor in evaluating digital signature schemes.
    However, side-channel analysis of SQIsign remains very limited.
    To the best of our knowledge, all existing studies target the Round-1 version, so their applicability to the substantially revised Round-3 SQIsign has not been established.
    Moreover, existing studies either provide experimental validation only for toy parameters or assume exploitable leakage without demonstrating its extraction in practice, leaving their applicability to realistic implementations unclear.
    In this work, we identify five side-channel vulnerabilities in the signing procedure of Round-3 SQIsign and provide polynomial-time algebraic algorithms that recover the secret key from the corresponding leaked intermediate values.
    Additionally, we further provide algorithms that enable the reconstruction of the complete secret key even when the side-channel leakage reveals only partial bits of an algebraic value, for each vulnerability.
    Finally, we further perform power analysis attack on the SQIsign source code, extracting the necessary leakage or its partial information for each vulnerability.
    ## 2026/2509
    * Title: Sparse Secrets, Dense Problems: Efficiently Masking HQC in Hardware
    * Authors: Fabian Buschkowski, Niklas H||her, Tim G|+neysu
    * [Permalink](https://eprint.iacr.org/2026/2509)
    * [Download](https://eprint.iacr.org/2026/2509.pdf)
    ### Abstract
    HQC has recently been selected by NIST as a code-based alternative to ML-KEM and is currently undergoing standardization. While multiple timing and power side-channel attacks against HQC have been presented, application of masking has so far only been studied for software implementations.
    As part of this work, we close this gap by first proposing a novel masking technique for the sparse-dense vector multiplication, one of the core components in all HQC operations. We manage to securely exploit the sparsity of the secret operand using a mixed Boolean and arithmetic masking technique and prove its first-order security in the transition- and glitch-robust probing model as well as its PINI-composability. With the same memory width, our configurable and highly parallelizable masked design takes only 3% more clock cycles than a previous unprotected HQC multiplier. Furthermore, our technique requires only 81 bits of randomness per cycle, irrespective of its parallelism. However, like previous Rotate-and-Add constructions, it is vulnerable to profiled horizontal side-channel attacks, which recover all support indices within -#8 positions from 200 traces of our FPGA implementation despite TVLA showing no signs of leakage after 10 million traces. To prevent such attacks, we integrate efficient hiding countermeasures natively into the architecture of the multiplier, resulting in only 1.7% additional latency and moderate area overhead.
    Together with efficiently masked fixed-weight samplers and a masked decoder, we present the, to our knowledge, first fully masked hardware implementation of HQC, supporting first-order masked key generation, encapsulation, and decapsulation. Notably, our masked key generation is faster than a previous unprotected design from literature on an Artix-7 FPGA. Lastly, all modules of our complete designs show no signs of first-order leakage after 1 million traces.
    ## 2026/2510
    * Title: Secure Compilation of Probabilistic Side-Channel Countermeasures
    * Authors: Gilles Barthe, Ga|2tan Cassiers, Henri Dohmen, Marc Gourjon, Benjamin Gr|-goire, Nora Khayata, Thomas Schneider, Finn Schubert
    * [Permalink](https://eprint.iacr.org/2026/2510)
    * [Download](https://eprint.iacr.org/2026/2510.pdf)
    ### Abstract
    Probabilistic countermeasures are a common means of protecting programs against side-channels. These countermeasures are hard to implement and are routinely broken by compilers. Proving that a compiler preserves probabilistic side-channel security directly would require reasoning about perfect simulatability of distributions, a challenging technique normally reserved for high-assurance cryptography in frameworks like EasyCrypt and out of scope for compiler correctness.
    In this paper, we present a language- and leakage-model-agnostic framework for provably secure compilation of probabilistic side-channel security notions. Our main contribution is formalizing a deterministic leakage-preservation relation that implies preservation of probabilistic security notions, including d-NI and d-SNI for masking and cryptographic constant-time. Our framework establishes the same guarantees without probabilistic proof obligations, reducing preservation to a per-pass simulation argument on deterministic traces.
    We use the Rocq proof assistant to prove that a model of the core pipeline and several optimizing passes of the Jasmin compiler preserve security in the value-probing model with glitches. We also show how to harden against transition leakage with lightweight annotations at the source level. On top of this, we build libmasking, an open-source library of arbitrary-order masked gadgets in Jasmin that securely compiles to ARM and RISC-V assembly, provides C language bindings, and is benchmarked on real hardware. Together, these contributions are a step towards programming environments in which masked code is written or generated, verified at the source level, optimized, and compiled without breaking security.
    ## 2026/2511
    * Title: I Want to Ride My BIKE: Customizing Bit-Flipping Decoders for Ephemeral Key KEMs
    * Authors: Davide De Zuane, Marco Gianvecchio, Alessandro Annechini, Paolo Santini, Marco Baldi, Alessandro Barenghi, Gerardo Pelosi
    * [Permalink](https://eprint.iacr.org/2026/2511)
    * [Download](https://eprint.iacr.org/2026/2511.pdf)
    ### Abstract
    Large public keys and ciphertexts remain a major obstacle to the deployment of post-quantum cryptosystems in applications currently relying on compact classical schemes. In code-based post-quantum key encapsulation mechanisms, reducing the Decoding Failure Rate (DFR) generally requires larger parameters, further increasing communication and storage overheads. Ephemeral key-pair scenarios allow a different trade-off: ideally, each secret key is used for a single decapsulation, limiting the opportunities to observe and exploit decryption failures. We investigate how this setting can be used to reduce the public-key and ciphertext sizes of code-based key encapsulation mechanisms such as BIKE.
    We present the first optimized implementation of the $\textsf{BF-max}$ decoder:
    compared with conventional parallel bit-flipping decoders currently used by BIKE, $\textsf{BF-max}$ provides better error-correction capability, but its computational structure makes an efficient implementation less straightforward.
    Combining $\textsf{BF-max}$ with other decoders from the literature, we introduce decoding strategies that offer different trade-offs among DFR, execution time, public-key size, and ciphertext size.
    Experimental results show that the proposed design reduces both public-key and ciphertext sizes by 7.8\% compared with LeanBIKE, a BIKE variant specifically designed for ephemeral-key use, while retaining similar execution time and DFR.
    For additional context, the selected parameter set yields a combined public-key and ciphertext size that is 22\% smaller than that of BIKE and smaller by a factor of 2.79 than that of HQC. Note that BIKE and HQC, unlike LeanBIKE and our design, target the long-term-key setting. As a concrete application, we show that the solutions we propose make it possible to incorporate BIKE into constrained protocols, such as Internet Key Exchange version 2 (IKEv2), in which no code-based KEM would otherwise fit.
    ## 2026/2512
    * Title: SLEEK: Sparse Quasi-Cyclic Codes with Closed-Form DFR Key Encapsulation
    * Authors: Alessandro Annechini, Alessandro Barenghi, Marco Gianvecchio, Gerardo Pelosi
    * [Permalink](https://eprint.iacr.org/2026/2512)
    * [Download](https://eprint.iacr.org/2026/2512.pdf)
    ### Abstract
    Performance in terms of bandwidth and execution time, as well as decoding failures remain important challenges for code-based KEMs. This paper introduces SLEEK: Sparse quasi-cycLic codEs with closEd-form DFR Key encapsulation, a Key Encapsulation Mechanism (KEM) based on Quasi-Cyclic Moderate-Density Parity-Check (QC-MDPC) codes. The scheme employs a parallel bit-flipping decoder with three iterations and a closed-form estimate of the decoding-failure rate (DFR). The latter allows parameter selection with analytically bounded failure probability and supports the use of standard IND-CCA transformations.
    We designed two variants of SLEEK. The first, SLEEK-LT, targets IND-CCA security for long-term keys, and supports QC-MDPC codes with different rates, allowing a tradeoff between public-key and ciphertext size. The second, SLEEK-E, targets IND-CPA security for ephemeral keys in settings requiring forward secrecy. While SLEEK-LT makes conservative choices and aims at security against active attackers, SLEEK-E relies on a novel QC key structure, for which we establish security equivalent to that of the original QC-MDPC construction under the same assumptions, while reducing key-generation cost. We explore a broad design space and provide parameter sets targeting $128$-, $192$-, and $256$-bit security, together with an $80$-bit configuration for constrained embedded platforms. We also optimize polynomial inversion and parallel bit-flipping decoding, the two dominant components of the implementation. We provide quantitative benchmarks of our optimized AVX2 implementation of SLEEK. For SLEEK-LT, ciphertexts are $4.9\times$ smaller than those of the NIST standard choice, HQC, at the cost of a $47$% increase in the runtime, and is $1.3\times$ to $2.7\times$ faster than BIKE. For SLEEK-E, execution time improves by $1.6\times$ over HQC with a bandwidth usage reduced by $2.1\times$. Compared with Lean-BIKE, SLEEK-E is $5.3\times$ faster and substantially reduces the impact of decoding failures on system reliability.
    ## 2026/2513
    * Title: Fully Homomorphic Encryption for Small Batches of Complex Numbers
    * Authors: Jules Dumezy
    * [Permalink](https://eprint.iacr.org/2026/2513)
    * [Download](https://eprint.iacr.org/2026/2513.pdf)
    ### Abstract
    We propose a new approximate homomorphic encryption scheme to process small batches of complex numbers. Leveled operations are based on a new shaped rounding, whose error is a multiple of a fixed public ring element $g$, small on the data slots and larger on the others. The unused slots form a guard band that is computed on but never decoded, and the polynomial scaling factor $g^{-1}\Delta$ generalizes the CKKS scaling factor, with $g=1$ recovering CKKS. Guard-domain bounds determine the scaling factor needed for stability, while a norm bound limits the precision gain for a given guard amplification. A replicated layout uses a unit from a small cyclotomic subring to preserve shaping under admissible rotations and traces. We give a native bootstrapping algorithm whose forward transform reads only data slots, and conversions to and from CKKS with shared keys. Security reduces to Ring-LWE with the same parameters as CKKS. In poulpy, at ring degree $2^{15}$ and parameters targeting 128-bit security, bootstrapping a ciphertext holding 16 or 64 values restores 21 levels and retains about 22.8 bits of minimum precision after 21 sequential products by fresh operands, while sparse CKKS supports only four levels at that degree and comparable precision. For these batch sizes, bootstrapping to restore 16 levels is about 3.6 times faster on one thread than sparse CKKS, which requires ring degree $2^{16}$.
    ## 2026/2514
    * Title: Analysis of the Multi-Key Optimization for SPECK
    * Authors: Marco Baldi, Michele Battagliola, Rahmi El Mechri, Paolo Santini, Riccardo Schiavoni
    * [Permalink](https://eprint.iacr.org/2026/2514)
    * [Download](https://eprint.iacr.org/2026/2514.pdf)
    ### Abstract
    SPECK has recently been introduced as a code-based digital signature scheme exploiting the similarities between the Permuted Kernel Problem (PKP) and the Permutation Code Equivalence Problem (PEP). By utilizing PEP as a trapdoor for PKP, SPECK achieves a significant speedup compared to LESS, replacing expensive Gaussian elimination with vector-matrix multiplications.
    This comes at the cost of larger signatures, since each round of the Zero Knowledge (ZK) protocol used in SPECK has soundness error $1/2$.
    A well known technique to reduce the soundness errors (and thus the number of parallel repetitions and, ultimately, the signature size) in ZK proofs based on group actions consists in giving multiple elements in the public keys.
    Despite being constructed around an instance of PEP, which admits a natural description as a code-based group action, the protocol employed in SPECK deviates from the traditional proof of knowledge used for group actions.
    As shown by the authors of SPECK, a naive use of the multi-key optimization may lead to concrete security concerns.
    Therefore, the question on whether such a technique can be applied successfully to SPECK remains open.
    In this paper, we give a positive answer to such a question.
    We revisit the multi-key optimization for SPECK and investigate the underlying security concerns in detail, identifying conditions and parameter constraints under which multiple keys can be securely integrated into the protocol.
    Even though, when instantiated with conservative parameters, the multi-key optimization leads to unappealing performance, we show there is wide room for improvements.
    Furthermore, we design a ring signature scheme based on the same underlying construction.
    ## 2026/2515
    * Title: CHAMP: Cayley HAshing with Matrix Products
    * Authors: Alexander Demin, Alexey Ovchinnikov, Vladimir Shpilrain
    * [Permalink](https://eprint.iacr.org/2026/2515)
    * [Download](https://eprint.iacr.org/2026/2515.pdf)
    ### Abstract
    Cayley hash functions hash binary strings by representing the bits of the message as elements of a semigroup and multiplying the corresponding elements. This gives Cayley hash functions useful homomorphic properties. Here, we propose CHAMP, a Cayley hash function based on products of $2\times 2$ matrices over a finite field, and discuss its security, implementation, and performance.
    ## 2026/2516
    * Title: Watermarking Proofs with Provenance-Binding ZK-SNARKs
    * Authors: Wenhao Wang, Fan Zhang, Charalampos Papamanthou
    * [Permalink](https://eprint.iacr.org/2026/2516)
    * [Download](https://eprint.iacr.org/2026/2516.pdf)
    ### Abstract
    The emerging ecosystem of outsourced proving services, decentralized prover networks, and prover marketplaces raises a new requirement for ZK-SNARKs: the need to watermark proofs with provenance information, such as the prover identity and a fresh request-time nonce. The prover identity records who should receive credit for the proof, while the nonce binds the proof to a particular request and is intended to prevent the prover from reusing work performed before that request was created. The key security requirement is that a prover must perform fresh workrCocomparable to computing the proof from scratchrCowhen generating a proof for a fresh provenance, even if the attacker may have generated the same proofs before or performed precomputation.
    Prior attempts, such as Succinct Network, proposed embedding provenance information in the Fiat-Shamir challenges, though without a rigorous security definition or analysis. We show that this approach is not secure and is vulnerable to preprocessing attacks, in which an adversary can precompute provenance-independent information that can later be used to reduce the effort required to generate proofs for a fresh provenance. We instantiate these attacks against KZG-PLONK.
    To arrive at a secure construction, we propose the first formal definition for provenance-binding ZK-SNARKs to capture the above desired property. We present a generic construction that augments code-based polynomial commitments, such as BaseFold and FRI, with provenance binding. Compiling them with Poly-IOPs yields provenance-binding ZK-SNARKs. Our construction incurs minimal overhead.
    ## 2026/2517
    * Title: Zippel: A Language, Compiler, Runtime, and Analyzer for ZK Proof Systems
    * Authors: Sebastian Angel, Sydnie-Shea Cohen, Eleftherios Ioannidis, Pratyush Mishra, Alex Ozdemir, Yuxiang Qiu, Alireza Shirzad
    * [Permalink](https://eprint.iacr.org/2026/2517)
    * [Download](https://eprint.iacr.org/2026/2517.pdf)
    ### Abstract
    This paper introduces Zippel, a language, compiler, runtime, and analyzer for cryptographic proof systems. Zippel lets developers write proof systems with ease using syntax that mimics pseudocode in cryptography papers. It also eliminates entire classes of vulnerabilities by construction owing to its type system and runtime. For example, Zippel automatically synchronizes protocol transcripts and correctly applies the Fiat--Shamir transform. Zippel also has fully automated static analyses that confirm whether a protocol is complete and sound given only the protocol's description. We have implemented 35 proof systems in Zippel including Sumcheck, Schnorr, KZG, Groth16, Bulletproofs, Hyrax, Spartan, Dory, HyperPlonk, DeKART, and Pari. Our evaluation shows that Zippel programs are competitive with hand-written implementations on multi-core hardware, so Zippel's security and implementation benefits do not come at high cost.
    ## 2026/2518
    * Title: Associated-Data Correlations in Eevee: Deterministic Forgeries against Nonce-Misuse Security
    * Authors: Takanori Isobe, Mostafizar Rahman
    * [Permalink](https://eprint.iacr.org/2026/2518)
    * [Download](https://eprint.iacr.org/2026/2518.pdf)
    ### Abstract
    Eevee's Umbreon and Espeon modes claim online authenticated-encryption security under nonce reuse. We give an independent analysis of associated-data correlations that yield probability-one non-empty-message forgeries with three encryption queries and one verification query. Two AD-only tags reveal a mask difference that translates a ciphertext to another AD value. The basic attacks and their proof diagnosis overlap with independent and concurrent work by Mao et al. Our complementary contribution is a systematic affine treatment of partial final message blocks. For any admissible fixed final-fragment length r, n-r+3 encryption queries suffice; allowing the forged length to be r or r-h for a chosen 1 <= h < r < n, while choosing the source plaintext adaptively, reduces this to n-r+2. Both constructions satisfy the padding check and succeed with probability one. They apply to general message lengths, with at least one preceding complete block for Espeon. We also analyze the published short-message Espeon AD omission, validate the published complete-block Umbreon attack using the official ForkSkinny primitive in a specification adapter, and report a separate two-query attack accepted by the unmodified public C modes. Finalization is discussed only as an unproved countermeasure direction.
    ## 2026/2519
    * Title: DPA-style Attacks on VOLE-in-the-Head Signature Schemes
    * Authors: Jinnuo Li, Shu Han, Yunyan Zou, Fan Zhang, Puwen Wei, Weijia Wang, Hao Cheng
    * [Permalink](https://eprint.iacr.org/2026/2519)
    * [Download](https://eprint.iacr.org/2026/2519.pdf)
    ### Abstract
    VOLE-in-the-Head (VOLEitH) has emerged as a promising paradigm for the design of post-quantum signatures, as it enables efficient signing and verification while also achieving small signature sizes. In the ongoing NIST PQC standardization process for additional digital signatures, two VOLEitH signature schemes, namely FAEST and SDitH, have advanced to the third round. Regarding their practical security, especially resistance to power side-channel attacks, existing studies have focused on only a few specific operations, and thus a comprehensive analysis remains lacking. To address this gap, we present, to the best of our knowledge, the first DPA-style attack framework against VOLEitH signatures. Our framework targets the secret witness, whose recovery permits the generation of valid signatures for arbitrary messages. Based on this framework, we systematically analyze the leakage stemming from the computation of sensitive intermediate values involved in VOLE correlations, and characterize how such leakage can be linked to secret witness hypotheses for mounting DPA-style attacks. As a consequence, we propose six classes of DPA-style attacks on FAEST and SDitH, including two vertical and four horizontal attacks. Finally, the proposed attacks are validated using both simulated leakage under varying noise conditions and practical measurements on three ARM Cortex-M4 devices, demonstrating their effectiveness in both settings.
    ## 2026/2520
    * Title: GPU Acceleration for Boyar-Peralta Algorithm in High Dimensional Linear Layers
    * Authors: Xiao Huang, Chao Sun, Ge Wu, Liquan Chen
    * [Permalink](https://eprint.iacr.org/2026/2520)
    * [Download](https://eprint.iacr.org/2026/2520.pdf)
    ### Abstract
    The design of lightweight cryptographic schemes necessitates efficient circuit implementations of linear layers. A commonly used metric for evaluating circuit efficiency is the number of XOR gates required. For a given linear transformation over $\mathbb F_2$, finding its circuit implementation with the minimum number of XOR gates is referred to as the Shortest Linear Program (SLP) problem. As a prominent heuristic, the Boyar-Peralta (BP) algorithm provides competitive results, and numerous subsequent studies have introduced further optimizations. However, the inefficient implementations of the BP-like algorithms significantly limit their applicability to high-dimensional and dense matrices, and effective solutions to these performance bottlenecks remain scarce.
    In this paper, we address the performance bottlenecks of the BP algorithm and its variants (e.g., A1, A2 and BP-LSL) both theoretically and practically. We introduce the meet-in-the-middle (MITM) approach to reduce their theoretical time complexity. Practically, we re-design the implementation framework of these algorithms to fully leverage GPU parallelism, which significantly reduces the time spent on computing multiple XOR sums of bases, performing binary search, and updating distances. Meanwhile, we also propose a candidate pruning mechanism to reduce the computational burden on the GPU side and further improve the overall efficiency. Compared with the original implementations, we significantly accelerate the solving process for both normal and depth-constrained scenarios while maintaining the same solution quality.
    Our experimental results demonstrate that, for a 26-dimensional matrix with density 0.5, our implementation requires only 9.44 seconds on an entry-level GTX 1650 GPU, achieving a speedup of over $6{,}200\times$ compared with the current recursive, exhaustive, and one-threaded implementation.
    Using a high-performance RTX 4090 GPU, we extend the solvable boundary to 64-dimensional sparse matrices and 42-dimensional matrices with density 0.381. For 32-dimensional dense matrices, our accelerated A1 algorithm successfully establishes some new g-XOR records, including a 172-step g-XOR implementation for Whirlwind M0 and a 170-step implementation for Whirlwind M1. Besides, we also provide a 157-step g-XOR sequence for AES-InvMixColumn matrix with depth 5 through our BP-LSL implementation. Based on our accelerated BP implementation, we construct some MDS matrices with dimension 40 or more. For $4\times 4$ blockwise circulant matrices of dimensions 40, 48, and 64, the minimum g-XOR sequence lengths we found are 110, 132, and 184.
    ## 2026/2521
    * Title: EN4acient Fixed-Point Implementation of Mitaka
    * Authors: Shiduo Zhang, Paul Kirchner, Xiuhan Lin, Yang Yu
    * [Permalink](https://eprint.iacr.org/2026/2521)
    * [Download](https://eprint.iacr.org/2026/2521.pdf)
    ### Abstract
    The Mitaka signature scheme is a variant of Falcon (FN-DSA). It has a considerably simpler signing procedure that can be parallelized while retaining Falcon's efficiency advantage. Mitaka offers two different signing approaches: a default one relying on floating-point arithmetic and an alternative, called MitakaZ, avoiding floating-point arithmetic at the cost of more Gaussian samples. Despite its better portability, MitakaZ has not previously been implemented in practice.
    This work presents an efficient fixed-point implementation of the Mitaka signing algorithm. We optimize the MitakaZ Gaussian sampler to make it suited to fixed-point arithmetic while achieving higher efficiency. Specifically, we replace the wide integral Gram root decomposition used in MitakaZ with a fixed-point square Cholesky decomposition, which substantially reduces the cost of integer Gaussian sampling. We prove bounds on intermediate values and representation errors without empirical assumptions on their magnitudes. The distributional analysis models each integer Gaussian call as exact at its represented inputs. We provide a fixed-point implementation of the new Mitaka signing algorithm in C. On an Intel Core~i7-1360P, our native AVX2 implementation generates signatures in an average of 361 kcycles for Mitaka-512 and 707 kcycles for Mitaka-1024, measured with Linux hardware performance events. On an ARM Cortex-M4F STM32F411, the corresponding measured costs are 4.0 and 7.8 Mcycles.
    ## 2026/2522
    * Title: Superspecial points on Humbert surfaces and the probability of (N,N)-splitting
    * Authors: Tanush Shaska
    * [Permalink](https://eprint.iacr.org/2026/2522)
    * [Download](https://eprint.iacr.org/2026/2522.pdf)
    ### Abstract
    Let $p\equiv3\pmod4$ be a prime and let $N\geq2$ be an integer. We determine, to first order in $1/p$ and with an explicit error bound, the proportion of superspecial principally polarized abelian surfaces over $\overline{\mathbb{F}}_p$ that are optimally $(N,N)$-split. The surfaces are weighted by the reciprocals of their automorphism orders, which is the stationary measure of the Richelot random walk. The main theorem states that for $p\nmid N$ the expected number of optimal $(N,N)$-splittings of a surface is exactly $5NJ_2(N)(p-1)/(p^2+1)$, where $J_2$ is Jordan's totient; that for $p>2N^2$ the second factorial moment is $c_N/(p^2+1)$ with $c_N$ independent of $p$; and consequently that, for fixed $N$, the proportion of split surfaces is $5NJ_2(N)/p+O_N(p^{-2})$. The constants $c_N$ are determined explicitly for $2\leq N\leq7$. This proportion is the stationary target density of the splitting-detection attack on the superspecial isogeny problem in dimension two. It was previously known only from experiments or from a one-sided bound. The method is to show that the superspecial surfaces sample the genus of their refined Humbert invariants with Siegel's weights, which makes Siegel's theorem on genus averages available. The same method gives the first moment of primitive representations of every discriminant prime to $p$, mixed moments for several levels, an exact probability at level $2$, and a proof that the geometric upper bound of earlier work has the correct leading term. All results are proved; the enumerations enter only through the values of $c_N$, and every formula was additionally confirmed by exact computation at twelve primes.
    --- Synchronet 3.22a-Linux NewsLink 1.2