Security and Communication Networks
Volume 2020 (2020), Article ID 8847487, 12 pages
https://doi.org/10.1155/2020/8847487

Research Article

An Efficient Outsourced Oblivious Transfer Extension Protocol and Its Applications

Shengnan Zhao,¹ Xiangfu Song,¹ Han Jiang,¹ Ming Ma,¹ Zhihua Zheng,² and Qiuliang Xu¹

¹School of Software, Shandong University, Jinan 250100, China
²School of Information Science and Engineering, Shandong Normal University, Jinan 250358, China

Correspondence should be addressed to Han Jiang; jianghan@sdu.edu.cn and Qiuliang Xu; xql@sdu.edu.cn

Received 20 August 2020; Revised 2 November 2020; Accepted 18 November 2020; Published 5 December 2020

Academic Editor: Zhihua Xia

Copyright © 2020 Shengnan Zhao et al. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

Oblivious transfer (OT) is a cryptographic primitive originally used to transfer a collection of messages from the sender to the receiver in an oblivious manner. OT extension protocol reduces expensive asymmetric operations by running a small number of OT instances first and then cheap symmetric operations. While most earlier works discussed security model or communication and computation complexity of OT in general case, we focus on concrete application scenarios, especially where the sender in the OT protocol is a database with less computation and limited interaction capability. In this paper, we propose a generic outsourced OT extension protocol () that outsources all the asymmetric operations of the sender to a semihonest server so as to adapt to specific scenarios above. We give a standard security definition, and the proposed protocol is proven secure in the semihonest model. In , the sender works on the fly and performs only symmetric operations locally. Whatever the number of rounds OT to be executed and the length of messages in OT to be sent, our protocol realizes optimal complexity. Besides, can be used to construct high-level protocols, such as private membership test (PMT) and private set intersection (PSI). We believe our construction may be a building block in other applications as well.

1. Introduction

Oblivious transfer (OT) is one of the most important primitives in secure computation. It is wildly used in Yao’s protocol [1], GMW construction [2], and preprocessing phase of SPDZ-like [3] protocols. With the development of big data, cloud computing, and mobile computing, the demand for joint computation grows rapidly between different organizations and individuals. In order to ensure the security of such computing tasks against complicated external environment, cryptographic components have to be used to design protocols, in which OT plays a pivotal role together with homomorphic encryption, secret sharing, and garbled circuit.

However, OT is public-key primitive centered, which makes it computational expensive for secure computation. Many privacy-preserving protocols, such as private membership test (PMT) and private set intersection (PSI), rely heavily on huge number of OT instances for secure computation to get the trade-off between computation and communication. The most efficient way to produce many OT instances is through OT extension protocol [4, 5]. In such protocol, two participants collectively run few “base” OT instances and then perform some cheap symmetric operations to produce many OT instances.

1.1. Motivation

In an OT extension protocol, the sender needs to interact with the receiver for each step during the protocol, which involves exponential calculation and intensive interaction. In some application scenarios, however, could be a mobile device with less computation power or a database holder with limited interaction capability. When invoking OT extension as a subprotocol in some more complex computation tasks, needs to respond requests from as fast as possible.

Nowadays, many applications are rapidly transferred to cloud-based service, and it would be desired to seek some server-aided OT extension protocol to relief the burden of under reasonable security assumption. A considerable literature [6–12] has grown up around the theme of fertilizing functionality of OT or optimizing communication cost of the receiver . However, far too little attention has been paid to investigate sender side of OT adapting to specific scenarios.

To this end, we propose a generic outsourced oblivious transfer extension protocol in the semihonest model. In , the sender first outsources all expensive asymmetric operations to a third party who runs a subprotocol called “base” OT instances with the receiver . Based on the corresponding outputs of the subprotocol and other auxiliary information, generates symmetric keys used to encrypt sending messages in OT. As a result, the sender works on the fly and sends its inputs encrypted by symmetric key generated from to the receiver , and thus, it enables two parties to complete the whole OT extension protocol.

Recent trends in OT extension have led to a proliferation of studies showing how to design an efficient PSI [13–17] or PSI-based protocols [18–21] in different secure models since OT extension protocol is an important component in secure computation and plays a key role in set operations. Take PSI as an example, without violating individuals’ privacy, and the use of PSI in contact tracing [21] can help prevent the further spread of COVID-19. Therefore, framework has a wide range of applications in outsourced scenarios, and as a building block, we think can be applied conveniently to high-level protocols.

1.2. Related Work

Rabin [22] first introduced the notion of OT that the receiver receives a message sent from the sender with probability and the sender does not know whether the receiver has received the message or not. Then, a line of works seek to enrich functionality of OT, and they mainly consist of 1-out-of-2 OT [6], 1-out-of- OT [7, 8], and k-out-of- OT [9, 10], in which the first two functionalities are considered in this paper. Some researchers [23–25] proposed OT protocols in different security models although we focus on semihonest model that is sufficient enough to deploy our framework in future among including malicious model, covert adversary model, and universally composable model.

Because OT is public-key primitive centered, the issue of efficiency has received considerable critical attention after Rabin’s work [22]. Beaver [26] showed that OT can be precomputed using only prior transfers. Studies over the past two decades have proved that extending a small number of OT to huge number of OT instances can be achieved by one-way function [27–29]. Until 2003, Ishai et al. [4] proposed an efficient method to extend 1-out-of-2 OTs by running few “base” OT instances, which is also known as the IKNP OT extension protocol. Kolesnikov and Kumaresan [5] generalized IKNP from a coding understanding and proposed an improved OT extension protocol allowing to do 1-of-out- OTs with less communication and computation cost. Lindell et al. [11] studied input-size hiding two-party computation based on fully homomorphic encryption (FHE) and proposed a secure OT extension protocol to reduce the communication cost of both the sender and receiver. Cho et al. [12] focused on the receivers’ communication cost in OT and proposed laconic OT protocol based on the decisional Diffie–Hellman (DDH) assumption. Carter et al. [30] proposed outsourced OT protocol specifically for the mobile use-case where the cloud receives outputs of OT. Recently, Mansy and Rindal proposed [31] noninteractive OTs from noninteractive key exchange. However, the resulting OT extension would require 3 rounds.

The research to date has tended to focus more on the cost of the receiver and less on the sender in OT, and there are few studies that have investigated computation and communication complexity on sender side. The aim of this work is to explore the cost of sender in OT and construct efficient OT extension framework assisted by a third party. In addition, OT extension provides a brief but useful account of the construction of oblivious pseudorandom function (PRF). Also, oblivious PRF has been attracting a lot of interest in very recent years, such as multiparty PSI [14], PSI cardinality [21], and private set union [32]. This indicates a need to adapt OT extension to outsourcing scenarios due to practical constraints.

1.3. Our Contribution

In this paper, we focus on server-aided OT to reduce the sender’s public-key computation and rounds of interaction with the receiver. Main contributions of our work go as follows:

(i)We propose a generic outsourced OT extension protocol . In , the server and the receiver cooperatively run a small number of OT instances, and at this moment, the sender can be off-line. After the first phase, the sender can fetch necessary corelated randomness from the server whenever needed; then, the sender can send their inputs encrypted only by a symmetric key to the receiver, which completes an OT instance. We design a novel mechanism for this purpose and formally prove its security under semihonest model.(ii)We analyze the complexity of our construction and perform implementation, and the experiment shows that our construction is practical and efficient.(iii)Our construction can be applied to improve the efficiency of OT-based privacy-preserving primitives in server-aided setting, such as oblivious pseudorandom function, and high-level protocols, such as PMT and PSI, which is of independent interest.

2. Preliminaries

2.1. Notation

Unless otherwise stated, we use OT to denote 1-out-of-2 OT and to denote instances of 1-out-of-2 OT of l-bit strings. For simplicity, let denote random oracles with a suitable secure output length, which will be well defined in an actual protocol. Matrices are denoted by capital letters, and vectors are denoted by small bold letters; that is, denotes the i-th row of a matrix , and denotes the j-th column of . Small light front with subscript denotes the -th bit of a string . Notably, we regard strings as vectors and do not distinguish the difference between strings and vectors. If and are two strings, then the notation denotes . Similarly, the notation denotes the vector . Specially, when , denotes the vector .

2.2. Secure Computation and Security Model

The formal definition of security of a secure multiparty protocol [33] is based on comparing two output distributions coming from an ideal world and a real world, respectively. The functionality of three parties is denoted as , where and gets as output.

 Ideal/reality Simulation Paradigm. In an ideal world, participants send the input to an external trusted party who computes the functionality and sends each participant the corresponding output. Suppose there exists an adversary who has the inputs and outputs of a protocol in the ideal world and executes attack against a real protocol, then there always be an adversary executing the same attack in the ideal world. In a real protocol, if no adversary can do more harm than the execution of the protocol in the ideal world, the protocol in the real world is said to secure. Computationally Indistinguishability. Two distribution probability ensembles and are said to be computationally indistinguishable, denoted by , if for every nonuniform polynomial-time algorithm , there exists a negligible function such that for every and every :

 Semihonest Adversary Model. In the semihonest adversary model, corrupted participant must execute the protocol correctly. However, the adversary can comprehensively obtain the internal status of the corrupted party, e.g., the transcripts of all received messages, and then tries to obtain additional information that should be kept confidential. Semihonest model is sufficient and captures many scenarios in practice although it is a very weak adversary model.

In this paper, we focus on semihonest model and honest majority case where an adversary can corrupt at most one participant and any two participants will not get colluded. In the following, the formal security definition is proposed.

Definition 1. Let be a deterministic functionality and be a three-party protocol for computing . Given the security parameter and triple inputs , where is from , is from , and is from , the view of in the protocol is denoted as , where , is the randomness used by , and is the -th message received by ; the output of is denoted as , and the joint output of the parties is . We say that securely computes in the semihonest model if the following holds:

(i)The correctness holds:

(ii)There exist probabilistic polynomial-time simulators , , and such that

2.2.1. Security Model

In , a simpler definition can be used since two of three parties output nothing (see in Figure 1). Specifically, three parties stand for server , sender , and receiver , respectively. The functionality of can be given by simply writing , where denotes the empty string. We still require correctness described above, and security meaning that there exist three simulators , , and such that

where denotes input set from , denotes output of , and denotes null value.

Figure 1: Outsourced oblivious transfer functionality .

2.3. OT Extension

We start by introducing the definition of standard 1-out-of-2 OT, where a sender holding two messages interacts with a receiver holding a choice bit . The 1-out-of-2 OT protocol guarantees that the receiver obtains without knowing anything about , while the sender knows nothing about . The ideal functionality for 1-out-of-2 OT, denoted as , is described in Figure 2.

Figure 2: 1-out-of-2 oblivious transfer functionality .

In most settings, it is necessary to run a large number of OT instances at the same time. The multiexecution of OT is called batch OT (see Figure 3) denoted as . The IKNP OT extension protocol [4] is a real milestone in the development of OT research computing efficiently. It is trivial to compute by simultaneously running times although it leads to large costs on computation and communication. Therefore, OT extension is the most efficient way for executing instead of running instances of OT in parallel.

Figure 3: Batch oblivious transfer functionality .

As shown in Figure 3, the functionality of IKNP is that receives messages without knowing anything about , while knows nothing about , where denotes the -th bit of . In the IKNP protocol, after acting as the receiver in and running it times, computes pairs of symmetric keys denoted as , which are used to encrypt each pair of messages , where . For each pair of symmetric keys , only knows the exact one according to his selection string, i.e.,. The key insight of IKNP OT extension is to execute such an OT-based key agreement between and in the following way:

forms matrix at random and then computes matrix such that . chooses at random. For each , invokes with input , and acts as the receiver with selection bit . receives after each computation of and then forms matrix . For each column of matrix , it implies . The essential observation is that, for each row of matrix , it holds

prepares key pairs by and and exactly knows , where is generated by locally. In addition, due to the randomness of chosen by , learns with no more than a negligible probability . Then, can execute just symmetric operations so as to encrypt each pair of messages using key pairs and sends pairs of encrypted messages to . Finally, can decrypt the corresponding message for each message pairs under .

As described above, the IKNP protocol begins with running times and then executes lots of symmetric operations to “extend” these OT instances, which are also called as “base” OTs.

2.4. Oblivious PRF

Freedman et al. [34] proposed oblivious evaluation of pseudorandom function (OPRF) and gave a general construction of OPRF from OT. An OPRF is a two-party protocol where a sender inputting a random seed obtains nothing while a receiver inputting an evaluation point obtains for some pseudorandom function family . The functionality of OPRF (see Figure 4) can be defined by .

Figure 4: Oblivious PRF functionality .

A general definition of OPRF is that the receiver inputs an evaluation set and obtains the evaluations on a PRF in an oblivious manner, i.e.,. The functionality in Figure 4 can be regarded as a special and simplified case although it is sufficient to construct such an efficient OPRF for some scenarios. In this paper, we consider only the definition where receiver evaluates the PRF on a single point , which can be constructed massively in an efficient manner.

2.4.1. Batched OPRF Based on OT Extension

Kolesnikov and Kumaresan [5] generalized IKNP and proposed KK protocol realizing OTs in an efficient way. In IKNP, the equation means that each row of matrix is either all zeros or all ones. This feature was interpreted as a repetition code in KK, and they improved it using a linear error correcting code denoted by . Now for each row in and , it holds that , where is a public linear error correcting code of dimension and codeword length . Therefore, in KK, equation (5) becomes

Notably, stands for the -th element in vector , and now, it is no longer a binary bit in equation (5) but an -bit string. The codeword length of determines the length of and the number of columns of matrices and , instead in IKNP of ( is relative to a security parameter ). In KK, to reach the same security requirement, the codeword length is about twice as much as . That is to say, . As a consequence, the number of “base” OT in KK is doubled than that in IKNP.

Based on 1-out-of- OT extension, Kolesnikov et al. [13] proposed a variant of OPRF and described an efficient protocol to generate batched OPRF instances (known as ). From the point of adaption of OT extension, the variant OPRF functionality based on equation (6) is that

where now is a pseudorandom code instead of a linear error correcting code.

Notably, the random seed consists of in and , indicating that equation (6) essentially instantiates different OPRFs in total, and this is why is called bathed and key-related OPRF. In addition, the codeword length of pseudorandom code in is approximately 2 times longer than the output length of linear error correcting code in KK, which is necessary to reach security requirement. Based on OPRF, it is trivial to construct the private membership test, which will be illustrated later.

3. Overview of Our Construction

The functionality of is described in Figure 1. While the essential difference between in Figure 3 and in Figure 1 may appear to be unimpressive and unnecessary, the distinction becomes more pronounced in the case of practical OT extension applications and even more so in outsourced OT scenarios.

The codeword length of code schemes in equations (6) and (7), i.e., pseudorandom code and linear error correcting code, determines the number of “base” OT instances to be evaluated. This gives us the intuition that we could use a specific number of OTs to extend any large amount of OT instances we need. Both Ishai et al. [4] and Kolesnikov et al. [5, 13] show OTs of long strings that can be reduced to “base” OTs of shorter strings. That is, given pseudo-random generator and a small number of OTs, we can implement any we want. Therefore, we make OT execute in a program-iteration-like way (see Figure 5) to reach the final functionality . Here, for clarity, we denote selection string in by bold letter instead of , and -th element of is denoted by .

Figure 5: Overview of OT iteration.

To better understand our work, let us review IKNP OT extension where holds pairs of -length messages , and the receiver holds -bit selection vector . According to Figure 5, we now focus on and only. For , each row of matrices and consists of and , respectively; that is, both and are matrices and . Now, serves as “base” OT in IKNP, while the final functionality is to realize , where is the security parameter, , and . After , computes equation (5) and sends encrypted and to . Using symmetric-key operations only, receives from and in an oblivious way. For , each row of matrix is . We have reviewed the whole framework of IKNP protocol so far, and it does matter the relationships among , , and . If we write the algorithm implementing as recursive function in programming language, then the key step in IKNP is that invokes ; i.e., is reduced to , where is the security parameter in IKNP. Thus, we implement by invoking first and then executing some symmetric-key encryption operations.

In more general case, two parties and prepare to run protocol , where acts as sender holding messages matrices and while holds chosen vector . After , gets outputs consisting of those messages he/she chooses to receive. According to OT extension protocol, and first run , where acts as a receiver and acts as a sender. For each and , it holds

denotes the -th row of matrix , denotes -th element of , and for some encoding scheme, such as repetition code in equation (5) and linear error correcting code in equation (6). We present detailed in concrete protocol and just emphasize the connections between and here.

and are named as outer and inner OT, respectively. Specially, is the innermost one. Then, we find that the two input vectors and of the inner are determined by the input of the outer . The role of and get reversed each time invokes ; that is to say, in outer OT becomes the receiver in inner OT, so as to . Furthermore, (if exists) is the outer OT related to ; therefore, the input vectors of and are determined by .

The transformation among , , and is the main part of our work. The key observation is that the inputs of both two parties in and are independent. That is, and , and , and and are independent. If is a necessary component in protocol, we can precompute assisted with a semihonest server. We focus on a special-but-sufficient case where and prepare to execute ; notably, the innermost is (see Figure 6) instead of . In such a scenario, should not be less than security parameter. If is a normal user acting as the receiver in and is a database with limited computation power and interaction capability, the framework becomes more useful and efficient. Therefore, we consider a server-aided oblivious transfer reducing the sender’s all public-key computation and numbers of interaction with other parties. As shown in Figure 6, outsources the computation marked with blue rectangle to a server.

Figure 6: Construction of .

Our protocol consists of two major phases. First, in the outsourced phase, and server run as follows. inputs random selection string , while inputs two random matrices and . After , gets output and prepares (and ) for . In the second phase, aims to respond to the request for . This phase can be concluded as invoking and sending pairs of messages ( and encrypted by ) to . In the last phase, gets outputs from , which can be seen as invoking .

4. Outsourced Oblivious Transfer Extension

In this section, we show how to construct an outsourced oblivious transfer extension protocol , where three-party functionality can be securely computed in the presence of semihonest adversaries.

Our protocol consists of two major phases among three parties, sender, receiver, and server. Figure 6 shows construction in a program-iteration-like way, where a small number of OT instances, the innermost , are first to be executed cooperatively. In fact, we let , and it becomes , where is the security parameter in real protocol. From the global perspective, we give procedure of in Figure 7 so as to have a better understanding of roles three parties play in every phase.

Figure 7: Procedure of outsourced oblivious transfer.

First, in the outsourced phase, and run as follows. inputs random selection string , while inputs two random matrices and . After , gets outputs and prepares (and ) for . In the second phase, aims to respond to the request for . This phase can be concluded as invoking and sending pairs of messages ( and encrypted by ) to . In the last phase, gets outputs from , which can be seen as invoking .

We describe in Figure 8 which realizes functionality in Figure 4. The invoking procedure in can be written as .

Figure 8: Outsourced oblivious transfer extension protocol.

According to equation (8), each time invokes , and it holds . Let represent different encoding schemes each time iteration occurs. In , we have and , where both and are repetition code with output length , i.e.,

Notably, in more general case, the outputs of and may be not equal length, which is determined by and , respectively. Figures 7 and 8 illustrate framework and procedure, where the symbols are consistent and the output length of repetition code is embodied in the number of columns in the matrices and .

Theorem 1. The protocol in Figure 8 securely computes the functionality (Figure 4) in semihonest setting, as described in Definition 1, given random oracle and functionality (Figure 1).

Proof. We begin by proving the correctness. After , we prove that only receives and knows nothing about when computing . In the outsourced phase, it holds that

Then, in the responding phase, Step 5, essentially computes

Therefore, in Step 6, for , by computing , gets when and gets when . Due to , we have and

For , computes and essentially sends to the following messages:

It holds that if and only if . Concretely, when , computes

When , computes

In summary, only receives in and cannot recover by computing because knows nothing about , i.e.,.
This concludes the correctness of .
We now construct three simulators , , and for simulating corrupt , , and such that the produced transcript and the view of real execution are computationally indistinguishable. That is,

where denotes input set from , denotes output of , and denotes the null value.

 Corrupt. Given , it is easy to perfectly simulate the view of the Server because only has input, neither receives messages nor outputs during the execution of the protocol. That is, is computationally indistinguishable with . Corrupt. In protocol, Sender works only in the responding phase, when receives messages from and then sends encrypted inputs to . The messages obtained by are . That is to say, consists of input and messages , where . It is trivial for to generate a simulation of since both are random values from the point of view of . Now, simulates a simulation of by choosing a -length string , -length strings , matrix , and matrix at random and computing

 Let be the output of . Therefore, we claim that the view generated by and the view of corrupt in a real protocol are computationally indistinguishable. Corrupt. We construct a simulator that simulates the view of corrupt in the real protocol execution. We first analyze ’s view in . obtains matrix in the outsourced phase and in the outputting phase. Therefore, consists of ’s input and messages . To construct the simulation of the view, works as follows.(i)In the outsourced phase, given the security parameter , ’s input , and the randomness , calls simulation with input and gets output . Then, appends the output of , i.e., matrix , to its own output.(ii)In the outputting phase, given the security parameter , ’s input , the randomness , and output , simulates a simulation of by choosing -length strings and computing

Then, appends to its output.
Combining two phases described above in sequence, we finally claim that the output of is computationally indistinguishable from the real execution, i.e.,.
This completes the construction of three simulators: , , and . In summary, is secure under semihonest model.

4.1. Performance Analysis

We now analyze the performance of in semihonest model. The complexities of are presented in Table 1.

(i)Computation complexity. The number of symmetric and asymmetric operation to be executed in essentially depends on the size of matrices , , and , respectively. In the outsourced phase, consists of public-key and private-key operations, for both (acting as sender) and (acting as receiver). In the responding phase, invokes random oracle and performs XOR operation for times. Then, recovers matrix and encrypts messages , which only consists of symmetric operations. In the outputting phase, performs symmetric operations times to compute its outputs.(ii)Communication complexity. In the outsourced phase, the number of bits transferred between and is bounded by . In the responding phase, receives messages from and and sends encrypted messages to , which consist of . In the outputting phase, receives -bit messages in total from .(iii)Round complexity. The only interaction in exists in the outsourced phase between and , i.e.,. The number of interaction round in is bounded by 1.

Table 1: Complexity of .

Party
Computation
Communication
Round

Asymmetric
Symmetric

Server

1

Sender
–

–

Receiver

1

4.2. Efficiency Comparison

Since we focus on the efficiency of the sender in OT, we provide comparisons to prior classical protocols from the ’s point of view in Table 2. In , all asymmetric operations are operated between the receiver and the cloud server , and works on the fly and conducts symmetric computations locally.

Table 2: Efficiency comparison.

Protocol
Round
Communication
Asymmetric computation
Security model

[4]
2

Semihonest and malicious

[5]
2

Semihonest

[16]
2

Semihonest and one-sided malicious

[30]
2

Semihonest

[31]
3

Malicious

Ours
–

–
Semihonest

