Unbalanced privacy set intersection system supporting set real-time updating

Abstract

The invention relates to an unbalanced privacy set intersection system supporting real-time updating of a set, and belongs to the technical field of cryptology. The system comprises three entity units: a data provider, a client and a security processing pipeline, wherein the data provider and the client respectively send encrypted data streams to the security processing pipeline, and the client hopes to know an intersection of an input set of the client and an input set of the data provider; the security processing pipeline is composed of two non-collusive servers, is a core computing component, and is used for safely processing data and providing an intersection result; no direct communication exists between the client and the data provider, and an execution protocol of the system comprises an initialization stage, a client updating stage and a data provider updating stage. According to the system provided by the invention, the participants are allowed to safely update the sets in real time, the confidentiality and integrity of incremental updating are effectively ensured, and dynamic set management is facilitated without leaking a single set element.

Description

Technical Field

[0001] The invention belongs to the technical field of cryptography and relates to an unbalanced privacy set intersection system that supports real-time update of sets. Background Art

[0002] With the rapid development of cloud computing technology and the increasing demand for privacy protection, a series of application scenarios such as private contact tracing, online advertising precision delivery, and data mining have put forward higher requirements for data processing. In these application scenarios, a common requirement is to find the intersection of the data sets owned by the participants, and it must be ensured that no additional data content is leaked except the intersection information. The Private Set Intersection (PSI) technology can just meet the urgent needs of these application scenarios. It allows the participants to jointly calculate the intersection of their data sets while protecting their respective data privacy.

[0003] However, in practical applications, the data sets of the participants often present an unbalanced characteristic, that is, the size of one data set may be much larger than that of another data set. This imbalance poses a challenge to the intersection of private sets. In addition, data sets in the real world are constantly changing dynamically, data are updated frequently, and the latest intersection results need to be obtained quickly after the update. Traditional private set intersection protocols are often inefficient when dealing with such unbalanced and frequently updated data, and are difficult to meet the needs of practical application scenarios.

[0004] Existing unbalanced PSI protocols are mainly designed for static datasets. When datasets are constantly updated, these protocols will incur huge computational and communication overheads, leading to performance bottlenecks. To solve this problem, some methods try to reduce computational and communication overheads by filling virtual elements or using techniques such as homomorphic encryption, but these methods still have significant performance issues and security risks and cannot fully meet the needs of actual application scenarios.

[0005] The current privacy set intersection protocol faces two key challenges in practical applications: 1) the protocol calculation and communication efficiency is low under unbalanced data sets; 2) the unbalanced privacy intersection protocol is difficult to adapt to the scenario of dynamically updated data sets. Therefore, improving the efficiency of protocol calculation and communication and promoting the development of privacy set intersection technology to dynamic unbalanced data sets has become an urgent problem to be solved. By developing a more efficient and secure privacy set intersection protocol, better privacy protection can be provided for cloud services, meeting the dual requirements of efficiency and privacy of data processing in practical application scenarios. This will not only promote the further development of cloud computing technology, but also provide strong guarantees for personal privacy protection and data security. Summary of the invention

[0006] In view of this, the purpose of the present invention is to provide an unbalanced private set intersection system that supports real-time update of sets, which allows participants to securely update their sets in real time and effectively ensures the confidentiality and integrity of incremental updates, facilitates dynamic set management without leaking individual set elements.

[0007] In order to achieve the above object, the present invention provides the following technical solutions:

[0008] An unbalanced private set intersection system supporting real-time update of sets, the system comprising three entity units: a data provider, a client and a secure processing pipeline; wherein the data provider and the client respectively send encrypted data streams to the secure processing pipeline, and the client wishes to know the intersection of its input set and the data provider's input set; the secure processing pipeline is composed of two non-collusive servers, which are core computing components for securely processing data and providing intersection results; there is no direct communication between the client and the data provider, and the execution protocol of this system includes an initialization phase, a client update phase and a data provider update phase.

[0009] Furthermore, the initialization phase is only performed when the participants establish communication for the first time, including: the data provider generates an encryption key and generates a corresponding additional share and sends it to the security processing pipeline; the client randomly generates a hash table and sends it to the security processing pipeline.

[0010] Furthermore, the client update phase is a phase in which the client updates data and receives results, including: the client and the security processing pipeline interact inadvertently to obtain an encrypted form of the newly added element; the client updates the hash table and sends it to the security processing pipeline, the hash table is a data structure for storing and processing elements of the client input set, so as to facilitate subsequent intersection calculations; the security processing pipeline calculates the intersection and sends the result to the client.

[0011] Furthermore, the data provider update phase is a phase in which the data provider updates data and pushes results to the client, including: the data provider encrypts the newly added elements and sends them to the security processing pipeline; the security processing pipeline calculates the intersection and sends the results to the client.

[0012] Furthermore, the encrypted data stream is generated by a specific encryption algorithm to ensure the confidentiality and integrity of the data.

