Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2007.14915

Secure Computation Framework for Multiple Data Providers Against Malicious Adversaries

Zhili Chen, Xin Chen

Published Jul 29, 2020• 1 citation
arXivHTMLPDF

Abstract

Due to the great development of secure multi-party computation, many practical secure computation schemes have been proposed. As an example, different secure auction mechanisms have been widely studied, which can protect bid privacy while satisfying various economic properties. However, as far as we know, none of them solve the secure computation problems for multiple data providers (e.g., secure cloud resource auctions) in the malicious security model. In this paper, we use the techniques of cut-and-choose and garbled circuits to propose a general secure computation framework for multiple data providers against malicious adversaries. Specifically, our framework checks input consistency with the cut-and-choose paradigm, conducts maliciously secure computations by running two independent garbled circuits, and verifies the correctness of output by comparing two versions of outputs. Theoretical analysis shows that our framework is secure against a malicious computation party, or a subset of malicious data providers. Taking secure cloud resource auctions as an example, we implement our framework. Extensive experimental evaluations show that the performance of the proposed framework is acceptable in practice.

DOI
10.48550/arxiv.2007.14915

Related papers

Secure Multi-Party Computation System Against Malicious Adversary based on Circuit Simulation

Junyan Ye, Bangzhou Xin, Jun Han +3 more

In wide area networks, garbled circuit protocols have advantages in enabling distributed privacy computing for multiple participants. However, current representative secure multiparty computing systems based on garbled circuit protocols cannot resist malicious adversary attacks, and the implementation of circuits is relatively complex. To address these issues, this paper uses an extended C language to simulate Boolean circuits and implements the garbled circuit protocol based on the cut-and- choose technique, which can resist malicious adversary attacks. Common variables are represented as oblivious data structures stored in ciphertext. Specific oblivious variable acquisition functions are designed based on the garbled circuit protocol and the oblivious transfer protocol. During the circuit construction and computation process, FreeXOR and half-gate techniques are combined to effectively reduce the communication cost. After testing, the secure multi-party computing system designed and implemented in this paper has less execution time compared to similar systems; it can correctly perform functional computing tasks in multiple application scenarios and performs well.

IEEE International Symposium on Parallel and Distributed Processing with Applications (ISPA)•Oct 10, 2025•0 citations

Cut-and-Choose Based Two-Party Computation in the Online/Offline and Batch Settings.

Yehuda Lindell, Ben Riva

Protocols for secure two-party computation enable a pair of mistrusting parties to compute a joint function of their private inputs without revealing anything but the output. One of the fundamental techniques for obtaining secure computation is that of Yao’s garbled circuits. In the setting of malicious adversaries, where the corrupted party can follow any arbitrary (polynomial-time) strategy in an attempt to breach security, the cut-and-choose technique is used to ensure that the garbled circuit is constructed correctly. The cost of this technique is the construction and transmission of multiple circuits; specifically, s garbled circuits are used in order to obtain a maximum cheating probability of 2−s. In this paper, we show how to reduce the amortized cost of cut-and-choose based secure two-party computation to O s logN garbled circuits when N secure computations are run. We use this method to construct a secure protocol in the batch setting. Next, we show how the cut-

•Jan 1, 2014•0 citations

Garbled Circuits Checking Garbled Circuits: More Efficient and Secure Two-Party Computation.

Payman Mohassel, Ben Riva

Applying cut-and-choose techniques to Yao’s garbled circuit protocol has been a promising approach for designing efficient Two-Party Computation (2PC) with malicious and covert security, as is evident from various optimizations and software implementations in the recent years. We revisit the security and efficiency properties of this popular approach and propose alternative constructions and a new definition that are more suitable for use in practice. • We design an efficient fully-secure 2PC protocol for two-output functions that only requires O(t|C|) symmetric-key operations (with small constant factors, and ignoring factors that are independent of the circuit in use) in the Random Oracle Model, where |C | is the circuit size and t is a statistical security parameter. This is essentially the optimal complexity for protocols based on cut-and-choose, resolving a main question left open by the previous work on the subject. Our protocol utilizes novel techniques for enforcing garbler’s input consistency and handling twooutput functions that are more efficient than all prior solutions. • Motivated by the goal of eliminating the all-or-nothing nature of 2PC with covert security (that privacy and correctness are fully compromised if the adversary is not caught in the challenge phase), we propose a new security definition for 2PC that strengthens the guarantees provided by the standard covert model, and offers a smoother security vs. efficiency tradeoff to protocol designers in choosing the right deterrence factor. In our new notion, correctness is always guaranteed, privacy is fully guaranteed with probability (1 − ɛ), and with probability ɛ (i.e. the event of undetected cheating), privacy is only “partially compromised ” with at most a single bit of information leaked, in case of an abort. We present two efficient 2PC constructions achieving our new notion. Both protocols are competitive with the previous covert 2PC protocols based on cut-and-choose. A distinct feature of the techniques we use in all our constructions is to check consistency of inputs and outputs using new gadgets that are themselves garbled circuits, and to verify validity of these gadgets using multi-stage cut-and-choose openings.

•Jan 1, 2013•0 citations

Efficient Secure Two-Party Computation Against Malicious Adversaries

Chih-Hao Shen

Secure 2PC (Two-Party Computation) is a research problem that abstracts a wide class of realworld applications with privacy concerns.In this problem, two parties want to collaboratively compute an objective function over their private inputs while the inputs are too valuable or sensitive to share with each other.For example, competing insurance companies may be interested in finding out the statistics of their aggregated client database but reluctant to reveal their own databases; drivers on the road may want to query the nearest gas station but hesitate to disclose their GPS coordinates.In this thesis, we constructed a framework for secure 2PC.This framework consists of a two-party interactive protocol and a few cryptographic building blocks.More specifically, the former comes from applying the cut-and-choose technique to the Yao protocol with the support of the latter, which are formally defined to capture the security properties needed in order to tackle the known attacks.We first proved that the main protocol indeed securely computes any single-output objective function even in the presence of malicious adversaries.Next, to demonstrate the power of this framework, we explicitly instantiated the building blocks by using number-theoretic assumptions and the technique of auxiliary circuits.We also presented techniques that allow our framework to handle from any single-output to any two-output objective functions.Finally, we implemented the framework to demonstrate its performance empirically.In particular, this implementation benefits from the embarrassingly parallelizable nature of our framework.

•Jul 30, 2013•0 citations

Faster Maliciously Secure Two-Party Computation Using the GPU Full version

Tore Kasper Frederiksen, Thomas Pelle Jakobsen, Jesper Buus Nielsen

Abstract We present a new protocol for maliciously secure two-party computation based on cut-and-choose of garbled circuits using the recent idea of “forge-and-loose”, which eliminates around a factor 3 of garbled circuits that needs to be constructed and evaluated. Our protocol introduces a new way to realize the “forge-and-loose” approach, which avoids an auxiliary secure two-party computation protocol, does not rely on any number theoretic assumptions and parallelizes well in a same instruction, multiple data (SIMD) framework. With this approach we prove our protocol universally composable-secure against a malicious adversary assuming access to oblivious transfer, commitment and coin-tossing functionalities in the random oracle model. Finally, we construct, and benchmark, a SIMD implementation of this protocol using a GPU as a massive SIMD device. The findings compare favorably with all previous implementations of maliciously secure, two-party com-putation. 1

•Jan 1, 2014•0 citations

Amortizing Garbled Circuits

Yan Huang, Jonathan I. Katz, Vladimir Kolesnikov +2 more

