[Paper Review] Self-Healing Computation

George Saad, Jared Saia|arXiv (Cornell University)|May 6, 2014

Cryptography and Data Security16 references6 citations

TL;DR

This paper presents a self-healing algorithm for reliable multiparty computation (RC) that maintains asymptotically optimal message and computational costs—O(m + n log n) per computation—while limiting the expected number of corrupted outputs to O(t(log* m)²) under an adversary controlling up to (1/4 − ε)n parties. The approach uses quorum graphs and a detection mechanism to isolate corrupted parties over time, enabling long-term resilience with minimal overhead.

ABSTRACT

In the problem of reliable multiparty computation (RC), there are $n$ parties, each with an individual input, and the parties want to jointly compute a function $f$ over $n$ inputs. The problem is complicated by the fact that an omniscient adversary controls a hidden fraction of the parties. We describe a self-healing algorithm for this problem. In particular, for a fixed function $f$, with $n$ parties and $m$ gates, we describe how to perform RC repeatedly as the inputs to $f$ change. Our algorithm maintains the following properties, even when an adversary controls up to $t \leq (\frac{1}{4} - ε) n$ parties, for any constant $ε>0$. First, our algorithm performs each reliable computation with the following amortized resource costs: $O(m + n \log n)$ messages, $O(m + n \log n)$ computational operations, and $O(\ell)$ latency, where $\ell$ is the depth of the circuit that computes $f$. Second, the expected total number of corruptions is $O(t (\log^{*} m)^2)$, after which the adversarially controlled parties are effectively quarantined so that they cause no more corruptions.

Motivation & Objective

• To design a self-healing algorithm for reliable multiparty computation (RC) that maintains efficiency under persistent Byzantine attacks.
• To minimize the total number of corrupted outputs while keeping amortized communication and computational costs asymptotically optimal.
• To enable long-term resilience by automatically quarantining corrupted parties after a bounded number of corruptions.
• To achieve this under a partially synchronous model with computationally bounded adversaries and unique party IDs.
• To support repeated executions of a function f over changing inputs with minimal reconfiguration.

Proposed method

• The algorithm uses a quorum graph structure where each quorum contains Θ(log n) parties, with at most 1/4 of them being bad, ensuring fault tolerance.
• Each party is part of Θ(log n) quorums, and quorum connectivity allows direct communication between any parties in connected quorums.
• A detection phase, CHECK, uses random sampling to identify corrupted computations with probability at least 1/2 per call.
• When corruption is detected, the UPDATE procedure identifies conflicting pairs of parties across neighboring quorums to mark bad parties.
• The deception DAG model tracks corrupted dependencies and shrinks logarithmically over rounds, ensuring eventual isolation of bad parties.
• Chernoff bounds and probabilistic analysis are used to show that O(log* m) rounds of detection suffice to shrink deception DAGs to zero size with high probability.

Experimental results

Research questions

• RQ1 Can a self-healing algorithm for reliable multiparty computation achieve asymptotically optimal message and computational costs while limiting corruption?
• RQ2 What is the minimum expected number of corruptions achievable under optimal message complexity in the presence of a static Byzantine adversary?
• RQ3 How can corrupted parties be automatically isolated over time without prior knowledge of their identities?
• RQ4 Can the detection mechanism be designed to scale efficiently with circuit depth and gate count?
• RQ5 Is it possible to maintain reliability across repeated executions of a function with dynamic inputs?

Key findings

• The algorithm achieves O(m + n log n) amortized message and computational costs per computation, matching theoretical lower bounds.
• The expected number of corrupted outputs is bounded by O(t(log* m)²), where t is the number of compromised parties.
• After O(t(log* m)²) corruptions, all bad parties are effectively quarantined and no longer affect future computations.
• The latency of each computation is O(ℓ), where ℓ is the depth of the circuit computing f.
• The detection mechanism, CHECK, identifies corruption with probability at least 1/2 per call using random sampling of parties.
• The deception DAG model ensures that corruption propagation shrinks in O(log* m) rounds with high probability, enabling efficient isolation of bad parties.