💻 computer science

From Finite Enumeration to Universal Proof: Ring-Theoretic Foundations for PQC Hardware Masking Verification

This paper presents the first machine-checked universal proof in Lean 4 that establishes value-independence implies identical marginal distributions for arithmetic masking across all moduli $q > 0$ , thereby replacing finite-domain SMT-based verification with a sound, ring-theoretic foundation for post-quantum cryptographic hardware.

Original authors: Ray Iskander, Khaled Kirah

Published 2026-04-22

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ray Iskander, Khaled Kirah

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are building a high-security vault to protect the world's most valuable secrets. In the future, powerful "quantum" computers will be able to crack today's locks, so you need to build a new kind of vault using Post-Quantum Cryptography (PQC).

But there's a catch: even if the lock is mathematically perfect, a thief might not break the lock; they might just listen to the sound of the tumblers clicking or feel the heat of the metal as you turn the key. This is called a "side-channel attack."

To stop this, engineers use a trick called Masking. Instead of turning the key with one hand, you split the action between two hands (shares) that move randomly. If a thief only watches one hand, they see nothing but random noise.

The Problem: The "Tiny Sample" Trap

The authors of this paper, Ray and Khaled, had previously built a super-smart robot (called QANARY) to check if their vault designs were safe from these side-channel attacks.

However, there was a major flaw in how they tested it:

The Old Way: To prove the vault was safe, the robot checked the design using a very small, simple number system (like a lock with only 5 possible positions). It checked every single combination of those 5 positions.
The Reality: The real vaults they are building for the future use numbers so huge they are practically infinite (like 3,329 or 8 million positions).
The Gap: Proving a lock works with 5 positions doesn't guarantee it works with 8 million. It's like proving a bridge can hold a bicycle by testing it with a toy car. You know the toy car fits, but you can't be 100% sure a real truck won't break it.

The old method relied on brute force (checking every possibility), which is impossible when the numbers get that big.

The Solution: The "Universal Key"

In this paper, the authors stop trying to count every single possibility. Instead, they switch to pure mathematics (specifically, something called Ring Theory) to prove the vault is safe for every possible number size, all at once.

Here is the analogy:

The Old Robot (SMT Solvers): Imagine trying to prove a door is secure by trying every single key in the world, one by one. If you have 5 keys, it takes a minute. If you have 8 million keys, it would take forever.
The New Robot (Lean 4 Proof): Imagine a master locksmith who looks at the shape of the keyhole and the shape of the key. They realize, "Ah, because of the way the metal bends, no matter how big the key is, it will always fit perfectly." They don't need to try the keys; they just need to understand the geometry of the lock.

The "Five-Line" Miracle

The most surprising part of the paper is how simple the solution turned out to be.

The old method required checking 33 million different scenarios to feel confident.
The new method required a five-line mathematical proof.

Why? Because the authors realized that the security of the vault isn't about the specific numbers; it's about the rules of the game (the algebra). Once you prove the rules work for any number, you don't need to check the numbers individually.

What This Means for You

Future-Proof Security: The vaults built for the new NIST standards (ML-KEM and ML-DSA) are now mathematically guaranteed to be safe, not just for the numbers we use today, but for any numbers we might use tomorrow.
Less Trust, More Proof: Previously, we had to trust that the computer software checking the locks didn't have bugs. Now, the proof is so simple and fundamental that it's verified by the very core of the mathematical language itself. It's like moving from trusting a mechanic's word to reading the blueprint yourself.
Efficiency: They found that the "complex" problem was only complex because they were looking at it the wrong way. Once they looked at it through the lens of algebra, the solution was as simple as saying, "A plus B minus B always equals A."

The Bottom Line

The authors took a massive, scary gap in security verification (where we couldn't be sure big numbers were safe) and filled it with a tiny, elegant mathematical bridge. They proved that if the "masking" trick works for a small number, the laws of mathematics guarantee it works for the biggest numbers imaginable.

They didn't just build a better lock; they proved that the blueprint for the lock is unbreakable, no matter how big you make it.

1. Problem Statement

The paper addresses a critical gap in the formal verification of Post-Quantum Cryptography (PQC) hardware, specifically regarding arithmetic masking used to defend against side-channel attacks (e.g., power analysis) in Number Theoretic Transform (NTT) accelerators.

The Context: Recent NIST standards (FIPS 203 for ML-KEM and FIPS 204 for ML-DSA) rely on modular arithmetic over large prime fields ( $q = 3,329$ and $q = 8,380,417$ , respectively).
The Limitation of Prior Work: The authors' previous framework, QANARY, used Structural Dependency Analysis (SADC) to verify hardware security. However, its soundness guarantee (Theorem 3.9.1) relied on SMT solvers (Z3, CVC5) to perform exhaustive enumeration over a finite domain ( $q=5$ $q = 5$ ).
- The Gap: A proof verified at $q=5$ does not structurally guarantee correctness for production moduli ( $q=3,329$ or $q=8,380,417$ ). SMT solvers enumerate cases but cannot perform structural induction. Furthermore, the trusted base included complex, unverified tools (Z3, CVC5, Python encoders).
The Challenge: There was a need for a universal, machine-checked proof that holds for all $q > 0$ , eliminating the need for re-verification for every new parameter set and reducing the trusted computing base.

2. Methodology

The authors shifted from bit-vector SAT solving to Interactive Theorem Proving (ITP) using Lean 4 and its mathematical library, Mathlib.

Abstraction Shift: Instead of modeling arithmetic as bit-vectors with explicit overflow checks and modular reduction operations (which obscures algebraic structure), the authors modeled the domain as the quotient ring $\mathbb{Z}/q\mathbb{Z}$ .
Core Concept: They formalized Value-Independence. A wire function $w$ is value-independent of a secret $x$ if $w(x - s_1, s_1) = w(x' - s_1, s_1)$ for all masks $s_1$ .
Proof Strategy:
- They utilized the commutative ring axioms of $\mathbb{Z}/q\mathbb{Z}$ (specifically sub_add_cancel) to prove that value-independence implies a constant marginal distribution.
- The proof relies on the fact that reparametrization ( $s_0 = x - s_1$ ) is a ring identity, not a computational procedure subject to overflow errors in the abstract model.
- The entire proof suite is sorry-free (no unverified stubs) and kernel-verified, meaning the Lean kernel (a small, formally specified core) checks every logical step.

3. Key Contributions

The paper presents a comprehensive proof suite comprising nine theorems (T1–T6, T1', T3') that replace the previous finite-domain verification:

Universal Main Theorem (T1): A machine-checked proof that for any $q > 0$ $q > 0$ , any wire function, and any secrets, value-independence implies identical marginal distributions.
- Impact: This proves that if a wire is structurally independent of the secret, it leaks zero information, regardless of the modulus size.
Supporting Theorems:
- T2 & T3: Proofs of reparametrization round-trips for Boolean (XOR) and Arithmetic (subtraction) masking, valid for all $k$ and $q$ .
- T3': Proof of bijectivity for the reparametrization map, ensuring no collisions occur in the mask space.
- T4: No-overflow bounds bridging the abstract ring model to concrete bit-vector hardware implementations.
- T5: Characterization of RNG bias (e.g., for ML-KEM's $q=3,329$ ) and universal bounds for bias in any $N, q$ configuration.
- T6: A universal non-tightness counterexample proving that the converse of the main theorem fails for all $q \ge 2$ (i.e., a constant distribution does not guarantee value-independence). This validates the conservative nature of the QANARY tool.
Methodological Insight: The authors demonstrate that ring theory is the natural abstraction layer for arithmetic masking, whereas bit-vector SAT is an inefficient and structurally opaque alternative.

4. Results

Proof Brevity vs. Complexity: The core soundness result (Theorem 4.1), which previously required 225 Boolean evaluations (and $33.5$ million checks in the broader context of Paper 2) using SMT solvers, is now proven in five lines of Lean 4 code.
Verification Status:
- 1,739 build tasks completed.
- 0 errors, 0 sorry (unverified stubs).
- Verified on Lean 4.30.0-rc1 with Mathlib pinned to a specific commit.
Scope Expansion: The verification now covers all positive moduli ( $q > 0$ ), including current NIST standards (ML-KEM, ML-DSA) and any future PQC parameters, without requiring re-verification.
Trusted Base Reduction: The trusted computing base was reduced from complex, unverified SMT solvers (Z3, CVC5) and Python encoders to the Lean 4 kernel (and the native compiler for specific instances).

5. Significance

Certification (FIPS 140-3): The universal proof eliminates the need for Cryptographic Module Validation Program (CMVP) laboratories to re-verify security for every parameter change. A single proof covers all $q$ .
Design Portability: Security guarantees are now "future-proof." If NIST updates parameters or adopts new lattice-based schemes, the existing formal proof remains valid automatically.
Tool Trust: By moving to a kernel-verified proof, the authors significantly increase the trustworthiness of the security analysis. The result is no longer dependent on the correctness of external solver implementations.
Theoretical Advancement: The paper establishes that the algebraic structure of $\mathbb{Z}/q\mathbb{Z}$ is sufficient to prove security properties that were previously thought to require exhaustive enumeration. It suggests that other complex properties (e.g., higher-order masking, composition of NTT stages) may admit similarly concise proofs when formulated algebraically.

In conclusion, this paper closes the "finite-domain gap" in PQC hardware verification, transitioning the field from case-specific enumeration to universal, algebraic formal proofs, ensuring robust security guarantees for the next generation of cryptographic hardware.