Privacy set intersection data processing method and system based on nested cuckoo filtering

By using nested cuckoo filtering method in the privacy set interception protocol, data insertion is solved by using the candidate bucket location calculated by hash function, and the problem of low space utilization in the existing technology is achieved, and higher storage efficiency and Query efficiency.

CN119066709APending Publication Date: 2024-12-03UNIV OF JINAN
View PDF 0 Cites 3 Cited by

Patent Information

Application Number
CN202411194011.8
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-08-28
Publication Date
2024-12-03

AI Technical Summary

Technical Problem

In the existing privacy set interception protocol, the space utilization rate of the one-dimensional cuckoo hash used is not high, resulting in high storage costs and low query efficiency under high loads.

Method used

Using nested cuckoo filtering method, two candidate bucket positions calculated by the first set of hash functions are inserted into the hash table, and the cuckoo insertion operation is performed in the hash table, using the preset second The group hash function determines the candidate bucket location to improve space utilization.

Benefits of technology

Without revealing the privacy data of participants, the storage and computing costs of clients and servers are reduced, and the space utilization is improved. The experimental results show that the space utilization can reach 80% or higher.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119066709A_ABST
    Figure CN119066709A_ABST
Patent Text Reader

Abstract

The invention belongs to the technical field of data processing, and provides a privacy set intersection data processing method and system based on nested cuckoo filtering, for each element to be inserted into a first participant, traversing all entries under two candidate bucket positions determined by a preset first group of hash functions; for the set elements to be inserted into the second participant, the elements in the set elements are inserted into a hash table by using the two candidate bucket positions calculated by the first group of hash functions, and the column range of the hash table is the same as the mapping range of the first group of hash functions; for each element of each column of hash table, executing cuckoo insertion operation in the hash table by using two candidate bucket positions determined by a preset second group of hash functions; according to the method, data of both parties can be preprocessed on the premise of not leaking private data of the parties, so that the storage and calculation cost of the client and the server is reduced.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present invention belongs to the technical field of data processing, and in particular relates to a privacy set intersection data processing method and system based on nested cuckoo filtering. Background Art

[0002] Private Set Intersection (PSI) is a cryptographic technique that allows two or more parties to compute the intersection of their sets without revealing the contents of their respective sets.

[0003] Through reasonable data preprocessing, the efficiency, accuracy and security of the privacy set intersection protocol can be improved; for example, data hashing can be performed in advance. By converting the data into a hash value of fixed length, comparison can be performed without exposing the original data. Because the hash value is usually shorter than the original data and has a fixed length, it is conducive to accelerating the execution of the privacy set intersection protocol; however, the space utilization rate of the currently used one-dimensional cuckoo hashing is not high, the space storage cost is high, and the query efficiency under high load is not high. Summary of the invention

[0004] In order to solve the above problems, the present invention proposes a privacy set intersection data processing method and system based on nested cuckoo filtering. For the set elements to be inserted into the second participant, the present invention uses two candidate bucket positions calculated by a first group of hash functions to insert the elements in the set elements into a hash table, and the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, a cuckoo insertion operation is performed in the hash table using two candidate bucket positions determined by a preset second group of hash functions; the data of the two participants can be pre-processed without leaking the privacy data of the participants, thereby reducing the storage and computing costs of the client and the server.

[0005] In order to achieve the above object, the present invention is implemented through the following technical solutions:

[0006] In a first aspect, the present invention provides a privacy set intersection data processing method based on nested cuckoo filtering, comprising:

[0007] Obtaining a set element that participates in the intersection of the privacy sets of the first participant and the second participant;

[0008] For each element to be inserted into the first participant, traverse all entries under the two candidate bucket positions determined by the preset first set of hash functions;

[0009] For the set elements to be inserted into the second participant, the two candidate bucket positions calculated by the first group of hash functions are used to insert the elements in the set elements into a hash table, and the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, a cuckoo insertion operation is performed in the hash table using the two candidate bucket positions determined by the preset second group of hash functions.

[0010] Furthermore, when traversing all entries under the two candidate bucket positions determined by the preset first set of hash functions: if there is an entry in one of the candidate buckets that is empty, an element is inserted; if all entries are not empty, an element is randomly kicked out and the existing element is inserted.