Abstract. We consider secure two-party computation in a multiple-execution setting, where two parties wish to securely evaluate the same circuit multiple times. We design efficient garbled-circuit-based two-party protocols secure against malicious adversaries. Recent works by Lindell (Crypto 2013) and Huang-Katz-Evans (Crypto 2013) have obtained op-timal complexity for cut-and-choose performed over garbled circuits in the single execution setting. We show that it is possible to obtain much lower amortized overhead for cut-and-choose in the multiple-execution setting. Our efficiency improvements result from a novel way to combine a recent technique of Lindell (Crypto 2013) with LEGO-based cut-and-choose techniques (TCC 2009, Eurocrypt 2013). In concrete terms, for 40-bit statistical security we obtain a 2 × improvement (per execution) in com-munication and computation for as few as 7 executions, and require only 8 garbled circuits (i.e., a 5 × improvement) per execution for as low as 3500 executions. Our results suggest the exciting possibility that secure two-party computation in the malicious setting can be less than an order of magnitude more expensive than in the semi-honest setting. 1

Lecture notes in computer science•Aug 17, 2014•2 citations
Due to the great development of secure multi-party computation, many practical secure computation schemes have been proposed. As an example, different secure auction mechanisms have been widely studied, which can protect bid privacy while satisfying various economic properties. However, as far as we know, none of them solve the secure computation problems for multiple data providers (e.g., secure cloud resource auctions) in the malicious security model. In this paper, we use the techniques of cut-and-choose and garbled circuits to propose a general secure computation framework for multiple data providers against malicious adversaries. Specifically, our framework checks input consistency with the cut-and-choose paradigm, conducts maliciously secure computations by running two independent garbled circuits, and verifies the correctness of output by comparing two versions of outputs. Theoretical analysis shows that our framework is secure against a malicious computation party, or a subset of malicious data providers. Taking secure cloud resource auctions as an example, we implement our framework. Extensive experimental evaluations show that the performance of the proposed framework is acceptable in practice.
In wide area networks, garbled circuit protocols have advantages in enabling distributed privacy computing for multiple participants. However, current representative secure multiparty computing systems based on garbled circuit protocols cannot resist malicious adversary attacks, and the implementation of circuits is relatively complex. To address these issues, this paper uses an extended C language to simulate Boolean circuits and implements the garbled circuit protocol based on the cut-and- choose technique, which can resist malicious adversary attacks. Common variables are represented as oblivious data structures stored in ciphertext. Specific oblivious variable acquisition functions are designed based on the garbled circuit protocol and the oblivious transfer protocol. During the circuit construction and computation process, FreeXOR and half-gate techniques are combined to effectively reduce the communication cost. After testing, the secure multi-party computing system designed and implemented in this paper has less execution time compared to similar systems; it can correctly perform functional computing tasks in multiple application scenarios and performs well.
Protocols for secure two-party computation enable a pair of mistrusting parties to compute a joint function of their private inputs without revealing anything but the output. One of the fundamental techniques for obtaining secure computation is that of Yao’s garbled circuits. In the setting of malicious adversaries, where the corrupted party can follow any arbitrary (polynomial-time) strategy in an attempt to breach security, the cut-and-choose technique is used to ensure that the garbled circuit is constructed correctly. The cost of this technique is the construction and transmission of multiple circuits; specifically, s garbled circuits are used in order to obtain a maximum cheating probability of 2−s. In this paper, we show how to reduce the amortized cost of cut-and-choose based secure two-party computation to O s logN garbled circuits when N secure computations are run. We use this method to construct a secure protocol in the batch setting. Next, we show how the cut-
Applying cut-and-choose techniques to Yao’s garbled circuit protocol has been a promising approach for designing efficient Two-Party Computation (2PC) with malicious and covert security, as is evident from various optimizations and software implementations in the recent years. We revisit the security and efficiency properties of this popular approach and propose alternative constructions and a new definition that are more suitable for use in practice. • We design an efficient fully-secure 2PC protocol for two-output functions that only requires O(t|C|) symmetric-key operations (with small constant factors, and ignoring factors that are independent of the circuit in use) in the Random Oracle Model, where |C | is the circuit size and t is a statistical security parameter. This is essentially the optimal complexity for protocols based on cut-and-choose, resolving a main question left open by the previous work on the subject. Our protocol utilizes novel techniques for enforcing garbler’s input consistency and handling twooutput functions that are more efficient than all prior solutions. • Motivated by the goal of eliminating the all-or-nothing nature of 2PC with covert security (that privacy and correctness are fully compromised if the adversary is not caught in the challenge phase), we propose a new security definition for 2PC that strengthens the guarantees provided by the standard covert model, and offers a smoother security vs. efficiency tradeoff to protocol designers in choosing the right deterrence factor. In our new notion, correctness is always guaranteed, privacy is fully guaranteed with probability (1 − ɛ), and with probability ɛ (i.e. the event of undetected cheating), privacy is only “partially compromised ” with at most a single bit of information leaked, in case of an abort. We present two efficient 2PC constructions achieving our new notion. Both protocols are competitive with the previous covert 2PC protocols based on cut-and-choose. A distinct feature of the techniques we use in all our constructions is to check consistency of inputs and outputs using new gadgets that are themselves garbled circuits, and to verify validity of these gadgets using multi-stage cut-and-choose openings.
Secure 2PC (Two-Party Computation) is a research problem that abstracts a wide class of realworld applications with privacy concerns.In this problem, two parties want to collaboratively compute an objective function over their private inputs while the inputs are too valuable or sensitive to share with each other.For example, competing insurance companies may be interested in finding out the statistics of their aggregated client database but reluctant to reveal their own databases; drivers on the road may want to query the nearest gas station but hesitate to disclose their GPS coordinates.In this thesis, we constructed a framework for secure 2PC.This framework consists of a two-party interactive protocol and a few cryptographic building blocks.More specifically, the former comes from applying the cut-and-choose technique to the Yao protocol with the support of the latter, which are formally defined to capture the security properties needed in order to tackle the known attacks.We first proved that the main protocol indeed securely computes any single-output objective function even in the presence of malicious adversaries.Next, to demonstrate the power of this framework, we explicitly instantiated the building blocks by using number-theoretic assumptions and the technique of auxiliary circuits.We also presented techniques that allow our framework to handle from any single-output to any two-output objective functions.Finally, we implemented the framework to demonstrate its performance empirically.In particular, this implementation benefits from the embarrassingly parallelizable nature of our framework.
Abstract We present a new protocol for maliciously secure two-party computation based on cut-and-choose of garbled circuits using the recent idea of “forge-and-loose”, which eliminates around a factor 3 of garbled circuits that needs to be constructed and evaluated. Our protocol introduces a new way to realize the “forge-and-loose” approach, which avoids an auxiliary secure two-party computation protocol, does not rely on any number theoretic assumptions and parallelizes well in a same instruction, multiple data (SIMD) framework. With this approach we prove our protocol universally composable-secure against a malicious adversary assuming access to oblivious transfer, commitment and coin-tossing functionalities in the random oracle model. Finally, we construct, and benchmark, a SIMD implementation of this protocol using a GPU as a massive SIMD device. The findings compare favorably with all previous implementations of maliciously secure, two-party com-putation. 1
Abstract. We consider secure two-party computation in a multiple-execution setting, where two parties wish to securely evaluate the same circuit multiple times. We design efficient garbled-circuit-based two-party protocols secure against malicious adversaries. Recent works by Lindell (Crypto 2013) and Huang-Katz-Evans (Crypto 2013) have obtained op-timal complexity for cut-and-choose performed over garbled circuits in the single execution setting. We show that it is possible to obtain much lower amortized overhead for cut-and-choose in the multiple-execution setting. Our efficiency improvements result from a novel way to combine a recent technique of Lindell (Crypto 2013) with LEGO-based cut-and-choose techniques (TCC 2009, Eurocrypt 2013). In concrete terms, for 40-bit statistical security we obtain a 2 × improvement (per execution) in com-munication and computation for as few as 7 executions, and require only 8 garbled circuits (i.e., a 5 × improvement) per execution for as low as 3500 executions. Our results suggest the exciting possibility that secure two-party computation in the malicious setting can be less than an order of magnitude more expensive than in the semi-honest setting. 1