Imagine a group of competing companies trying to compute their industry's average revenue without revealing their individual financial data. They can use Secure Multiparty Computation (MPC) to achieve this privacy. But what happens if, at the very last second of the protocol, one dishonest company receives the final average and immediately goes offline, refusing to send its final message to the others?
The dishonest company now possesses a unique competitive advantage: it knows the industry average, while every honest company is left with nothing.
This scenario illustrates the protocol abort vulnerability. To achieve high performance, many foundational MPC frameworks operate under a model called security with abort, as explored by Escudero et al. in Honest Majority MPC with Abort with Minimal Online Communication and Polychroniadou et al. in Constant-Overhead Unconditionally Secure Multiparty Computation over Binary Fields. In this model, if any participant cheats or drops out, the protocol safely terminates to protect data privacy.
While privacy is preserved, this lack of fairness creates a severe vulnerability. A single malicious actor can execute a denial-of-service attack or engineer an information asymmetry, stalling auctions (Blass et al.), disrupting anonymous messaging networks (Eskandarian), or invalidating outsourced cloud computations (Jakobsen et al.).
To solve this, researchers focus on achieving Guaranteed Output Delivery (GOD)—a security standard ensuring that if any party learns the output, all honest parties are guaranteed to receive it as well.
The Root Cause: The Last-Mover Advantage
To understand why guaranteed output delivery is difficult to achieve, we have to look at how messages travel across a network. In standard point-to-point networks, parties communicate sequentially or over isolated channels rather than through a magical, instantaneous global broadcast.
As Ananth et al. demonstrate in Two Round Information-Theoretic MPC with Malicious Security, point-to-point communication naturally enables selective aborts. An adversary can strategically send their final message to a subset of honest participants while withholding it from others. Bartusek et al. show in On the Communication Complexity of Secure Multi-Party Computation With Aborts that preventing these selective failures typically introduces significant communication overhead.
When a protocol forces participants to speak one after another, the last participant always holds a structural advantage. Naor et al. analyzed this dynamic through a game-theoretic lens in Cryptography and Game Theory: Designing Protocols for Exchanging Information, proving that eliminating this last-mover advantage requires tying the communication complexity directly to the size of the output range. Without specific countervailing mechanisms, sequential protocols inherently struggle to distribute results fairly.
Solution 1: Leveraging Honest Majorities and Redundancy
The most direct way to achieve guaranteed output delivery is to change the underlying trust assumptions of the network. If we can guarantee that a strict majority of the participants are honest, we can use mathematical redundancy to bypass any party that aborts.
Consider the FLASH framework introduced by Chaudhari et al. in FLASH: Fast and Robust Framework for Privacy-preserving Machine Learning. The authors demonstrate that by scaling a secure computation from three participants to four, the system can seamlessly transition from "security with abort" to true guaranteed output delivery.
[Security with Abort (3 Parties)]
Adversary quits ──> Protocol halts ──> Honest parties get nothing
[Guaranteed Output Delivery (4 Parties)]
Adversary quits ──> Majority-rule logic ──> Protocol completes ──> Everyone gets output
This works because the data is distributed using secret-sharing schemes with built-in threshold redundancy. When a malicious actor goes offline or attempts to sabotage the final phase, the remaining honest parties still hold enough overlapping shares to reconstruct the missing pieces using majority-rule logic. As shown by Abspoel et al. in An Efficient Passive-to-Active Compiler for Honest-Majority MPC over Rings, this honest-majority assumption allows protocols to actively identify and exclude cheaters, ensuring the computation reaches completion without a massive performance penalty.
Solution 2: Decoupling Fairness from Circuit Complexity
But what if we cannot guarantee an honest majority? If the majority of participants are potentially malicious, achieving fairness is notoriously difficult. Historically, making an entire complex circuit "fair" meant that every single addition and multiplication gate required expensive verification steps, causing communication costs to skyrocket.
The breakthrough intuition that makes modern dishonest-majority fairness practical is decoupling: we do not need the entire computation to be fair; we only need the final share reconstruction to be fair.
Orlandi et al. formalized this in Yet Another Compiler for Active Security or: Efficient MPC Over Arbitrary Rings. They proved that a protocol can be compiled such that the cost of ensuring complete fairness is entirely independent of the total complexity of the computed function. Instead, the overhead scales strictly with the size of the final output.
This is achieved by dividing the protocol into two distinct phases:
- The Computation Phase: The parties evaluate a massive, complex circuit using a highly efficient, unfair protocol that provides "security with abort." Instead of revealing the actual answer, this phase outputs encrypted or secret-shared fragments of the result.
- The Reconstruction Phase: The parties use a specialized, lightweight primitive called Synchronizable Fair Exchange to swap their final shares.
As developed by Kumaresan et al. in Synchronizable Exchange and Synchronizable Fair Exchange, this primitive acts as a synchronized cryptographic clearinghouse. The exchange is structured so that unlocking one party's share mathematically forces the release of the other shares. If an adversary tries to abort mid-exchange, the protocol ensures that either all honest parties receive enough shares to reconstruct the output, or no one does.
Solution 3: Verifiable Aborts and Graph-Based Interaction
A third approach to enforcing fairness without relying on expensive broadcast channels is to make the act of aborting cryptographically traceable.
In the ASTRA framework, Chaudhari et al. introduce a proof-of-origin mechanism for abort signals in ASTRA: High Throughput 3PC over Rings with Application to Secure Prediction. If a malicious participant attempts to selectively trigger an abort to isolate a specific honest party, that honest party receives an undeniable cryptographic receipt of the abort signal. This receipt can be instantly distributed to all other participants. Because the abort signal is verifiable, the adversary cannot quietly exploit an information asymmetry; the moment they try to withhold data from one person, they trigger a synchronized, system-wide termination.
Alternatively, fairness can be engineered directly into the structural flow of the protocol's messages. In Generalizing Multi-party Contract Signing, Mauw et al. demonstrated that multi-party interactions can be modeled as Directed Acyclic Graphs (DAGs). By mathematically analyzing the state transitions within these graphs, the authors showed that a protocol is guaranteed to be fair if its interaction sequence is entirely free of abort-chaining sequences.
By structuring the message graph correctly, you ensure that a dishonest participant can never reach a state where they have committed an honest party to an outcome while retaining a unilateral path to abort the rest of the network.
Key Foundational Work
Co-operative Private Equality Test (2005) — contributed 1 concept elements to this direction.
Secure Computation Without Agreement (2002) — contributed 1 concept elements to this direction.