[0011] Furthermore, the kicked out element traverses all entries under another candidate bucket position; if there is an empty entry, the element is directly inserted; if all entries are not empty, an element is randomly kicked out and the previously kicked out element is inserted; the kicked out element repeats the traversal process until the number of kicked out elements reaches the preset maximum number of cycles.

[0012] Furthermore, when the cuckoo insertion operation is performed in the hash table using the two candidate bucket positions determined by the preset second set of hash functions: all entries under the two candidate bucket positions calculated by the second set of hash functions for each element are traversed; if one of the candidate buckets has an empty entry, the fingerprint of the element is inserted; if all entries are not empty, the fingerprint of an element is randomly kicked out and the fingerprint of the existing element is inserted.

[0013] Furthermore, the fingerprint of the kicked out element calculates another candidate bucket position and traverses all entries; if there is an empty entry, the fingerprint of the kicked out element is inserted; if all entries are not empty, the fingerprint of an element is randomly kicked out again, and then the fingerprint of the previously kicked out element is inserted, and the fingerprint of the kicked out element again repeats the traversal process until the number of kicked out element fingerprints reaches the preset maximum number of cycles.

[0014] Furthermore, the first participant is a client, and the second participant is a server.

[0015] In a second aspect, the present invention further provides a privacy set intersection data processing system based on nested cuckoo filtering, comprising:

[0016] The data collection module is configured to: obtain a set element participating in the intersection of the privacy sets of the first participant and the second participant;

[0017] A first processing module is configured to: for each element to be inserted into the first participant, traverse all entries under two candidate bucket positions determined by a preset first set of hash functions;

[0018] The second processing module is configured to: for the set elements to be inserted into the second participant, use the two candidate bucket positions calculated by the first group of hash functions to insert the elements in the set elements into a hash table, the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, perform a cuckoo insertion operation in the hash table using the two candidate bucket positions determined by the preset second group of hash functions.

[0019] In a third aspect, the present invention further provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in the first aspect.

[0020] In a fourth aspect, the present invention further provides an electronic device, comprising a memory, a processor, and a computer program stored in the memory and capable of running on the processor, wherein when the processor executes the program, the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in the first aspect are implemented.

[0021] In a fifth aspect, the present invention further provides a computer program product, which includes a computer program. When the computer program is executed by a processor, the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in the first aspect are implemented.

[0022] Compared with the prior art, the present invention has the following beneficial effects:

[0023] In the present invention, for each element to be inserted into the first participant, all entries under the two candidate bucket positions determined by the preset first group of hash functions are traversed; for the set element to be inserted into the second participant, the two candidate bucket positions calculated by the first group of hash functions are used to insert the elements in the set element into a hash table, and the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, the cuckoo insertion operation is performed in the hash table using the two candidate bucket positions determined by the preset second group of hash functions; the data of the two participants can be preprocessed without leaking the privacy data of the participants, thereby reducing the storage and computing costs of the client and the server.

[0024] In the present invention, the number of hash functions (candidate buckets) is set to 2, the number of entries in the bucket is 4 / 8, the fingerprint length is 16 bits, and when |X|=10000, the experimental results show that the space utilization rate of the nested cuckoo filter proposed in the present invention can reach 80% or higher, while the traditional one-dimensional cuckoo hash can only achieve 50% space utilization rate. BRIEF DESCRIPTION OF THE DRAWINGS

[0025] The drawings in the specification that constitute a part of this embodiment are used to provide a further understanding of this embodiment. The schematic embodiments of this embodiment and their descriptions are used to explain this embodiment and do not constitute improper limitations on this embodiment.

[0026] Figure 1 The client filter of Embodiment 1 of the present invention;

[0027] Figure 2 The server filter of embodiment 1 of the present invention;

[0028] Figure 3 is the load factor of the nested cuckoo filter under different bucket entries in Example 1 of the present invention (|X|=10000, f=16bit);

[0029] Figure 4 1 is a comparison of the space utilization of the nested cuckoo filter and the cuckoo hash in Example 1 of the present invention (|X|=10000, f=16bit). DETAILED DESCRIPTION

[0030] The present invention will be further described below in conjunction with the accompanying drawings and embodiments.

[0031] It should be noted that the following detailed descriptions are exemplary and are intended to provide further explanation of the present application. Unless otherwise specified, all technical and scientific terms used herein have the same meanings as those commonly understood by those skilled in the art to which the present application belongs.

[0032] The Cuckoo Filter is an approximate set membership test data structure proposed based on the Cuckoo Hash Algorithm to replace the Bloom filter. It has higher search performance than the traditional Bloom filter (even under high load), supports dynamic addition and deletion of items, and has better space utilization than the Bloom filter when the false positive rate is less than 3%. In addition, since the data filter stores the fingerprint of the data instead of the original data, the space storage cost of the participants is reduced.

[0033] Embodiment 1:

[0034] With the development of information technology and the advent of the big data era, data sharing and cooperation have become increasingly important. However, in the big data era, the amount of data is often very large, and directly processing this data will consume a lot of computing resources and time. Data preprocessing technology can reduce data storage space and transmission time and improve data processing efficiency while ensuring data quality. In addition, data security is crucial in data sharing and cooperation. Through technical means such as data encryption and desensitization in data preprocessing, data security can be guaranteed to prevent data leakage and abuse. In many cases, the sensitivity of data and the need for privacy protection make it unrealistic to directly share data. For example, in the medical field, different hospitals may want to cooperate in studying the prevalence of a certain disease, but the patient data of each hospital is very sensitive and cannot be shared directly.

[0035] In the field of e-commerce, different companies want to learn about common customers through cooperation, but they are unwilling to disclose their respective customer lists. Therefore, researchers have proposed the Private Set Intersection (PSI) technology. Private Set Intersection is a cryptographic technology that allows two or more parties to calculate the intersection of their sets without exposing the contents of their respective sets. Private Set Intersection can be divided into two-party or multi-party Private Set Intersection protocols according to the number of participants. The two-party protocol can be divided into balanced Private Set Intersection according to the size of the sets involved by both parties: the sizes of the participating sets of both parties are the same or unbalanced Private Set Intersection: the participating set of one party is much larger than that of the other party. Private Set Intersection technology realizes the intersection operation between sets while protecting privacy, and has broad application prospects, such as private contact discovery, advertising rate conversion, etc.

[0036] The efficiency, accuracy and security of the PSI protocol can be improved through reasonable data preprocessing. For example, data hashing can be performed in advance. By converting the data into a hash value of fixed length, it can be compared without exposing the original data. Hash processing in the data preprocessing stage helps reduce the amount of calculation and communication, because the hash value is usually shorter than the original data and has a fixed length, which is conducive to accelerating the execution of the PSI protocol;

[0037] However, the space utilization rate of the currently used one-dimensional cuckoo hash is not high, the space storage cost is high, and the query efficiency under high load is not high. Based on this, this embodiment proposes a privacy set intersection data processing method based on nested cuckoo filtering, which can pre-process the data of both the server and the client without leaking the privacy data of the participants, encode and encrypt the elements to be input, and reduce the element input size of the subsequent protocol through the server-client nested cuckoo filter form, thereby reducing the calculation and communication costs of the privacy set intersection protocol, and reducing the space storage cost of the elements in the database, and improving the space utilization of the database.