[0013] Furthermore, the oblivious interaction is implemented by oblivious pseudorandom functions (OPRF) or other similar privacy protection technologies to protect the privacy of the newly added elements. This function is regarded as a hash function with a key. In this protocol, only the sender knows the key s, and the receiver can obtain OPRF (s, X) without knowing the function OPRF (s, -) or the key s, and the sender will not know X, where X is the data sent by the receiver.

[0014] Furthermore, the intersection result is calculated through secure multi-party computing technology or other similar privacy protection technology to ensure the confidentiality of the calculation process and the accuracy of the result.

[0015] The beneficial effects of the present invention are:

[0016] The present invention provides an unbalanced private set intersection system that supports real-time update of sets. The PSI protocol in the present invention has the characteristics of high efficiency, real-time performance and strong privacy protection. The scheme is based on distributed point functions and oblivious pseudo-random functions and can run effectively in a dynamic data environment. The scheme is implemented and evaluated on real-world data sets to verify its effectiveness and performance. Compared with the existing unbalanced private set intersection protocol, the scheme of the present invention shows significant advantages in computing and communication costs. Specifically, the scheme reduces bandwidth and storage overhead by up to 24 times and 31 times, respectively, while maintaining low computing latency and communication latency. For example, for a large set managed by a server (containing one million elements), the running time for adding 4096 elements is 31 milliseconds; while for a small set managed by a client (containing one thousand elements), the running time for adding 64 elements is only 32 milliseconds. In addition, the scheme also ensures the confidentiality and integrity of the data, avoids the risk of data leakage and security vulnerabilities, and performs particularly well in processing large-scale streaming data and real-time update scenarios.

[0017] Other advantages, objectives and features of the present invention will be described in the following description to some extent, and to some extent, will be obvious to those skilled in the art based on the following examination and study, or can be taught from the practice of the present invention. The objectives and other advantages of the present invention can be realized and obtained through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to make the purpose, technical solutions and advantages of the present invention more clear, the present invention will be described in detail below in conjunction with the accompanying drawings, wherein:

[0019] Figure 1A workflow diagram of a privacy set intersection solution that can be updated in real time provided by an embodiment of the present invention;

[0020] Figure 2 An algorithm flow chart of the privacy set intersection solution provided in an embodiment of the present invention;

[0021] Figure 3 This is a flowchart of a client sending two sets to server 1 and server 2 respectively in an embodiment of the present invention;

[0022] Figure 4 This is a flow chart of a client sending a key set to server 1 and server 2 in an embodiment of the present invention. DETAILED DESCRIPTION

[0023] The technical solution of the present invention is described in detail below with reference to the accompanying drawings.

[0024] The embodiment of the present invention provides a private set intersection method for unbalanced data sets and real-time update requirements, such as Figure 1 As shown in Figure 1. The method includes three entities: data provider, client and secure data processing pipeline. Data processing between participants includes three phases: initialization phase, client update phase and data provider update phase. Figure 2 As shown, the initialization phase is only performed when the data provider and the client establish a connection with the secure data processing pipeline for the first time; the client update phase is the phase in which the client updates the data and receives the result; and the data provider update phase is the phase in which the data provider updates the data and pushes the result to the client.

[0025] In the initialization phase, in order to avoid direct communication between the data provider and the client in the subsequent calculation process, the data provider generates the key k p After that, two more key shares k need to be generated p1 ,k p2 Satisfy k p1 +k p2 =k p .

[0026] The client randomly generates a Cuckoo hash table using a distributed point function (DPF) and sends it to server 1 and server 2 respectively. The point function in this embodiment means a function whose value is 1 only at a specific point and 0 at all other points. DPF includes two algorithms:

[0027] k1,k2←DPF.Gen(1 λ ,α)

[0028] y←DPF.Eval(1 λ,k,x)

[0029] y1+y2=1 if and only if y1←DPF.Eval(k1,α) and y2←DPF.Eval(k2,α).

[0030] The Cuckoo hash table contains two hash functions h1 and h2, which map elements to the index of the hash table. For example, if you want to insert an element x into the table, first check whether the position h1(x) in the table is empty. If it is, put it in; if not, then check whether the position h2(x) is empty. If it is empty, put it in; if it is not empty, take out the original element in h2(x), put the new element in, and then repeat this process for the taken elements until all elements are inserted.

[0031] The way to randomly generate a hash table is to randomly sample |CT| elements from the cyclic group G. We call this set R, and let CT[i] = DPF.Gen(1 λ ,R[i]), and then send CT to Server 1 and Server 2.

[0032] Client Initialization Collection Data provider initialization collection

[0033] During the client update phase, the secure computation pipeline processes the client's new input and returns the result to the client. The specific steps are as follows:

[0034] 1) The client has a newly added element set X'. The client updates the set X = X ∪ X'. After the client generates the blinded key α, it first performs a i ∈G is blinded to obtain And will collect Sent to server 1 and server 2 respectively.

[0035] 2) Server 1 receives Then, use your own key share k p1 calculate And return to the client; the execution process of server 2 is the same as that of server 1, except that it uses its own key share to calculate Sent to the client.

