Modern cryptography and modern artificial intelligence are built on two fundamentally different mathematical foundations. Cryptographic protocols, such as Multi-Party Computation (MPC) and Homomorphic Encryption (HE), typically operate on large integers within finite fields or rings to ensure exactness and security. In contrast, the hardware that powers AI—GPUs and specialized accelerators—is optimized for floating-point arithmetic, where speed is prioritized over modular precision.
This "impedance mismatch" has historically made privacy-preserving machine learning painfully slow. However, a new research direction is bridging this gap by repurposing standard floating-point units (FPUs) to perform secure cryptographic operations, achieving orders-of-magnitude speedups by meeting the hardware where it lives.
The Integer Bottleneck
When we perform standard neural network training, we use 32-bit or 16-bit floats. But when we move to the encrypted domain, we often use 64-bit or even 128-bit integers. Standard GPUs are remarkably bad at the specific type of modular arithmetic required for these large integers. While a GPU can perform trillions of floating-point operations per second (FLOPS), its throughput for high-precision modular integer math is a fraction of that.
To solve this, researchers like Lucien K. L. Ng and Sherman S. M. Chow in Goten propose a "mantissa mapping" strategy. They realized that a double-precision (64-bit) floating-point number contains a 53-bit significand (mantissa). By carefully mapping cryptographic finite field integers into these 53 bits, they can use the GPU’s high-speed floating-point pipelines to perform exact modular arithmetic. This allows Goten to outsource heavy computations from restricted Trusted Execution Environments (TEEs) to untrusted GPUs, achieving a 132x speedup over traditional methods.
Secret Sharing on Real Numbers
A more radical approach moves away from integer rings entirely. Traditional additive secret sharing splits a secret $x$ into $x_1$ and $x_2$ such that $x = x_1 + x_2 \pmod q$. Katrine Tjell and Rafal Wisniewski argue in Privacy in Distributed Computations based on Real Number Secret Sharing that we can perform secret sharing directly on real numbers.
By accepting an infinitesimal, quantifiable privacy leak, they enable secure computation at machine precision. This is particularly powerful for operations that are notoriously difficult in integer-based cryptography, such as division. In their framework, reciprocals can be computed by masking secrets with random real numbers, allowing a privacy-preserving Kalman filter to run with minimal communication overhead.
Similarly, the PermLLM framework, developed by Chaochao Chen and Fei Zheng, extends additive secret sharing to floating-point numbers to enable private inference for Large Language Models. By avoiding the conversion to integer rings, PermLLM leverages standard GPU acceleration to generate tokens in roughly 3 seconds over a WAN—a feat previously considered computationally infeasible for models of that scale.
Accelerating Homomorphic Encryption with BLAS
The same intuition applies to Homomorphic Encryption (HE). The CKKS scheme is popular for machine learning because it natively supports approximate arithmetic on vectors of complex numbers. However, the underlying implementation still relies on complex polynomial multiplications.
In Fast Homomorphic Linear Algebra with BLAS, Youngjin Bae and Damien Stehlé demonstrate that these operations can be reduced to standard BLAS (Basic Linear Algebra Subroutines). By using truncation and "chopping" strategies to fit cryptographic calculations into 53-bit floating-point hardware, they bridge the gap between encrypted and cleartext performance. Their approach results in encrypted matrix multiplications that are only 4–12x slower than standard double-precision operations, compared to the 10,000x slowdowns seen in earlier integer-only implementations.
Why It Works: The Hardware Alignment
The success of this research direction stems from a shift in perspective: instead of trying to make hardware better at cryptography, researchers are making cryptography look more like the data hardware was designed to move.
- Precision Management: By staying within the 53-bit mantissa of FP64, researchers prevent the overflow and rounding errors that would otherwise break cryptographic integrity.
- Library Reuse: By framing secure operations as linear algebra, researchers can inherit decades of optimization in libraries like cuBLAS or Intel MKL.
- Direct Acceleration: Moving secret sharing to the floating-point domain allows the use of Tensor Cores and other specialized AI hardware that simply cannot process traditional cryptographic rings efficiently.
By treating the floating-point unit as a high-throughput modular arithmetic engine, this field is turning the "inexactness" of real-number hardware into a high-performance substrate for exact privacy.