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

ACM SIGSAC Conference on Computer and Communications Security (CCS)

2PC Memory-Manipulating Programs with Constant Overhead

David Heath

Published Nov 12, 2026• 0 citations
Publisher

Abstract

General-purpose secure multiparty computation (MPC) remains bottlenecked in large part by a lack of efficient techniques for handling memory access. We demonstrate a remarkably simple and efficient 2PC instantiation of random access memory (RAM), based on distributed point functions (DPFs, Gilboa and Ishai, Eurocrypt'14). Our semi-honest 2PC protocol can be achieved from oblivious transfer (OT) and a black-box pseudorandom generator (PRG). For a memory storing large enough data words, our 2PC RAM incurs constant communication overhead per access. Like prior works using DPFs to achieve memory access, our work incurs linear computation per access, but per-access communication is lean. Our 2PC RAM is built on top of an obliviousness-friendly model of computation called the single access machine model (SAM, Appan et al., CCS'24). In the SAM model, each memory slot can be read at most once. We present a simple 2PC SAM protocol, where each single-access memory operation incurs at most O(w + λ lg n) bits of communication, where w is the word size, n is the number of memory words, and ?ambda is a security parameter. Of this cost, only 2w + 2lg n bits are incurred in the online phase. There are now many oblivious algorithms that compile directly to SAM more efficiently than via a compilation to RAM, and our 2PC SAM can instantiate these algorithms. As one example, we can use our 2PC SAM to implement privacy-preserving graph traversal (DFS or BFS) over a secret-shared size- n graph while revealing nothing beyond the runtime of the SAM program. Our construction achieves online communication O(n lg n) bits, asymptotically matching the number of bits touched in a corresponding cleartext graph traversal.

DOI
10.1145/3830454.3832698

Related papers

Efficient Actively Secure DPF and RAM-based 2PC with One-Bit Leakage

Wenhao Zhang, Xiaojie Guo, Kang Yang +3 more

Secure two-party computation (2PC) in the RAM model has attracted huge attention in recent years. Most existing results only support semi-honest security, with the exception of Keller and Yanai (Eurocrypt 2018) with very high cost. In this paper, we propose an efficient RAM-based 2PC protocol with active security and one-bit leakage.1)We propose an actively secure protocol for distributed point function (DPF), with one-bit leakage, that is essentially as efficient as the state-of-the-art semi-honest protocol. Compared with previous work, our protocol takes about 50× less communication for a domain with 220entries, and no longer requires actively secure generic 2PC.2)We extend the dual-execution protocol to allow reactive computation, and then build a RAM-based 2PC protocol with active security on top of our new building blocks. The protocol follows the paradigm of Doerner and shelat (CCS 2017). We are able to prove that the protocol has end-to-end one-bit leakage.3)Our implementation shows that our protocol is almost as efficient as the state-of-the-art semi-honest RAM-based 2PC protocol, and is at least two orders of magnitude faster than prior actively secure RAM-based 2PC without leakage, providing a realistic trade-off in practice.

IEEE Symposium on Security and Privacy (S&P)•May 19, 2024•8 citations

Efficient Actively Secure Multi-Party Computation for RAM Programs

Kun Xiong, Wenfang Zhang, Muhammad Khurram Khan

Cloud platforms offer innovative solutions for data processing, and privacy concerns arising from this can be addressed through secure multi-party computation (MPC). MPC in the random access machine (RAM) model leverages Oblivious RAM (ORAM) to conceal memory access patterns, rendering it more suitable for data storage and aggregation in cloud environments, where cloud servers can infer user privacy based on observed access patterns. However, most existing RAM-based MPC protocols only ensure semi-honest security; the few actively secure alternatives have limitations in efficiency or input leakage. To address this gap, this paper proposes an efficient active-secure RAM-based MPC protocol without input leakage. Specifically, we first present a new actively secure, reactive MPC protocol with communication of 2(n−1) bits per gate. As the building blocks, we design the (i) multi-party distributed BitGC garbling scheme and (ii) multi-party somewhat homomorphic encryption (SWHE) scheme with distributed decryption. In particular, we then build a RAM-based MPC protocol on top of the above new building blocks with Circuit ORAM and present the check mechanism to achieve secure memory accesses. The implementation shows that our protocol outperforms the prior actively secure RAM-based MPC without leakage by one to two orders of magnitude in both LAN and WAN networks. Compared with the state-of-the-art actively secure RAM-based 2PC with one bit leakage, ours is slightly less efficient in most cases (not all), but supports the multi-party setting and offers a superior alternative for highly confidential environments.

IEEE Transactions on Cloud Computing•Jan 1, 2026•0 citations