Note: the efficiency of sender in OT is presented here, who inputs pairs of -bit length messages in protocol. Specially, is security parameter, denotes a group, and in 1-out-of- OT.

5. Performance

In this section, we test the performance of . The experiments were performed on a Linux machine equipped with 4 cores 3.40 GHz Intel Core i5-7500 CPU and 8 GB RAM.

Our tests refer to the implement on GitHub: https://github.com/emp-toolkit/emp-ot. We simulated main asymmetric operations in on a single machine. We compared with the OT protocol used in recent work [32], where they compute at least 450 OT instances locally from 128 “base” OTs. Therefore, we regarded as a reference and simulated the outsourced phase. After setting the length of security parameter equal to 128, we simulated for , , and , respectively. We repeated each simulation 20 times, and the result is shown in Figure 9. Although shows an almost identical performance to Vladimir’s, the running time tends to be steady sooner when . In addition, in Figure 9, the sender of works offline for most of the time during simulation, and this is one of the advantages of .

Figure 9: Comparison of running time.

The other advantage of found in performance tests is the reduction of communication bottleneck caused by the sender . The main idea of OT extension protocol is to extend a small number of base OTs to perform many OTs. As a consequence, we summed from the time of base OTon setup to the time of protocol finish and then computed average time for each original OT. The averaged time is illustrated in Figure 10. We tested OT instances for different values and computed the average running time for one single OT, i.e.,. From Figure 10, we can see that the average time keeps steady when is less than 8. If we extend base OT to an adequate number of OTs, for example, , the average time has a sharp increase. It does not matter in , however, since the extension process is conducted between and in the outsourced phase.

Figure 10: Average time for OT instances in .

6. Applications of

The framework has a wide range of applications in outsourced scenarios. In this section, we take private set intersection (PSI) as a case study and demonstrate that, as a building block, can be applied conveniently to high-level protocol.

We first introduce a private membership test (PMT) protocol to estimate whether an element belongs to a set or not and then describe how to efficiently implement it via . The resulting protocol can then be simply extended to compute functionality in Figure 11 by applying the -based PMT protocol.

Figure 11: Private set intersection functionality .

6.1. OPRF-Based PMT Protocol

PMT protocol involves two parties: Alice who holds an element and Bob who holds a set . After PMT, Bob knows nothing about , and Alice only knows whether her element belongs to the set or not.

Based on OPRF, we can construct PMT protocol as follows. First, during the OPRF phase, Bob acts as sender with a random seed . And Alice, acting as receiver, inputs her element . After OPRF, Alice obtains and Bob has . Then, Bob sends all to Alice who compares with one by one. In conclusion, Alice outputs 1 if and only if there exits an such that and else outputs 0.

The security of PMT via OPRF relies on the fact that an OPRF protocol is secure. In a secure OPRF, it guarantees that is a one-way pseudorandom function and the length of equals to secure parameter. Therefore, Alice receives and then learns whether there exists an such that , but she will not learn the exact values with nonnegligible probability. We omit concrete security proof here.

6.2. -Based PMT Protocol

Given functionality , we can construct PMT protocol in a simple manner. In this section, we introduce how to design OPRF protocol based on . Equation (7) indicates that 1-out-of- OT extension implies ; therefore, we focus on the transformation from 1-out-of- OT extension to . As a result, can be easily used to construct PMT protocol.

We can apply pseudorandom code to equation (8) for defining new relationship among and in Figure 6, which implements functionality in Figure 3. In , however, we stress that it always holds and , where is the repetition code. This means that we implement INKP protocol in an outsourced manner since we use the same repetition code in and . That is to say, three parties, , , and , evaluate corporately instances of 1-out-of-2 OT of -bit messages where repetition code is used twice in total, each by and , respectively. Now, suppose Alice and Bob would like to execute instances of 1-out-of- OT where Bob inputs and Alice inputs her selection vector , and they need make the following adjustments:

(i)Bob organizes the inputs in with matrices , where the -th row of matrix is .(ii)Alice makes her selection vector in be .

Then, the only adaption they need take in is that , where is the linear error correcting code . To reach the security requirement defined in [13], in , we need to reset security parameter rather than —concretely .

Given 1-out-of- OT protocol designed from , it is trivial to design -based OPRF so is to -based PMT. Again, Alice prepares her element , while Bob holds set . In brief, if it holds in that

where is the repetition code and is the pseudorandom code; implies the functionality where the seed consists of generated by Bob and Alice gets . Meanwhile, this essentially completes the main construction of -based PMT protocol. All needed to do next is that Bob sends to Alice who compares with locally.

6.3. -Based PSI Protocol

To obtain the final PSI protocol that computes , Alice simply invokes the PMT protocol for each . The protocol in Figure 12 computes in an outsourced manner. The intuition is that Alice holds a set , while Bob holds , and after PMT, Alice knows whether her element belongs to or not, i.e., the intersection of two sets.

