Eliminating Trusted Setups in Cryptographic Proofs

153 concepts139 papers1 proposal

Imagine building a digital fortress where the security of every lock depends on a single master key that was melted down and destroyed during construction. If even a speck of that molten metal survived, an attacker could forge copies of any key, bypass every lock, and manipulate the contents of the fortress without leaving a trace.

This is the paradox of the trusted setup in modern cryptography. To make zero-knowledge proofs succinct and fast to verify, protocols historically relied on a initialization phase to generate a Common Reference String (CRS) or Structured Reference String (SRS). This phase requires a set of initial secrets—often called "toxic waste"—to be generated and then completely destroyed.

As Rinberg et al. explain, if these initial parameters are compromised or not properly discarded, malicious actors can generate fraudulent proofs or mint unauthorized assets undetected. This creates a fundamental centralization risk and a single point of failure in supposedly decentralized systems. Consequently, a major shift in cryptographic research focuses on eliminating this dependency entirely, moving toward transparent proof systems.


The Root of the Dependency: Why Setups Exist

To understand how to eliminate the trusted setup, we must first understand why early succinct proof systems required them.

In pairing-based zero-knowledge arguments (such as the widely used Groth16 protocol), a prover wants to convince a verifier that they know a valid solution to a complex computational circuit. To keep the proof small and the verification instantaneous, the circuit is converted into a system of polynomials. The verifier checks the proof by evaluating these polynomials at a secret, randomly chosen point $\s$.

If the prover knows $\s$ ahead of time, they can easily construct a fake polynomial that happens to intersect with the true polynomial at exactly that point, allowing them to forge a valid proof for a false statement. Therefore, $\s$ must remain completely hidden. In a trusted setup, a distributed group of participants calculates powers of $\s$ hidden inside cryptographic groups (e.g., $g^s, g^{s^2}, \dots$), creating a Structured Reference String. The raw value of $\s$ is then discarded.

While multi-party computation (MPC) ceremonies can distribute this risk among many participants, the system still requires a baseline assumption of honesty. Furthermore, as Gennaro et al. point out, these traditional setups are often tied to a specific computation or circuit, meaning any change to the underlying program requires an entirely new setup ceremony.


The Vulnerability of Subversion

The danger of the trusted setup isn't just that the initial participants might be careless; it is that the authority managing the setup might be actively malicious.

Ananth et al. formalized this threat by exploring what happens when the reference string is maliciously chosen from the start. If a subverted authority plants a backdoor in the CRS, they can break the privacy of users or forge proofs at will. While researchers have designed safety nets like "accountable soundness" to catch cheating authorities after the fact, the ultimate goal remains a transparent setup—one where the public parameters are completely unstructured, uniform, and require no pre-existing secrets.


Mechanism 1: Recursive Inner Product Arguments

The most prominent strategy for eliminating the trusted setup replaces the structured reference string with a random reference string that can be generated safely via public randomness (such as a hash function). The breakthrough architecture for this approach is the Inner Product Argument (IPA).

Instead of evaluating a polynomial at a hidden secret point, the protocol frames the proof as a vector commitment problem. The prover wants to show that the inner product of two secret vectors equals a given scalar.

Traditional Setup (Structured):
[Secret s] ──> Generate SRS (g^s, g^s², ...) ──> Destroy s (Risk of Toxic Waste)

Transparent Setup (Unstructured):
[Public Randomness] ──> Generate Random Base Vectors (g₁, g₂, ...) ──> No Secrets Kept

To keep the proof succinct without a hidden secret, the protocol uses a recursive, logarithmic reduction strategy introduced in the original Bulletproofs framework by Bootle et al..

  1. Vector Halving: In each round of the interaction, the prover splits their vectors of length $n$ into two halves ($n/2$).
  2. Linear Combination: The prover computes a random linear combination of these halves using a challenge value provided by the verifier.
  3. Logarithmic Scaling: This process repeats recursively until the vectors are reduced to a single element.

Because the vectors are halved at each step, the communication overhead scales logarithmically rather than linearly. To optimize this further, Chung et al. introduced a zero-knowledge weighted inner product argument (zk-WIP). This variant shrinks the proof size by an additional 15% while maintaining a completely transparent setup, making it highly practical for confidential transaction ledgers where blockchain bloat is a critical constraint.


Mechanism 2: Interactive Oracle Proofs and Polynomial Delegation

Another powerful alternative to trusted setups involves compiling Interactive Oracle Proofs (IOPs) into non-interactive proofs using the Fiat-Shamir heuristic.

Instead of relying on elliptic curve pairings and hidden evaluation points, these systems use transparent polynomial delegation. For example, the Virgo proof system designed by Zhang et al. eliminates the trusted setup by building upon the GKR interactive proof protocol.

In this paradigm, the circuit is evaluated layer by layer. The verifier reduces a claim about the outputs of a layer to a claim about its inputs using a sum-check protocol, which relies only on simple field arithmetic and random challenges. By pairing this with a transparent polynomial delegation scheme, the prover can commit to data using nothing more than cryptographic hash functions. This results in a system that requires zero pre-coordinated parameters, offers fast proving times, and remains secure even against quantum adversaries.


Shifting the Trust Model

Eliminating the trusted setup fundamentally changes the infrastructure requirements of decentralized applications.

In traditional models, establishing security in complex multi-party environments or universal composability frameworks required a heavy reliance on a globally trusted CRS. To bypass this, researchers like Yao et al. have explored alternative cryptographic models, such as the Bare Public-Key (BPK) model. By removing the assumption of structured, trusted randomness and instead allowing users to simply register public keys, protocols can achieve non-malleability and concurrent security without a centralized initialization phase.

By replacing hidden algebraic secrets with recursive reduction arguments and interactive oracle techniques, modern cryptography is successfully decoupling privacy from trust. The elimination of the trusted setup ensures that the integrity of a cryptographic system depends solely on the laws of mathematics and public randomness—not on whether a group of human participants successfully destroyed their keys.

Key Foundational Work

Efficient and Non-Interactive Non-Malleable Commitment (2001) — contributed 2 concept elements to this direction.
History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 139 papers
  2. Version 1 · 2026-10-04 · 184 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_trusted_setup_dependency_4bbfd346,
  title = {trusted setup dependency},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/trusted-setup-dependency/rdr_4bbfd346f87f46d9806361b23254f20f},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 2, frozen text):

@misc{lacuna_trusted_setup_dependency_4bbfd346_v2,
  title = {trusted setup dependency},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/trusted-setup-dependency/rdr_4bbfd346f87f46d9806361b23254f20f/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake