Secure Multi-Party Computation

The foundational property of SMPC: no party learns anything about another party's private input beyond what can be inferred from the agreed-upon output. This is achieved through cryptographic secret sharing, where each data provider splits their sensitive patient records into mathematically meaningless shares distributed across multiple compute nodes. Even if an adversary compromises a subset of nodes, the original data remains information-theoretically or computationally hidden. This guarantee holds against passive adversaries (honest-but-curious nodes that follow the protocol but attempt to learn extra information) and, in stronger variants, against active adversaries that deviate arbitrarily from the protocol.

SMPC protocols guarantee that the computed output is mathematically correct—as if a trusted third party had performed the computation on the pooled plaintext data. This property holds even when some participating nodes are malicious. Key mechanisms include:

• Verifiable secret sharing: Nodes can prove their shares are consistent without revealing them
• Consensus checks: Multiple compute parties perform identical operations and compare results
• Circuit verification: The agreed-upon function is encoded as an arithmetic or Boolean circuit, and every gate evaluation is cryptographically verified

In healthcare federated learning, correctness ensures that the aggregated gradient update or model parameter is the exact weighted average of all local contributions, not a corrupted value.

SMPC protocols enforce output delivery fairness: either all parties receive the computation result, or none do. This prevents a malicious party from aborting the protocol after learning the output while denying it to honest participants. In practice:

• Graduated release: Output is reconstructed incrementally, requiring threshold agreement
• Commitment schemes: Parties cryptographically commit to their inputs before seeing others' data
• Penalty mechanisms: Blockchain-based SMPC variants can financially penalize aborting parties

For clinical research consortia, fairness ensures that no hospital can withdraw after seeing preliminary results that might disadvantage their publication or patent position.

The cryptographic engine underlying most practical SMPC implementations. Shamir's Secret Sharing splits a private value into n shares distributed to n parties, such that any t shares can reconstruct the original value, but t-1 shares reveal nothing. Key properties:

• Additive homomorphism: Shares can be added locally without communication, enabling efficient secure aggregation
• Threshold flexibility: The t-of-n threshold can be tuned to balance security against node availability
• Proactive refresh: Shares can be periodically re-randomized without changing the underlying secret, limiting the window for attackers to accumulate shares

Modern variants like replicated secret sharing optimize for the three-party setting common in healthcare SMPC deployments, dramatically reducing communication overhead.

A foundational SMPC technique for secure two-party computation, extended to multi-party settings. One party (the garbler) encrypts a Boolean circuit representing the function to be computed, creating a garbled version where each wire has two encrypted labels (one for 0, one for 1). The other party (the evaluator) obliviously evaluates the circuit using oblivious transfer to obtain input labels without revealing which inputs were selected.

• Constant-round complexity: Evaluation requires a fixed number of communication rounds regardless of circuit depth
• XOR optimization: Free-XOR technique eliminates cryptographic operations for XOR gates
• Half-gates: Reduces garbled gate size by 50%, making the protocol practical for complex functions

In healthcare, garbled circuits excel at secure comparison operations—such as determining if a patient meets trial eligibility criteria without revealing their exact lab values.

An alternative to Boolean-circuit SMPC that operates directly on integers and fixed-point numbers within a finite field. This approach is particularly efficient for the linear operations dominating machine learning workloads:

• Matrix multiplications: Local shares are multiplied and re-shared in a single communication round
• Dot products: Vector operations require minimal inter-party communication
• Addition: Completely free—parties add shares locally without any network interaction

Non-linear operations like ReLU activations and division require conversion to Boolean sharing or specialized comparison protocols. The SPDZ family of protocols (including MASCOT and Overdrive) provides actively secure arithmetic SMPC with preprocessing phases that shift heavy cryptography offline, enabling online phases fast enough for production federated learning.