Secure Multiparty Computation (MPC)

• Secure Multiparty Computation (MPC) is a cryptographic method enabling distrustful parties to jointly compute a function while keeping their inputs private.
• It leverages techniques such as secret sharing, garbled circuits, and Beaver triples to ensure security against both semi-honest and malicious adversaries.
• Recent advances focus on scalability, load-balanced circuit partitioning, and quantum-resistant protocols, making MPC applicable in big data analytics and financial services.

Secure Multiparty Computation (MPC) is a foundational cryptographic paradigm enabling mutually distrustful parties to jointly compute a function over their private inputs, revealing nothing beyond the specified output. The field encompasses a wide range of protocols, security models, and practical instantiations, ranging from the classical theoretical constructions to modern scalable frameworks addressing cloud, big data, and heterogeneous environments.

1. Foundations and Security Definitions

In the standard MPC setting, $n$ parties $P_1, \ldots, P_n$ each hold a private input $x_i$ from some domain $\mathcal X$, and jointly compute $y = f(x_1, \ldots, x_n)$, for some agreed-upon function $f:\mathcal X^n \to \mathcal Y$, such that no party learns anything beyond what is implied by their own input and the public output. Security is formalized via the ideal/real-world simulation paradigm: for any real-world adversary attacking the protocol, there exists a simulator in the ideal world (where a trusted party simply computes $f$) such that no distinguisher can tell these executions apart, up to computational or information-theoretic indistinguishability (Sedraoui et al., 1 Jan 2026).

Adversary models include:

• Semi-honest (passive): Corrupted parties follow the protocol but seek additional information from protocol transcripts.
• Malicious (active): Corrupted parties may deviate arbitrarily.

Correctness guarantees require that honest parties obtain the correct output except with negligible (or zero, for perfectly secure MPC) probability.

2. Core Protocols and Secret-Sharing Primitives

The design space of MPC protocols is largely organized around secret sharing and garbled-circuit techniques:

• Shamir secret sharing [Sha79]: A dealer holding $s\in\mathbb{F}_p$ selects a random degree-$t$ polynomial $P(x)$ with $P_1, \ldots, P_n$0; each party $P_1, \ldots, P_n$1 receives $P_1, \ldots, P_n$2. Reconstruction from $P_1, \ldots, P_n$3 shares via Lagrange interpolation.
• Additive secret sharing: $P_1, \ldots, P_n$4, with each $P_1, \ldots, P_n$5 uniformly random conditioned on the sum (threshold $P_1, \ldots, P_n$6).
• Yao's garbled circuits: For 2-party computation using Boolean circuits, with oblivious transfer for initial label distribution.
• Beaver triples [SPDZ]: Random $P_1, \ldots, P_n$7 shared and used for secure multiplication, allowing the bulk of the crypto work in an offline phase.

Other important building blocks include replicating secret sharing for honest-majority settings and oblivious transfer (OT), with efficient OT extension for scaling.

3. System Architectures and Execution Workflows

Practical MPC frameworks such as ABY, Conclave, SPDZ, and their derivatives implement these cryptographic primitives in distinct system architectures.

• ABY (Ni et al., 2020): Implements arithmetic, Boolean, and Yao sharing for 2-party, semi-honest computation. Focused on layered circuit processing, with local (CPU-bound) evaluation of addition/XOR gates and synchronized (network-bound) rounds for multiplication/AND. For arithmetic sharing, each $P_1, \ldots, P_n$8-bit input $P_1, \ldots, P_n$9 is secret-shared as $x_i$0 such that $x_i$1.
• Conclave (Volgushev et al., 2019): Query compiler for relational analytics on big data, partitioning queries into cleartext and MPC fragments. Incorporates hybrid MPC–cleartext operators, with trust-annotated data columns to optimize join and aggregation at a trusted party, reducing MPC load by orders of magnitude.
• SPDZ (Chen et al., 2019): Malicious-secure, dishonest-majority framework using arithmetic circuits, Beaver triple preprocessing, and MAC authentication of all shares. Online phase is reduced to one broadcast per multiplication gate.
• Scalable asynchronous MPC (Dani et al., 2013, Dani et al., 2012): Utilizes quorums (small groups of polylog($x_i$2) parties with honest majority) to reduce per-party communication and computational load to $x_i$3 for an $x_i$4-gate circuit, even in the presence of Byzantine adversaries and asynchrony.
• Quantum-safe protocols (Mohanty et al., 2023): Address post-quantum threats by constructing information-theoretic, quantum-UC secure building blocks (e.g. qOLE) leveraging quantum one-time pads and decoy qubit detection.

4. Performance, Scalability, and System Bottlenecks

Performance evaluation in MPC systems exhibits distinct characteristics, especially as input size increases or in heterogeneous/cloud deployments (Ni et al., 2020, Volgushev et al., 2019, Sedraoui et al., 1 Jan 2026):

• Bottlenecks: In ABY, for small-scale tasks (e.g., inner product of length $x_i$5), network stalls dominate ($x_i$6 of online time). For large-scale tasks ($x_i$7), local computation dominates and network overhead falls to $x_i$8, except in heterogeneous settings where faster nodes wait for slower ones, causing exponential degradation.
• Throughput degradation: In a case study (Xeon↔Atom, inner product size $x_i$9), the fast node’s online time increased from $\mathcal X$0 ms to $\mathcal X$1 ms, with communication wait time rising to $\mathcal X$2 of the total, and total throughput collapsing to $\mathcal X$3 of the homogeneous baseline.
• Strategy alignment: Load-balanced circuit partitioning, overlapping computation and communication, and dynamic protocol adaptation are critical for high performance in practical deployments.
• Big data MPC: Conclave’s hybrid query engine (Volgushev et al., 2019) demonstrates 3–6 orders of magnitude scalability improvement over pure MPC by moving the MPC "frontier" to minimal critical sections, with explicit authorization of any trusted-party leaks via annotations.