[0036] 3) For and Each element in and The client calculates the final result of OPRF get for Each element in First insert it into the cuckoo hash table CT, then calculate the DPF key Finally, we get two sets K containing DPF keys. 1 ,K 2 , the client will K 1 Send to server 1 and K 2 Sending Server 2.

[0037] 4) For the sake of convenience, assume that the data provider first sends To server 1 and server 2; server 1 first initializes a Boolean array Res1 of all 0s. Each element in Extract its K 1 The corresponding position in Key And calculate:

[0038]

[0039]

[0040] in, Represents the exclusive OR operation;

[0041] Then Res1 is sent to the client; the operations of Server 2 and Server 1 are symmetrical, and Server 2 will send the corresponding Res2 to the client after the calculation is completed.

[0042] 5) After the client receives Res1 from server 1 and Res2 from server 2, the client can get the result If Res[i] = 1, it means that the element at position i in CT is in the intersection, because if the data provider and the client have the same element z, it is assumed that the client inserts it into CT at position i. When the server looks for When DPF.Eval is calculated, the output value is 1 according to the correctness of DPF, while the output value is 0 when calculating other points. The value obtained after the XOR operation is still 1; if Res[i] = 0, it means that the element at this position is outside the intersection.

[0043] In the above steps, the process of step 3 is as follows Figure 3 As shown, the process of step 4 is as follows Figure 4 shown.

[0044] During the data provider update phase, the secure computation pipeline processes the new input from the data provider and returns the result to the client. The specific steps are as follows:

[0045] 1) The data provider inputs a new element set Y' and then updates Y = Y ∪ Y'. The data provider uses its own encryption key k p , encrypt your own elements: Get Collection Sent to servers 1 and 2.

[0046] 2) Assume that the client has sent the DPF key set K 1 ,K 2 To servers 1 and 2; Server 1 receives the set

[0047] Later, for each element Extract its K 1 The corresponding position in Key And calculate,

[0048]

[0049]

[0050] Then Res1 is sent to the client; the operations of Server 2 and Server 1 are symmetrical, and Server 2 will send the corresponding Res2 to the client after the calculation is completed.

[0051] 3) After the client receives Res1 from server 1 and Res2 from server 2, it can get the result If Res[i]=1, it means that the element at the i-th position in the cuckoo hash table is in the intersection, otherwise it is outside the intersection.

[0052] In the above steps, the process of step 2 is as follows Figure 4 shown.

[0053] This solution ensures the confidentiality and integrity of data and avoids the risk of data leakage and security vulnerabilities, making it particularly effective in processing large-scale streaming data and real-time update scenarios.

[0054] Finally, it should be noted that the above embodiments are only used to illustrate the technical solution of the present invention rather than to limit it. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solution of the present invention can be modified without departing from the purpose and scope of the technical solution, which should be included in the scope of the claims of the present invention.

Claims

1. An unbalanced private set intersection system supporting real-time set update, characterized by: The system includes three entity units: a data provider, a client, and a secure processing pipeline; the data provider and the client respectively send encrypted data streams to the secure processing pipeline, and the client hopes to know the intersection of its input set and the data provider's input set; the secure processing pipeline is composed of two non-collusive servers, which are core computing components for securely processing data and providing intersection results; there is no direct communication between the client and the data provider, and the execution protocol of this system includes an initialization phase, a client update phase, and a data provider update phase.

2. According to claim 1, the unbalanced private set intersection system supporting real-time set update is characterized by: The initialization phase is only performed when the parties establish communication for the first time, and includes: the data provider generates an encryption key and generates a corresponding additional share and sends it to the security processing pipeline; the client randomly generates a hash table and sends it to the security processing pipeline.

3. The unbalanced private set intersection system supporting real-time set update according to claim 2, characterized in that: The client update phase is a phase in which the client updates data and receives results, including: the client and the security processing pipeline interact inadvertently to obtain an encrypted form of the newly added element; the client updates the hash table and sends it to the security processing pipeline, the hash table is a data structure for storing and processing elements of the client input set, so as to facilitate subsequent intersection calculations; the security processing pipeline calculates the intersection and sends the result to the client.

4. According to claim 3, the unbalanced private set intersection system supporting real-time set update is characterized in that: The data provider update phase is a phase in which the data provider updates data and pushes results to the client, including: the data provider encrypts the newly added elements and sends them to the security processing pipeline; the security processing pipeline calculates the intersection and sends the results to the client.

5. According to claim 1, the unbalanced private set intersection system supporting real-time set update is characterized by: The encrypted data stream is generated by a specific encryption algorithm to ensure the confidentiality and integrity of the data.

6. The unbalanced private set intersection system supporting real-time set update according to claim 3, characterized in that: The oblivious interaction is achieved through oblivious pseudorandom functions (OPRF) or other similar privacy protection technologies to protect the privacy of the newly added elements.

7. The unbalanced private set intersection system supporting real-time set update according to claim 3, characterized in that: The intersection result is calculated through secure multi-party computing technology or other similar privacy protection technology to ensure the confidentiality of the calculation process and the accuracy of the result.

Images