Figure 12: Outsourced private set intersection protocol.

Some details on method of preprocessing items in set are simply omitted in Figure 12. We can hash the item to bins and then operate the -based PSI protocol on each bin separately. Specifically, we use Cuckoo hashing [35] for PSI in the following way. First, Alice and Bob agree on 3 random hash functions suitable for 3-way Cuckoo hashing. Alice places her items into in either , , or , and each bin contains at most one item. Bob places each of his items in locations , , and . At this point, Alice pads her input with dummy items so that each bin contains exactly 1 item. Note that when we use cuckoo hashing, then there will be some items which cannot be placed into the table and have to be moved to a stash, which does not matter because of the usage of stash-less cuckoo hashing [20]. Finally, Alice and Bob perform a PSI in each bin.

7. Conclusions and Future Work

In this paper, we proposed a generic outsourced OT extension protocol () which can outsource all the “base” OT from the sender to a semihonest server. The proposed protocol realizes optimal computational and communication complexity relative to security parameter. In addition, we showed that can be efficiently used in private membership test and private set intersection. In the future, we will consider malicious model and construct efficient outsourced OT extension protocols secure against malicious adversary.

Data Availability

The performance test data used to support the findings of this study are included within the article.

Conflicts of Interest

The authors declare that they have no conflicts of interest.

Acknowledgments

This work was supported by the National Natural Science Foundation of China (Grant nos. 61572294 and 61632020), Major Innovation Project of Science and Technology of Shandong Province (Grant no. 2018CXGC0702), Natural Science Foundation of Shandong Province (Grant no. ZR2017MF021), and Fundamental Research Funds of Shandong University (Grant no. 2017JC019).

References

C.-C. Y. Andrew, “How to generate and exchange secrets,” in Proceedings of the 27th Annual Symposium on Foundations of Computer Science (SFCS 1986), pp. 162–167, Washington, DC, USA, October 1986.

O. Goldreich, S. Micali, and A. Wigderson, “How to play any mental game, or a completeness theorem for protocols with honest majority,” in Providing Sound Foundations for Cryptography: On the Work of Shafi Goldwasser and Silvio Micali, pp. 307–328, Weizmann Institute of Science, Rehovot, Israel, 2019.

I. Damgård, V. Pastro, N. Smart, and S. Zakarias, “Multiparty computation from somewhat homomorphic encryption,” in Proceedings of the Annual Cryptology Conference, pp. 643–662, Santa Barbara, CA, USA, August 2012.

Y. Ishai, J. Kilian, K. Nissim, and E. Petrank, “Extending oblivious transfers efficiently,” in Proceedings of the Annual International Cryptology Conference, pp. 145–161, Santa Barbara, CA, USA, August 2003.

V. Kolesnikov and R. Kumaresan, “Improved ot extension for transferring short secrets,” in Proceedings of the Annual Cryptology Conference, pp. 54–70, Santa Barbara, 2013.

S. Even, O. Goldreich, and A. Lempel, “A randomized protocol for signing contracts,” Communications of the ACM, vol. 28, no. 6, pp. 637–647, 1985.

G. Brassard, C. Claude, and J.-M. Robert, “All-or-nothing disclosure of secrets,” in Proceedings of the Conference on the Theory and Application of Cryptographic Techniques, pp. 234–238, Santa Barbara, CA, USA, 1986.

W.-G. Tzeng, “Efficient 1-out-n oblivious transfer schemes,” in Proceedings of the International Workshop on Public Key Cryptography, pp. 159–171, Paris, France, February 2002.

Y. Mu, J. Zhang, and V. Varadharajan, “m out of n oblivious transfer,” in Proceedings of the Australasian Conference on Information Security and Privacy, pp. 395–405, Melbourne, Australia, 2002.

C.-K. Chu and W.-G. Tzeng, “Efficient k-out-of-n oblivious transfer schemes with adaptive and non-adaptive queries,” in Proceedings of the International Workshop on Public Key Cryptography, pp. 172–183, New York, NY, USA, March 2005.

Y. Lindell, K. Nissim, and C. Orlandi, “Hiding the input-size in secure two-party computation,” in Proceedings of the International Conference on the Theory and Application of Cryptology and Information Security, pp. 421–440, Bengaluru, India, December 2013.

C. Cho, N. Döttling, S. Garg, D. Gupta, P. Miao, and A. Polychroniadou, “Laconic oblivious transfer and its applications,” in Proceedings of the Annual International Cryptology Conference, pp. 33–65, Santa Barbara, CA, USA, 2017.