[0038] Optionally, this embodiment involves two parties, a client and a server, wherein the client input set can be set to X = {x1, x2, ..., x n}, the server input set can be set to Y = {y1, y2, ..., y n The cuckoo filter sets the number of candidate buckets to 2 and the number of entries in the bucket to b. The client and the server jointly discuss the hash functions H1 and H2 and the hash function F for calculating the fingerprint; the mapping range of the hash function H1 is {1, 2, ..., l1}, and the mapping range of the hash function H2 is {1, 2, ..., l2}. The specific process is as follows:

[0039] S1, such as Figure 1 As shown, the processing of the first party client:

[0040] S1.1. The client first calculates and saves the required fingerprints of its own set elements, the candidate bucket positions determined by the two sets of hash functions, and other information.

[0041] Optional, client-side calculation element x i Fingerprint Determine the candidate bucket position P1=H1(x i )and And determine the candidate bucket position P3=H2(x i )and and save it.

[0042] S1.2. The client starts traversing from the first element in the local collection and executes the insertion process of the cuckoo filter; optionally, for each element to be inserted, it traverses all entries under the two candidate bucket positions determined by the first set of hash functions, and inserts the element if any entry is empty; if all entries are not empty, a random element is kicked out and the existing element is inserted into the filter.

[0043] Specifically, the client traverses the set X and performs a cuckoo filter insertion operation: for each element x i First, traverse the first candidate bucket P1=H1(x i ) If any entry is empty, insert element x i ; If all entries in the first candidate bucket are not empty, traverse the second candidate bucket If any entry is empty, insert element x i ; If all entries are not empty, randomly kick out an element x j And the element x i Insert the kick-out position.

[0044] S1.3, the kicked element traverses all entries under the other candidate bucket position. If there is an empty entry, the element is directly inserted; if all entries are not empty, an element is randomly kicked out and inserted into the filter. The kicked element repeats the above process until the number of kicks reaches the maximum number of cycles. At this time, the insertion process is terminated and the filter is full. The setting of the maximum number of cycles can avoid infinite element migration.

[0045] Specific optional, kicked out element x j The position of another candidate bucket is calculated by the original position and the fingerprint processed by the first set of hash functions. For example, if the element x j From the candidate bucket P1=H1(x j ) is kicked out and another candidate bucket position is calculated Then traverse all entries under P2, and insert element x if any entry is empty j , if there is no empty entry, randomly kick out an element x k And the element x j Insert the filter, and the element x is kicked out for the second time k Repeat the above steps until the number of kick-outs reaches the maximum number of cycles, at which point the insertion process is terminated and the filter is full.

[0046] S2, such as Figure 2 As shown, the processing on the server side of the second participant is:

[0047] S2.1. The server also calculates and saves the required fingerprints of its own set elements, the candidate bucket positions determined by the two sets of hash functions, and other information.

[0048] Optional, server-side calculation element y i Fingerprint Determine the candidate bucket position P1=H1(y i )and And determine the candidate bucket position P3=H2(y i )and and save it.

[0049] S2.2. The server first uses the two candidate bucket positions calculated by the first set of hash functions to insert the elements in its local collection into a simple hash table. The column range of this simple hash table is the same as the range mapped by the first set of hash functions. At this time, the elements on the server will be inserted twice.

[0050] Specifically, the server side uses the first set of hash functions to calculate the two candidate bucket positions P1=H1(y i )and Then insert the elements in the collection into the simple hash table ST. The simple hash table ST should have l1 columns equal to the index space mapped by the first set of hash functions. At this time, the element y on the server side i Will be inserted twice.

[0051] S2.3. For each element in each column of the hash table, perform a cuckoo insertion operation in that column of the simple hash table using the two candidate bucket positions determined by the second set of hash functions: traverse all entries under the two candidate bucket positions calculated by the second set of hash functions for each element. If there is an empty entry, insert the fingerprint of this element into the filter. If all entries are not empty, randomly kick out the fingerprint of an element and insert the fingerprint of the existing element into it.

[0052] Specific optional, for hash table ST i Each element in each column y i , the two candidate bucket positions P3=H2(y i )and In that column a simple hash table ST i Execute the cuckoo insertion operation: first traverse the first candidate bucket position P3 = H2 (y i ) If there is an empty entry, insert the current element y i Fingerprint f y If all entries under the first candidate bucket position are not empty, traverse the second candidate bucket position All entries below, if there is an empty entry, insert the current element y i Fingerprint f y , if all entries are not empty, randomly select an element y j Kick its fingerprint information out of the filter.

[0053] S2.4. The fingerprint of the kicked out element calculates another candidate bucket position and traverses all the entries under it. If there is an empty entry, the fingerprint of this element is inserted into the filter. If all entries are not empty, the fingerprint of an element is randomly kicked out again and the fingerprint of this element is inserted again. The fingerprint kicked out of the filter again repeats the same steps as the above operation until the maximum number of cycles is reached.

[0054] Specific optional, the element y to be kicked out j The position of another candidate bucket is calculated by using the current position being kicked out and its own fingerprint information. The specific steps are consistent with step S1.3 in the client.

[0055] In order to illustrate the advantages of the nested cuckoo filter proposed in this embodiment, this embodiment designs an experiment for verification. Optionally, the number of hash functions (candidate buckets) is set to 2, the number of entries in the bucket is 4 / 8, the fingerprint length is 16 bits, and |X|=10000. Figure 3 and Figure 4 As shown, the experimental results show that the space utilization load factor of the nested cuckoo filter proposed in this embodiment achieves the expected results, averaging 80% / 90%, while the one-dimensional cuckoo hash can only achieve 50% space utilization; the space storage cost of the nested cuckoo filter is reduced by (l-16)*n bit on the client side and (l-32)*nbit on the server side compared to the cuckoo hash that directly stores the original data; where l is the element length and n is the number of elements.

[0056] The nested cuckoo filter proposed in this embodiment can be applied to the privacy set intersection protocol. Starting from the first element of the client and the server, assuming that the client input element is e, the client calculates the fingerprint f of element e e And the index set Then construct the EIV vector from the index set, so that for i∈{1,...,N}\{j} i =Enc(0),EIV j =Enc; finally, the encrypted fingerprint Enc(f e ) and the EIV vector are sent to the server, and the server determines which column of the hash table ST to add based on the index of the filter where the client element is located. i As input, by combining the EIV vector with the ST i Perform a dot product operation to get c← <EIV,ST i >, then perform homomorphic subtraction between c and the encrypted fingerprint to obtain Finally, c d Perform vector multiplication with a non-zero random number r to obtain c f ←c d □r and sent to the client, which then fDecryption is performed. If the decryption result is 0, it means that element e is an intersection element. The optional protocol flow is as follows:

[0057] Parameter definition:

[0058] The client set of participants is X, and the server set is Y;

[0059] The number of entries in the bucket b;

[0060] Hash functions H1, H2, fingerprint function F;

[0061] Client: X = {x1, x2, ..., x n}, server: Y = {y1, y2, ..., y n};

[0062] Client-side preprocessing:

[0063] f x =F(x i )

[0064] P1=H1(x i ),

[0065] P3=H2(x i ),

[0066] Insert the client element into the filter CF.Insert(X) using the first set of hash functions H1;

[0067] Server-side preprocessing:

[0068] f y =F(y i )

[0069] P1=H1(y i ),

[0070] P3=H2(y i ),

[0071] The server-side collection elements are inserted into the simple hash table ST using the first set of hash functions H1. i Then ST i The elements in each column of are inserted into the filter using the second set of hash functions H2;

[0072] CF.Insert(Y)

[0073] Homomorphic intersection:

[0074] The client traverses the input collection element x i ;

[0075] Calculate fingerprint f x =F(x i ), index set J = {P3 = H2 (x i ),

[0076] Construct EIV vector from index set;

[0077] For i∈{1,...,N}\{j}, let EIV i =Enc(0),EIV j =Enc(1);

[0078] Send the encrypted fingerprint and EIV vector to the server;

[0079] Enc(f x )、EIV

[0080] With x i The ST corresponding to the index i Perform a dot product operation on the input and the EIV vector to get c;

[0081] c← <EIV,ST i >

[0082] Combine c and Enc(f x ) do homomorphic subtraction (addition point multiplication -1) to get c d ;

[0083]

[0084] Obfuscate c by doing a dot product d Get c f And return it to the client;

[0085] r←$M{0}

[0086]

[0087] c f

[0088] The client decrypts the received c f If the result is 0 then x i is the intersection element;

[0089] If Dec(c f )==0:

[0090] x i is the intersection element.

[0091] Through the data preprocessing method in this embodiment, the nested cuckoo filter can preprocess the data of both parties without leaking the privacy data of the parties, reducing the storage and computing costs of the client and the server. The space utilization rate of the traditional one-dimensional cuckoo hash is consistent with that of the general hash and can only reach 50%. The nested cuckoo filter proposed in this paper can theoretically achieve a space utilization rate of up to 95% because it uses a multi-way association table, and still has high query efficiency under high load.

[0092] Embodiment 2:

[0093] This embodiment provides a privacy set intersection data processing system based on nested cuckoo filtering, including:

[0094] The data collection module is configured to: obtain a set element participating in the intersection of the privacy sets of the first participant and the second participant;

[0095] A first processing module is configured to: for each element to be inserted into the first participant, traverse all entries under two candidate bucket positions determined by a preset first set of hash functions;

[0096] The second processing module is configured to: for the set elements to be inserted into the second participant, use the two candidate bucket positions calculated by the first group of hash functions to insert the elements in the set elements into a hash table, the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, perform a cuckoo insertion operation in the hash table using the two candidate bucket positions determined by the preset second group of hash functions.

[0097] The working method of the system is the same as the privacy set intersection data processing method based on nested cuckoo filtering in Example 1, and will not be repeated here.

[0098] Embodiment 3:

[0099] This embodiment provides a computer-readable storage medium on which a computer program is stored. When the program is executed by a processor, the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in Example 1 are implemented.

[0100] Embodiment 4:

[0101] This embodiment provides an electronic device, including a memory, a processor, and a computer program stored in the memory and capable of running on the processor. When the processor executes the program, the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in Example 1 are implemented.

[0102] Embodiment 5:

[0103] This embodiment provides a computer program product, which includes a computer program. When the computer program is executed by a processor, the steps of the privacy set intersection data processing method based on nested cuckoo filtering described in Embodiment 1 are implemented.

[0104] The above description is only a preferred embodiment of the present embodiment and is not intended to limit the present embodiment. For those skilled in the art, the present embodiment may have various modifications and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present embodiment shall be included in the protection scope of the present embodiment.

Claims

1. A privacy set intersection data processing method based on nested cuckoo filtering, characterized in that: include: Obtaining a set element that participates in the intersection of the privacy sets of the first participant and the second participant; For each element to be inserted into the first participant, traverse all entries under the two candidate bucket positions determined by the preset first set of hash functions; For the set elements to be inserted into the second participant, the two candidate bucket positions calculated by the first group of hash functions are used to insert the elements in the set elements into a hash table, and the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, a cuckoo insertion operation is performed in the hash table using the two candidate bucket positions determined by the preset second group of hash functions.

2. The method for processing privacy set intersection data based on nested cuckoo filtering according to claim 1, characterized in that: When traversing all entries under the two candidate bucket positions determined by the preset first set of hash functions: if there is an entry in one of the candidate buckets that is empty, insert an element; if all entries are not empty, randomly kick out an element and insert the existing element.

3. The privacy set intersection data processing method based on nested cuckoo filtering as claimed in claim 2, characterized in that: The kicked out element traverses all entries under the position of another candidate bucket; if there is an empty entry, the element is directly inserted; if all entries are not empty, an element is randomly kicked out and the previously kicked out element is inserted; the kicked out element repeats the traversal process until the number of kicked out elements reaches the preset maximum number of cycles.

4. The method for processing privacy set intersection data based on nested cuckoo filtering according to claim 1, characterized in that: When performing a cuckoo insertion operation in the hash table using the two candidate bucket positions determined by the preset second set of hash functions: traverse all entries under the two candidate bucket positions calculated by the second set of hash functions for each element; if one of the candidate buckets has an empty entry, insert the element's fingerprint; if all entries are not empty, randomly kick out an element's fingerprint and insert the existing element's fingerprint.

5. The method for processing privacy set intersection data based on nested cuckoo filtering as claimed in claim 4, characterized in that: The fingerprint of the kicked element calculates another candidate bucket position and traverses all entries; if there is an empty entry, the fingerprint of the kicked element is inserted; if all entries are not empty, the fingerprint of an element is randomly kicked out again, and then the fingerprint of the previously kicked out element is inserted, and the fingerprint of the kicked out element again repeats the traversal process until the number of kicked out element fingerprints reaches the preset maximum number of cycles.

6. The method for processing privacy set intersection data based on nested cuckoo filtering according to claim 1, characterized in that: The first participant is a client, and the second participant is a server.

7. A privacy set intersection data processing system based on nested cuckoo filtering, characterized in that: include: The data collection module is configured to: obtain a set element participating in the intersection of the privacy sets of the first participant and the second participant; A first processing module is configured to: for each element to be inserted into the first participant, traverse all entries under two candidate bucket positions determined by a preset first set of hash functions; The second processing module is configured to: for the set elements to be inserted into the second participant, use the two candidate bucket positions calculated by the first group of hash functions to insert the elements in the set elements into a hash table, the column range of the hash table is the same as the range mapped by the first group of hash functions; for each element in each column of the hash table, perform a cuckoo insertion operation in the hash table using the two candidate bucket positions determined by the preset second group of hash functions.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the steps of the privacy set intersection data processing method based on nested cuckoo filtering as described in any one of claims 1 to 6 are implemented.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and capable of running on the processor, characterized in that: When the processor executes the program, the steps of the privacy set intersection data processing method based on nested cuckoo filtering as described in any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that The computer program product includes a computer program, and when the computer program is executed by a processor, the steps of the privacy set intersection data processing method based on nested cuckoo filtering are implemented as described in any one of claims 1 to 6.

Citation Information

Cited By

  • Safe non-interactive comparison method and device for multi-party set intersection

    CN119519933A

  • Unbalanced privacy set intersection calculation method, system, device and medium

    CN120658524A

  • A non-equilibrium privacy set intersection computing method, system, device and medium

    CN120658524B