Secure Multi-Party Computation with Security Modules

We consider the problem of secure multi-party computation (SMC) in a new model where individual processes contain a tamper-proof security module. Security modules can be trusted by other processes and can establish secure channels between each other. However, their availability is restricted by their host, i.e., a corrupted party can stop the computation of its own security module as well as drop any message sent by or to its security module. In this model we show that SMC is solvable if and only if a majority of processes is correct. We prove this by relating SMC to the problem of Uniform Interactive Consistency among security modules (a variant of the Byzantine Generals Problem from the area of fault-tolerance). The obtained solutions to SMC for the first time allow to compute any function securely with a complexity which is polynomial only in the number of processes (i.e., the complexity does not depend on the function which is computed). We conclude that adding secure hardware does not improve the resilience of SMC but can effectively improve the efficiency.

[1]  Fred B. Schneider,et al.  Implementing fault-tolerant services using the state machine approach: a tutorial , 1990, CSUR.

[2]  Shafi Goldwasser,et al.  Multi party computations: past and present , 1997, PODC '97.

[3]  John McLean,et al.  A General Theory of Composition for a Class of "Possibilistic'' Properties , 1996, IEEE Trans. Software Eng..

[4]  Ueli Maurer,et al.  Robustness for Free in Unconditional Multi-party Computation , 2001, CRYPTO.

[5]  Ueli Maurer,et al.  Efficient Secure Multi-party Computation , 2000, ASIACRYPT.

[6]  Andrew Chi-Chih Yao,et al.  Protocols for Secure Computations (Extended Abstract) , 1982, FOCS.

[7]  Yehuda Lindell Composition of Secure Multi-Party Protocols: A Comprehensive Study , 2003 .

[8]  Leslie Lamport,et al.  The Byzantine Generals Problem , 1982, TOPL.

[9]  Marko Vukolic,et al.  Gracefully Degrading Fair Exchange with Security Modules , 2005, EDCC.

[10]  Ran Canetti,et al.  Asynchronous secure computation , 1993, STOC.

[11]  Andrew Chi-Chih Yao,et al.  Protocols for secure computations , 1982, FOCS 1982.

[12]  David Chaum,et al.  Multiparty unconditionally secure protocols , 1988, STOC '88.

[13]  Ueli Maurer,et al.  Secure multi-party computation made simple , 2002, Discret. Appl. Math..

[14]  Andreas Pfitzmann,et al.  Anonymity, Unobservability, and Pseudonymity - A Proposal for Terminology , 2000, Workshop on Design Issues in Anonymity and Unobservability.

[15]  Leslie Lamport,et al.  Reaching Agreement in the Presence of Faults , 1980, JACM.

[16]  Avi Wigderson,et al.  Completeness theorems for non-cryptographic fault-tolerant distributed computation , 1988, STOC '88.

[17]  Rafail Ostrovsky,et al.  Minimal Complete Primitives for Secure Multi-Party Computation , 2001, Journal of Cryptology.

[18]  Alfred Menezes,et al.  Handbook of Applied Cryptography , 2018 .

[19]  Rennes Cedex,et al.  Uniform Agreement Despite Process Omission Failures , 2003 .

[20]  Michel Raynal,et al.  Uniform agreement despite process omission failures , 2003, Proceedings International Parallel and Distributed Processing Symposium.

[21]  Sam Toueg,et al.  Distributed agreement in the presence of processor and communication faults , 1986, IEEE Transactions on Software Engineering.

[22]  Sean W. Smith,et al.  Building the IBM 4758 Secure Coprocessor , 2001, Computer.