How to Efficiently Evaluate RAM Programs with Malicious Security.

Arash Afshar, Zhangxiang Hu, Payman Mohassel +1 more

Secure 2-party computation (2PC) is becoming practical for some applications. However, most ap-proaches are limited by the fact that the desired functionality must be represented as a boolean circuit. In response, random-access machines (RAM programs) have recently been investigated as a promising alternative representation. In this work, we present the first practical protocols for evaluating RAM programs with security against malicious adversaries. A useful efficiency measure is to divide the cost of malicious-secure evalu-ation of f by the cost of semi-honest-secure evaluation of f. Our RAM protocols achieve ratios matching the state of the art for circuit-based 2PC. For statistical security 2−s, our protocol without preprocessing achieves a ratio of s; our online-offline protocol has a pre-processing phase and achieves online ratio ∼ 2s / log T, where T is the total execution time of the RAM program. To summarize, our solutions show that the “extra overhead ” of obtaining malicious security for RAM programs (beyond what is needed for circuits) is minimal and does not grow with the running time of the program. 1

•Jan 1, 2014•2 citations

A Secure Priority Queue; Or: On Secure Datastructures from Multiparty Computation

Tomas Toft

Secure multiparty computation (MPC) – computation on distributed, private inputs – has been studied for thirty years. This includes “one shot” applications as well as reactive tasks, where the exact computation is not known in advance. We extend this line of work by exploring efficient datastructures based on MPC primitives. The oblivious RAM (ORAM) provides a completeness theorem. However, implementing the ORAM-CPU using MPC-primitives is costly; current IT-secure constructions incur a poly-log overhead on computation and memory, while computationally secure constructions require MPC-evaluation of one-way functions, which introduces considerable overhead. Using ideas radically different from those in ORAM’s, we propose a secure priority queue. Data accesses are deterministic, whereas ORAM’s hide the access pattern through randomization. $$n$$ priority queue operations – insertion and deletion of the minimal element – require $$O(n\log ^2 n)$$ invocations of the cryptographic primitives in $$O(n)$$ rounds. The amortized cost of each operation is low, thus demonstrating feasibility.

Lecture notes in computer science•Jan 1, 2014•3 citations

On the Power of Secure Two-Party Computation.

Carmit Hazay, Muthuramakrishnan Venkitasubramaniam

Ishai, Kushilevitz, Ostrovsky and Sahai (STOC 2007, SIAM JoC 2009) introduced the powerful “MPC-in-the-head” technique that provided a general transformation of information-theoretic MPC protocols secure against passive adversaries to a ZK proof in a “black-box” way. In this work, we extend this technique and provide a generic transformation of any semi-honest secure two-party computation (2PC) protocol (with mild adaptive security guarantees) in the so called oblivious-transfer hybrid model to an adaptive ZK proof for any NP-language, in a “black-box” way assuming only one-way functions. Our basic construction based on Goldreich-Micali-Wigderson’s 2PC protocol yields an adaptive ZK proof with communication complexity proportional to quadratic in the size of the circuit implementing the NP relation. Previously such proofs relied on an expensive Karp reduction of the NP language to Graph Hamiltonicity (Lindell and Zarosim (TCC 2009, Journal of Cryptology 2011)). We also improve our basic construction to obtain the first linear-rate adaptive ZK proofs by relying on efficient maliciously secure 2PC protocols. Core to this construction is a new way of transforming 2PC protocols to efficient (adaptively secure) instance-dependent commitment schemes. As our second contribution, we provide a general transformation to construct a randomized encoding of a function f from any 2PC protocol that securely computes a related functionality (in a black-box way). We show that if the 2PC protocol has mild adaptive security guarantees then the resulting randomized encoding (RE) can be decomposed to an offline/online encoding. As an application of our techniques, we show how to improve the construction of Lapidot and Shamir (Crypto 1990) to obtain “input-delayed” ZK proofs which are proofs where the honest prover’s algorithm does not require the actual statement until the last round. An interesting corollary we obtain using these proofs are first constructions of a 4-round non-malleable commitments scheme based on oneway permutations where the underlying one-way permutation is used in a black-box way. Previous constructions either required more number of rounds or made non-black-box usage of the underlying primitives.

•Jan 1, 2016•0 citations

Efficient, Oblivious Data Structures for MPC.

Marcel Keller, Peter Schöll

