Preprocessing for High Performance Secure Computation

This direction is split into other directions: preprocessing overhead (preprocessing communication overhead). Its last version stays readable and citable here.

Version 1 of 150 papers53 conceptsfrozen 2026-10-04

In traditional secure computation, the "tax" of privacy is paid in real-time. If two parties want to multiply private numbers or evaluate a neural network, they must exchange multiple rounds of messages, performing heavy cryptographic operations while the user waits for a result. This interaction creates a latency bottleneck that has long prevented secure protocols from reaching the speed of plaintext computing.

To solve this, researchers have converged on a powerful architectural shift: the Online/Offline Split. By moving the most expensive cryptographic tasks to an "offline" phase—performed before the actual inputs are even known—the "online" phase can be reduced to a few simple, lightning-fast operations.

The Strategy of Correlated Randomness

The core intuition behind this direction is that the "hardness" of secure computation often stems from the need to maintain secrecy during mathematical operations like multiplication. In a standard Multi-Party Computation (MPC) protocol, multiplying two secret-shared values requires interaction. However, as noted by Zhelei Zhou, Kui Ren, and Bingsheng Zhang in Practical Constructions for Single Input Functionality against a Dishonest Majority, the total execution time is often dominated by the generation of correlated randomness.

The most famous example is the Beaver Triple. If parties pre-generate shares of three random values $(a, b, c)$ such that $a \cdot b = c$, they can later multiply their actual private inputs $(x, y)$ using only simple additions and a single round of communication. This shifts the "cryptographic heavy lifting" to a time when the system is idle. Wuxuan Jiang and colleagues demonstrate in Spin: An Efficient Secure Computation Framework with GPU Acceleration that while the online phase is highly optimized, the generation of these triples remains the primary performance bottleneck for the system as a whole.

Beyond Arithmetic: Function Secret Sharing and Lookup Tables

While Beaver triples handle basic math, modern applications like Large Language Models (LLMs) require non-linear functions like Sigmoid or ReLU. Recent work has extended the online/offline paradigm to these complex operations using Function Secret Sharing (FSS) and Lookup Tables (LUTs).

In the SIGMA system, Kanav Gupta and Nishanth Chandran use FSS to pre-generate cryptographic keys that "describe" a function. During the online phase, these keys allow parties to evaluate complex Transformer layers with massive speedups. Similarly, A New PPML Paradigm for Quantized Models treats model operators as private lookup tables. By precomputing these tables in an offline phase, the online inference for LLMs can be accelerated by up to 25x.

The intuition here is to treat the function itself as a resource that can be "pre-shared." Instead of computing a complex curve in real-time, the parties simply "look up" the answer using pre-distributed shares, as explored by Max Lam in the Tabula protocol.

The Preprocessing Bottleneck

The "speed" of the online phase is not free; it is a transfer of debt. Shifting computation to the offline phase creates three distinct challenges:

  1. Communication Volume: Generating authenticated shares often requires massive data transfers. Daniel Escudero and Anders Dalskov note in Honest Majority MPC with Abort with Minimal Online Communication that reducing online communication often necessitates a more expensive preprocessing stage to generate authentication structures.
  2. Storage Overhead: For large-scale models, the precomputed "keys" or "triples" can reach hundreds of gigabytes. Neha Jawalkar and the Matchmaker team highlight a new "storage bottleneck" where the time to fetch precomputed keys from a disk can actually exceed the time spent on computation.
  3. Setup Latency: For one-off computations, the offline phase can be a dealbreaker. Ran Canetti and Guy N. Rothblum pointed out in Two 1-Round Protocols for Delegation of Computation that if the setup effort is proportional to the circuit size, the benefits are only realized when costs are amortized over many uses.

Silent Preprocessing: The Next Frontier

To address the communication cost of the offline phase, researchers like Claudio Orlandi and Peter Scholl have pioneered Silent Preprocessing.

In Low-Bandwidth Threshold ECDSA via Pseudorandom Correlation Generators, they describe a method where parties exchange tiny cryptographic seeds. These seeds then "expand" locally into massive amounts of correlated randomness without further communication. This technique, using Pseudorandom Correlation Generators (PCGs), allows for bandwidth savings of up to 400x, effectively making the "offline tax" much more affordable for bandwidth-constrained devices.

By treating cryptographic material as a commodity that can be manufactured in advance and stored for later use, this research direction has transformed secure computation from a theoretical curiosity into a practical tool for real-time applications like biometric authentication, private search, and secure AI inference.

Papers in this version

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_preprocessing_for_high_performance_secur_d20c1a5f,
  title = {Preprocessing for High Performance Secure Computation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/preprocessing-for-high-performance-secure-computation/rdr_d20c1a5f8ee542dda61b6ed17b3a4ff1},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_preprocessing_for_high_performance_secur_d20c1a5f_v1,
  title = {Preprocessing for High Performance Secure Computation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/preprocessing-for-high-performance-secure-computation/rdr_d20c1a5f8ee542dda61b6ed17b3a4ff1/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}