5. Applications and Domain-Specific Use Cases

MPC's application space includes, but is not limited to:

• Financial services (Sedraoui et al., 1 Jan 2026): Privacy-preserving analytics (risk management, credit scoring, fraud detection). Typical ML tasks involve arithmetic circuits with $\mathcal X$4 gates, high-throughput requirements, and strict regulatory constraints.
• Machine learning: Private linear/logistic regression (SPDZ (Chen et al., 2019)), secure feature selection (MPC-based Gini impurity (Li et al., 2021)), and DP model training with MPC output perturbation (Pentyala et al., 2022); see Table:

Task	Protocol/backend	Security	Scale/performance
Linear regression	SPDZ	Malicious	$\mathcal X$5: few sec (LAN)
Feature selection	3PC/4PC sharing	Semi/active	$\mathcal X$6: $\mathcal X$7s
DP logistic reg	SPDZ2k/3PC	Semi/malicious	$\mathcal X$8: $\mathcal X$9–$y = f(x_1, \ldots, x_n)$0ks

• Secure big data analytics: Joins and aggregations over $y = f(x_1, \ldots, x_n)$1 records via hybrid MPC–cleartext operators, e.g., market concentration analysis, credit regulation (Volgushev et al., 2019).
• Anonymous MPC: Frameworks for authorized-but-anonymous participation use Tor, blind signatures, and threshold cryptosystems to ensure participation privacy and auditability (Breuer et al., 2021).

6. Advancements: Asynchronous, Post-Quantum, and Robust Variants

Recent research targets both stronger security guarantees and new deployment paradigms:

• Best-of-both-worlds secure MPC (Appan et al., 2022): Achieves perfect security in either synchronous ($y = f(x_1, \ldots, x_n)$2) or asynchronous ($y = f(x_1, \ldots, x_n)$3) networks without having to predetermine the network model. The protocol relies on innovative Byzantine agreement and verifiable secret sharing primitives, secure under $y = f(x_1, \ldots, x_n)$4.
• Quantum-resistant MPC (Mohanty et al., 2023): Protocols such as qOLE provide information-theoretic security against quantum adversaries by one-time padding quantum messages and using decoy qubits to detect tampering.
• Coded MPC for massive matrices (Nodehi et al., 2019, Najarkolaei et al., 2020): Reduces worker requirements via polynomial sharing and efficient subroutines for addition, multiplication, and transpose, achieving order-wise lower recovery thresholds ($y = f(x_1, \ldots, x_n)$5 rather than $y = f(x_1, \ldots, x_n)$6).
• Robust MPC with identifiability and guaranteed output delivery (Wang et al., 31 May 2025): Via lattice-based commitments and a semi-honest TTP for recovery, this approach attains robustness and public verifiability in dishonest-majority scenarios, at a modest overhead compared to SPDZ.

7. Limitations, Open Challenges, and Research Directions

Despite advances, state-of-the-art MPC systems contend with several fundamental and engineering obstacles:

• Scalability bottlenecks: Communication and computation scale poorly for complex gates (mult/AND) and deep circuits. Even in best asynchronous protocols, per-party work is $y = f(x_1, \ldots, x_n)$7 (Dani et al., 2013, Dani et al., 2012).
• Malicious security overheads: Active-secure protocols (SPDZ, RV-MPC) require extra rounds, MAC authentication, and zero-knowledge checks, often trading off communication for stronger guarantees.
• Semi-honest limitations: Many efficient systems (Conclave, ABY) provide only simulation-based security against semi-honest adversaries and lack mechanisms for fairness or guaranteed output delivery.
• Protocol composability: Classical multiplication-based MPC is challenging to compose for high-degree polynomials or deep circuits without communication overhead; methods such as FMPC (Sonnino, 2019) offer sublinear-latency only for low-depth circuits.
• Anonymity and access control: Emerging applications in regulated or privacy-sensitive domains demand frameworks blending secure computation with anonymity-preserving access and participation authorization, still a research area (Breuer et al., 2021).
• Quantum security: Post-quantum MPC is a nascent subfield, with only a few constructions (quantum-safe OLE, MPSI) with scalable implementations (Mohanty et al., 2023).
• Programming usability: Metaprogramming toolchains such as HACCLE (Bao et al., 2020) and DSLs like Symphony (Sweet et al., 2023) significantly lower the barrier to MPC adoption yet do not fully support dynamic loops, data-dependent control, or advanced protocol selection.

Ongoing research seeks constant-round protocols for arithmetic circuits, better practical frameworks for robust asynchronous MPC, deeper integration with privacy-enhancing technologies such as differential privacy and federated learning, and efficient post-quantum cryptographic primitives. Open problems include optimal asynchronous resilience, lower bounds for adaptive adversaries, and practical dynamic circuit compilation and resource-aware backend selection (Appan et al., 2022, Bao et al., 2020, Nodehi et al., 2019).