Abstract. We present oblivious implementations of several data structures for secure multiparty com-putation (MPC) such as arrays, dictionaries, and priority queues. The resulting oblivious data structures have only polylogarithmic overhead compared with their classical counterparts. To achieve this, we give secure multiparty protocols for the ORAM of Shi et al. (Asiacrypt ‘11) and the Path ORAM scheme of Stefanov et al. (CCS ‘13), and we compare the resulting implementations. We subsequently use our oblivious priority queue for secure computation of Dijkstra’s shortest path algorithm on general graphs, where the graph structure is secret. To the best of our knowledge, this is the first implementation of a non-trivial graph algorithm in multiparty computation with polylogarithmic overhead. We implemented and benchmarked all of our protocols using the SPDZ protocol of Damg̊ard et al. (Crypto ‘12), which works in the preprocessing model and ensures active security against an adversary corrupting all but one players. For two parties, the online access time for an oblivious array of size 1 million is under 250 ms.

•Jan 1, 2014•0 citations
General-purpose secure multiparty computation (MPC) remains bottlenecked in large part by a lack of efficient techniques for handling memory access. We demonstrate a remarkably simple and efficient 2PC instantiation of random access memory (RAM), based on distributed point functions (DPFs, Gilboa and Ishai, Eurocrypt'14). Our semi-honest 2PC protocol can be achieved from oblivious transfer (OT) and a black-box pseudorandom generator (PRG). For a memory storing large enough data words, our 2PC RAM incurs constant communication overhead per access. Like prior works using DPFs to achieve memory access, our work incurs linear computation per access, but per-access communication is lean. Our 2PC RAM is built on top of an obliviousness-friendly model of computation called the single access machine model (SAM, Appan et al., CCS'24). In the SAM model, each memory slot can be read at most once. We present a simple 2PC SAM protocol, where each single-access memory operation incurs at most O(w + λ lg n) bits of communication, where w is the word size, n is the number of memory words, and ?ambda is a security parameter. Of this cost, only 2w + 2lg n bits are incurred in the online phase. There are now many oblivious algorithms that compile directly to SAM more efficiently than via a compilation to RAM, and our 2PC SAM can instantiate these algorithms. As one example, we can use our 2PC SAM to implement privacy-preserving graph traversal (DFS or BFS) over a secret-shared size- n graph while revealing nothing beyond the runtime of the SAM program. Our construction achieves online communication O(n lg n) bits, asymptotically matching the number of bits touched in a corresponding cleartext graph traversal.
Secure two-party computation (2PC) in the RAM model has attracted huge attention in recent years. Most existing results only support semi-honest security, with the exception of Keller and Yanai (Eurocrypt 2018) with very high cost. In this paper, we propose an efficient RAM-based 2PC protocol with active security and one-bit leakage.1)We propose an actively secure protocol for distributed point function (DPF), with one-bit leakage, that is essentially as efficient as the state-of-the-art semi-honest protocol. Compared with previous work, our protocol takes about 50× less communication for a domain with 220entries, and no longer requires actively secure generic 2PC.2)We extend the dual-execution protocol to allow reactive computation, and then build a RAM-based 2PC protocol with active security on top of our new building blocks. The protocol follows the paradigm of Doerner and shelat (CCS 2017). We are able to prove that the protocol has end-to-end one-bit leakage.3)Our implementation shows that our protocol is almost as efficient as the state-of-the-art semi-honest RAM-based 2PC protocol, and is at least two orders of magnitude faster than prior actively secure RAM-based 2PC without leakage, providing a realistic trade-off in practice.
Cloud platforms offer innovative solutions for data processing, and privacy concerns arising from this can be addressed through secure multi-party computation (MPC). MPC in the random access machine (RAM) model leverages Oblivious RAM (ORAM) to conceal memory access patterns, rendering it more suitable for data storage and aggregation in cloud environments, where cloud servers can infer user privacy based on observed access patterns. However, most existing RAM-based MPC protocols only ensure semi-honest security; the few actively secure alternatives have limitations in efficiency or input leakage. To address this gap, this paper proposes an efficient active-secure RAM-based MPC protocol without input leakage. Specifically, we first present a new actively secure, reactive MPC protocol with communication of 2(n−1) bits per gate. As the building blocks, we design the (i) multi-party distributed BitGC garbling scheme and (ii) multi-party somewhat homomorphic encryption (SWHE) scheme with distributed decryption. In particular, we then build a RAM-based MPC protocol on top of the above new building blocks with Circuit ORAM and present the check mechanism to achieve secure memory accesses. The implementation shows that our protocol outperforms the prior actively secure RAM-based MPC without leakage by one to two orders of magnitude in both LAN and WAN networks. Compared with the state-of-the-art actively secure RAM-based 2PC with one bit leakage, ours is slightly less efficient in most cases (not all), but supports the multi-party setting and offers a superior alternative for highly confidential environments.
Secure 2-party computation (2PC) is becoming practical for some applications. However, most ap-proaches are limited by the fact that the desired functionality must be represented as a boolean circuit. In response, random-access machines (RAM programs) have recently been investigated as a promising alternative representation. In this work, we present the first practical protocols for evaluating RAM programs with security against malicious adversaries. A useful efficiency measure is to divide the cost of malicious-secure evalu-ation of f by the cost of semi-honest-secure evaluation of f. Our RAM protocols achieve ratios matching the state of the art for circuit-based 2PC. For statistical security 2−s, our protocol without preprocessing achieves a ratio of s; our online-offline protocol has a pre-processing phase and achieves online ratio ∼ 2s / log T, where T is the total execution time of the RAM program. To summarize, our solutions show that the “extra overhead ” of obtaining malicious security for RAM programs (beyond what is needed for circuits) is minimal and does not grow with the running time of the program. 1
Secure multiparty computation (MPC) – computation on distributed, private inputs – has been studied for thirty years. This includes “one shot” applications as well as reactive tasks, where the exact computation is not known in advance. We extend this line of work by exploring efficient datastructures based on MPC primitives. The oblivious RAM (ORAM) provides a completeness theorem. However, implementing the ORAM-CPU using MPC-primitives is costly; current IT-secure constructions incur a poly-log overhead on computation and memory, while computationally secure constructions require MPC-evaluation of one-way functions, which introduces considerable overhead. Using ideas radically different from those in ORAM’s, we propose a secure priority queue. Data accesses are deterministic, whereas ORAM’s hide the access pattern through randomization. nnn priority queue operations – insertion and deletion of the minimal element – require O(nlog⁡2n)O(n\log ^2 n)O(nlog2n) invocations of the cryptographic primitives in O(n)O(n)O(n) rounds. The amortized cost of each operation is low, thus demonstrating feasibility.
Ishai, Kushilevitz, Ostrovsky and Sahai (STOC 2007, SIAM JoC 2009) introduced the powerful “MPC-in-the-head” technique that provided a general transformation of information-theoretic MPC protocols secure against passive adversaries to a ZK proof in a “black-box” way. In this work, we extend this technique and provide a generic transformation of any semi-honest secure two-party computation (2PC) protocol (with mild adaptive security guarantees) in the so called oblivious-transfer hybrid model to an adaptive ZK proof for any NP-language, in a “black-box” way assuming only one-way functions. Our basic construction based on Goldreich-Micali-Wigderson’s 2PC protocol yields an adaptive ZK proof with communication complexity proportional to quadratic in the size of the circuit implementing the NP relation. Previously such proofs relied on an expensive Karp reduction of the NP language to Graph Hamiltonicity (Lindell and Zarosim (TCC 2009, Journal of Cryptology 2011)). We also improve our basic construction to obtain the first linear-rate adaptive ZK proofs by relying on efficient maliciously secure 2PC protocols. Core to this construction is a new way of transforming 2PC protocols to efficient (adaptively secure) instance-dependent commitment schemes. As our second contribution, we provide a general transformation to construct a randomized encoding of a function f from any 2PC protocol that securely computes a related functionality (in a black-box way). We show that if the 2PC protocol has mild adaptive security guarantees then the resulting randomized encoding (RE) can be decomposed to an offline/online encoding. As an application of our techniques, we show how to improve the construction of Lapidot and Shamir (Crypto 1990) to obtain “input-delayed” ZK proofs which are proofs where the honest prover’s algorithm does not require the actual statement until the last round. An interesting corollary we obtain using these proofs are first constructions of a 4-round non-malleable commitments scheme based on oneway permutations where the underlying one-way permutation is used in a black-box way. Previous constructions either required more number of rounds or made non-black-box usage of the underlying primitives.
Abstract. We present oblivious implementations of several data structures for secure multiparty com-putation (MPC) such as arrays, dictionaries, and priority queues. The resulting oblivious data structures have only polylogarithmic overhead compared with their classical counterparts. To achieve this, we give secure multiparty protocols for the ORAM of Shi et al. (Asiacrypt ‘11) and the Path ORAM scheme of Stefanov et al. (CCS ‘13), and we compare the resulting implementations. We subsequently use our oblivious priority queue for secure computation of Dijkstra’s shortest path algorithm on general graphs, where the graph structure is secret. To the best of our knowledge, this is the first implementation of a non-trivial graph algorithm in multiparty computation with polylogarithmic overhead. We implemented and benchmarked all of our protocols using the SPDZ protocol of Damg̊ard et al. (Crypto ‘12), which works in the preprocessing model and ensures active security against an adversary corrupting all but one players. For two parties, the online access time for an oblivious array of size 1 million is under 250 ms.