V. Kolesnikov, R. Kumaresan, M. Rosulek, and T. Ni, “Efficient batched oblivious PRF with applications to private set intersection,” in Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp. 818–829, Vienna, Austria, October 2016.

V. Kolesnikov, N. Matania, B. Pinkas, M. Rosulek, and T. Ni, “Practical multi-party private set intersection from symmetric-key techniques,” IACR Cryptology ePrint Archive, vol. 799, p. 2017, 2017.

B. Pinkas, T. Schneider, and M. Zohner, “Scalable private set intersection based on ot extension,” ACM Transactions on Privacy and Security, vol. 21, no. 2, p. 7, 2018.

B. Pinkas, M. Rosulek, T. Ni, and A. Yanai, “Spot-light: lightweight private set intersection from sparse ot extension,” in Proceedings of the Annual International Cryptology Conference, pp. 401–431, Santa Barbara, CA, USA, August 2019.

M. Chase and P. Miao, “Private set intersection in the internet setting from lightweight oblivious PRF,” in Proceedings of the Annual International Cryptology Conference, pp. 34–63, Santa Barbara, CA, USA, August 2020.

B. Pinkas, T. Schneider, C. Weinert, and U. Wieder, “Efficient circuit-based psi via cuckoo hashing,” in Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, pp. 125–157, Darmstadt, Germany, May 2018.

M. Ciampi and C. Orlandi, “Combining private set-intersection with secure two-party computation,” in Proceedings of the International Conference on Security and Cryptography for Networks, pp. 464–482, Amalfi, Italy, September 2018.

B. Pinkas, T. Schneider, O. Tkachenko, and A. Yanai, “Efficient circuit-based psi with linear communication,” in Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, pp. 122–153, Darmstadt, Germany, May 2019.

T. Duong, D. H. Phan, and T. Ni, Catalic: Delegated PSI Cardinality with Applications to Contact Tracing, vol. 1105, IACR Cryptology ePrint Archive, 2020.

M. O. Rabin, “How to exchange secrets with oblivious transfer,” IACR Cryptology ePrint Archive, vol. 187, p. 2005, 2005.

A. Y. Lindell, “Efficient fully-simulatable oblivious transfer,” in Proceedings of the Cryptographers’ Track at the RSA Conference, pp. 52–70, San Francisco, CA, USA, April 2008.

B. Zeng, C. Tartary, P. Xu, J. Jing, and X. Tang, “A Practical Framework for -out-of- oblivious transfer with security against covert adversaries,” IEEE Transactions on Information Forensics and Security, vol. 7, no. 2, pp. 465–479, 2012.

M. Green and S. Hohenberger, “Universally composable adaptive oblivious transfer,” in Proceedings of the International Conference on the Theory and Application of Cryptology and Information Security, pp. 179–197, Melbourne, Australia, December 2008.

D. Beaver, “Precomputing oblivious transfer,” in Proceedings of the Annual International Cryptology Conference, pp. 97–109, Santa Barbara, CA, USA, August 1995.

D. Beaver, “Correlated pseudorandomness and the complexity of private computations,” in Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing, pp. 479–488, Philadelphia, PA, USA, May 1996.

Y. Gertner, S. Kannan, T. Malkin, O. Reingold, and M. Viswanathan, “The relationship between public key encryption and oblivious transfer,” in Proceedings 41st Annual Symposium on Foundations of Computer Science, pp. 325–335, Redondo Beach, CA, USA, November 2000.

Y. Gertner, T. Malkin, and O. Reingold, “On the impossibility of basing trapdoor functions on trapdoor predicates,” in Proceedings 42nd IEEE Symposium on Foundations of Computer Science, pp. 126–135, Heraklion, Greece, 2001.

H. Carter, B. Mood, P. Traynor, and K. Butler, “Secure outsourced garbled circuit evaluation for mobile devices,” Journal of Computer Security, vol. 24, no. 2, pp. 137–180, 2016.

D. Mansy and P. Rindal, “Endemic oblivious transfer,” in Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 309–326, London, UK, November 2019.

V. Kolesnikov, M. Rosulek, T. Ni, and X. Wang, “Scalable private set union from symmetric-key techniques,” in Proceedings of the International Conference on the Theory and Application of Cryptology and Information Security, pp. 636–666, Kobe, Japan, December 2019.

O. Goldreich, Foundations of Cryptography: Volume 2, Basic Applications, Cambridge University Press, Cambridge, UK, 2009.

M. J. Freedman, Y. Ishai, B. Pinkas, and O. Reingold, “Keyword search and oblivious pseudorandom functions,” in Proceedings of the Theory of Cryptography Conference, pp. 303–324, Cambridge, MA, USA, February 2005.

R. Pagh and F. F. Rodler, “Cuckoo hashing,” Journal of Algorithms, vol. 51, no. 2, pp. 122–144, 2004.