Private information retrieval method supporting multiple parties
By generating union and intersection, the querying party and the queried party protect the anonymity of query conditions and data sources in multi-party hidden queries, achieving highly secure multi-party hidden queries.
Patent Information
- Application Number
- PCT/CN2023/136357
- Authority / Receiving Office
- WO · WO
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-05-25
- Filing Date
- 2023-12-05
- Publication Date
- 2024-11-28
AI Technical Summary
Existing technologies cannot achieve highly secure multi-party anonymous queries. The querying party cannot protect the anonymity of query conditions across multiple data sources, and the queried party cannot determine the query conditions.
The corresponding local ciphertext ID is generated interactively, and the union and intersection are calculated. The querying party generates a vector of the same length as the union to fill the intersection position, and each queried party generates a corresponding vector to fill the union position. The sums are then multiplied by the query direction vector to obtain the final query result.
It achieves highly secure multi-party anonymous queries, where the querying party can only obtain the results corresponding to the query conditions and cannot lock the specific data source, thus ensuring the anonymity of the data source.
Smart Images

Figure CN2023136357_28112024_PF_FP_ABST
Abstract
Description
A hidden query method supporting multiple parties Technical Field
[0001] The present invention relates to the field of privacy computing technology, and in particular to a method for concealed querying that supports multiple parties. Background Art
[0002] Privacy computing refers to a collection of technologies that implement data analysis and computing while protecting the data from external leaks, achieving the goal of making data "available but invisible." It also aims to transform and unlock the value of data while fully protecting data and privacy. Anonymous querying protects the data of both the querying and queried parties, ensuring that after a query, the querying party, in addition to obtaining the results corresponding to the query conditions, cannot obtain information about other queried parties, while the queried party remains unaware of the querying party's conditions. Multi-party anonymous querying is defined here as a querying party using query conditions to query multiple data sources. It is possible that some data sources will match the results, and when returning the results, all results matching the same query conditions are summed, as shown in Figure 1.
[0003] Existing technologies generally target two-party anonymous queries. The "OT-based Multi-party Anonymous Identity Query Protocol" incorporates obfuscation conditions into the query conditions, preventing the queried party from determining the query conditions. However, the queried party can still narrow down the query conditions within a narrow range. Alternatively, the querying party can simply perform a two-party anonymous query with each queried party separately, and then sum the results. This way, the querying party can still clearly determine which data sources it retrieved the results from and what the results are. Existing technologies cannot achieve highly secure anonymous queries involving more than two parties (or multiple parties).
[0004] Summary of the Invention
[0005] In order to overcome the above problems or at least partially solve the above problems, an embodiment of the present invention provides a method for hidden query supporting multiple parties, which can realize highly secure multi-party hidden query.
[0006] The embodiment of the present invention is achieved as follows:
[0007] In a first aspect, an embodiment of the present invention provides a method for supporting multi-party hidden query, comprising the following steps:
[0008] Through interaction, the querying party and multiple queried parties generate corresponding local ID ciphertexts;
[0009] The querying party obtains the ciphertext union of the IDs of all queried parties through encryption, and obtains the intersection of the querying party's local ID ciphertext set and the union;
[0010] The querying party generates a vector of the same length as the union, fills the positions of the intersection elements with 1, and fills the remaining positions with 0;
[0011] Each queried party generates a corresponding vector of the same length as the union, fills the local ID ciphertext at the position in the union with its corresponding value, and fills the remaining positions with 0;
[0012] The vectors obtained by each queried party are summed up and then multiplied with the vector of the querying party to obtain the final query result.
[0013] In order to solve the problems in the prior art, the present invention uses an encryption method to allow the querying party to obtain the union of the ciphertext of the queried party's ID (here, only the union result can be obtained, but the specific element cannot be located which party it comes from), and then the querying party and the queried party map their own IDs to the corresponding positions of the union, and finally obtain the final result on the aligned data. Based on the present invention, the querying party can only obtain the final result corresponding to each query condition (the sum of the found values), but cannot know which data source the query condition can specifically match, let alone the corresponding value of the query condition in a certain data source. The queried party (data source) knows nothing, and cannot lock the query condition in a small range. The present invention can achieve highly secure multi-party hidden queries.
[0014] Based on the first aspect, in some embodiments of the present invention, the method of allowing a querying party to obtain the ciphertext union of the IDs of each queried party in an encrypted manner and calculating the intersection of the querying party's local ciphertext set of IDs and the union includes the following steps:
[0015] The querying party and each queried party jointly determine three hash functions h1, h2, and h3, and use cuckoo hashing to map the querying party's n data into a hash table L;
[0016] The query party initializes a random bit matrix T, the size of the matrix T is n0*k, and n0 is the length of the hash table;
[0017] Use the random encoding function C to encode the query party's hash table L, and each element in the hash table L is encoded as a bit string of length k;
[0018] Each queried party shares a random bit string p, the number of elements in p is the same as the number of columns k in the matrix T of the querying party S;
[0019] Based on the OT protocol, the querying party performs oblivious transmission with each queried party, where the querying party acts as the sender and each queried party acts as the receiver.
[0020] Obtain the pseudo-random number of the querying party based on the OPRF protocol, and determine the pseudo-random number of each queried party;
[0021] The pseudo-random numbers of each queried party are secretly shared. Each pseudo-random number is divided into three pieces and distributed to each queried party respectively. The pieced information is then concatenated into a long vector.
[0022] Each queried party shares a random seed, uses the seed to scramble the locally obtained shard information, and then sends the shard information to the querying party;
[0023] The querying party performs decryption and deduplication to obtain the union U of the pseudo-random numbers of each queried party, and then uses its own pseudo-random number to intersect the union U to obtain the corresponding intersection Intersect.
[0024] Based on the first aspect, in some embodiments of the present invention, the querying party generates a vector of the same length as the union, fills the positions of the intersection elements with 1, and fills the remaining positions with 0, including the following steps:
[0025] After the query party obtains the union U and the intersection Intersect with U, it locally generates a vector U_pos and U_tag of the same length as U, where U_pos is an index starting from 1 and extending to the same length as U; the position of the intersection element in U_tag is 1, and the rest of the positions are 0.
[0026] Based on the first aspect, in some embodiments of the present invention, the method for supporting multi-party hidden query further includes the following steps:
[0027] The querying party concatenates U and U_pos into a two-column dataset Data_U.
[0028] Based on the first aspect, in some embodiments of the present invention, each queried party generates a corresponding vector of the same length as the union, fills the position of the local ID ciphertext in the union with its corresponding value, and fills the remaining positions with 0, including the following steps:
[0029] Perform a hidden query between each queried party and the querying party. Each pseudo-random number of each querying party will obtain a corresponding query result, which is the position of the pseudo-random number in the union U.
[0030] Each queried party generates a vector of the same length as the union U, and fills the corresponding position with the corresponding value according to the query result, and fills the remaining positions with 0.
[0031] Based on the first aspect, in some embodiments of the present invention, the method of summing the vectors obtained by each queried party and then multiplying the sum by the querying party's vector to obtain the final query result includes the following steps:
[0032] The vectors of each queried party are summed using secret sharing, and each queried party holds a shard;
[0033] The querying party uses the Paillier encryption method to encrypt the U_tag to obtain the Enc_tag and sends it to the queried party;
[0034] The queried party multiplies the held fragments with Enc_tag to obtain and send the corresponding multiple result vectors to the querying party;
[0035] The querying party sums and decrypts multiple result vectors to obtain the final plaintext query result.
[0036] Based on the first aspect, in some embodiments of the present invention, the method of allowing a querying party to obtain the ciphertext union of the IDs of each queried party in an encrypted manner and calculating the intersection of the querying party's local ciphertext set of IDs and the union includes the following steps:
[0037] The querying party hashes the local ID, selects a random number as the private key, encrypts the local ID, obtains the corresponding querying party's ID ciphertext, and sends the ID ciphertext to any one of the multiple queried parties;
[0038] Each queried party first hashes its local ID, then shares a random number, uses the random number as its own private key, and uses the private key to encrypt the hash value of the local ID to obtain the corresponding queried party's ID ciphertext;
[0039] The party that obtains the ciphertext of the inquiring party's ID encrypts the ciphertext of the inquiring party's ID with its private key, obtains and sends the corresponding ciphertext data to the inquiring party;
[0040] The querying party obtains the union U of the queried parties and encrypts the union U using the querying party's private key to obtain the querying party's local ID ciphertext set;
[0041] Obtain the intersection of the querying party's local ID ciphertext set and the union.
[0042] In a second aspect, an embodiment of the present application provides an electronic device comprising a memory for storing one or more programs and a processor. When the one or more programs are executed by the processor, the method according to any one of the above-mentioned first aspects is implemented.
[0043] In a third aspect, an embodiment of the present application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method as described in any one of the first aspects above.
[0044] The embodiments of the present invention have at least the following advantages or beneficial effects:
[0045] An embodiment of the present invention provides a hidden query method that supports multiple parties. Through an encryption method, the querying party obtains the union of the ciphertexts of the queried party's ID (here, only the union result can be obtained, and the specific element cannot be located from which party). Then the querying party and the queried party map their own IDs to the corresponding positions of the union, and finally obtain the final result on the aligned data. Based on the present invention, the querying party can only obtain the final result corresponding to each query condition (the sum of the found values), but cannot know which data source the query condition can specifically match, let alone the corresponding value of the query condition in a certain data source. The queried party (data source) knows nothing, and cannot lock the query condition within a small range. The present invention realizes highly secure multi-party hidden query. BRIEF DESCRIPTION OF THE DRAWINGS
[0046] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the embodiments. It should be understood that the following drawings only illustrate certain embodiments of the present invention and therefore should not be regarded as limiting the scope. For ordinary technicians in this field, other relevant drawings can be obtained based on these drawings without paying any creative work.
[0047] Figure 1 is a schematic diagram of a multi-party hidden query;
[0048] FIG2 is a schematic diagram of mapping according to an embodiment of the present invention;
[0049] FIG3 is a schematic diagram of the overall logic of a hidden query method supporting multiple parties according to an embodiment of the present invention;
[0050] FIG4 is a schematic diagram of a multi-party hidden query based on the OT extension protocol in a method supporting hidden query of multiple parties according to an embodiment of the present invention;
[0051] FIG5 is a schematic diagram of a multi-party hidden query based on a DH key exchange algorithm in a method supporting hidden queries of multiple parties according to an embodiment of the present invention. DETAILED DESCRIPTION
[0052] To make the objectives, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions of the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Generally, the components of the embodiments of the present invention described and shown in the drawings herein can be arranged and designed in various different configurations.
[0053] Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the invention as claimed, but rather merely represents selected embodiments of the present invention. All other embodiments derived by persons of ordinary skill in the art based on the embodiments of the present invention without creative effort shall fall within the scope of protection of the present invention.
[0054] It should be noted that similar reference numerals and letters denote similar items in the following drawings, and therefore, once an item is defined in one drawing, it does not need to be further defined or explained in subsequent drawings.
[0055] It should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the term "comprises" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, article or device that includes a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further limitations, an element defined by the sentence "comprises a ..." does not exclude the presence of other identical elements in the process, method, article or device that includes the element.
[0056] Example:
[0057] As shown in FIG1 , in a first aspect, an embodiment of the present invention provides a method for supporting multi-party hidden query, comprising the following steps:
[0058] Through interaction, the querying party and multiple queried parties generate corresponding local ID ciphertexts;
[0059] The querying party obtains the ciphertext union of the IDs of all queried parties through encryption, and obtains the intersection of the querying party's local ID ciphertext set and the union;
[0060] The querying party generates a vector of the same length as the union, fills the positions of the intersection elements with 1, and fills the remaining positions with 0;
[0061] Each queried party generates a corresponding vector of the same length as the union, fills the local ID ciphertext at the position in the union with its corresponding value, and fills the remaining positions with 0;
[0062] The vectors obtained by each queried party are summed up and then multiplied with the vector of the querying party to obtain the final query result.
[0063] definition:
[0064] S is the query party, which has a number of query conditions (id), and uses (r1, r2, ..., r n )express;
[0065] X, Y, and Z are the searched parties, and their data (id, value) are respectively:
[0066] C: Random encoding function, which can input bits of any length and have a fixed length output; C: {0,1} * →{0,1} k
[0067] H: random encoding function, which randomly maps a bit string of length k to a bit string of length l; H: [m]×{0,1} k →{0,1} l
[0068] The present invention mainly includes two major steps, as follows:
[0069] Step 1: Through a secure means, let S obtain the complete set of IDs of X, Y, and Z (the complete set is also the union). This complete set is a ciphertext set. During this process, S's local ID will also generate a ciphertext set. By comparing the ciphertext set of S's node with the complete set, the intersection ID of S and the complete set can be found. During the process of obtaining the complete set, security is guaranteed: X, Y, and Z cannot obtain each other's data information; X, Y, and Z cannot obtain S's data information; S is guaranteed not to obtain specific information about X, Y, and Z. In particular, S cannot know the intersection of its own ID with a specific data entity; it can only know the intersection with all data entities.
[0070] Step 2: With the full set, S, X, Y, and Z all map local data to the full set. S generates a vector of the same length as the full set, fills the position of the intersection element with 1, and fills the rest of the positions with 0. X, Y, and Z each generate a vector of the same length as the full set, fills the position of the local id in the full set with its corresponding value, and fills the rest of the positions with 0. It can be found that the final result can be obtained by summing the vectors obtained by X, Y, and Z and then multiplying them by the vector of S. In the result, only the elements of the intersection have values, and the rest of the positions are 0. The intersection means that S has found the result, and the rest of the elements of S mean that it has not found it, as shown in Figure 2. S can only know the value and corresponding to the intersection id, but cannot know the value corresponding to the id of a certain data in X, Y, and Z; S cannot know any value information corresponding to the non-intersection id; X, Y, and Z cannot know each other's value and id information.
[0071] In order to solve the problems in the prior art, the present invention uses an encryption method to allow the querying party to obtain the union of the ciphertext of the queried party's ID (here, only the union result can be obtained, but the specific element cannot be located which party it comes from), and then the querying party and the queried party map their own IDs to the corresponding positions of the union, and finally obtain the final result on the aligned data. Based on the present invention, the querying party can only obtain the final result corresponding to each query condition (the sum of the found values), but cannot know which data source the query condition can specifically match, let alone the corresponding value of the query condition in a certain data source. The queried party (data source) knows nothing, and cannot lock the query condition in a small range. The present invention can achieve highly secure multi-party hidden queries.
[0072] The specific security implementation methods in this invention mainly include two methods: one is based on the OT extension protocol, and the other is based on the DH key exchange. The following are detailed introductions:
[0073] As shown in Figure 4, the implementation method based on the OT extension protocol includes:
[0074] Step 1: The querying party and the queried party jointly determine three hash functions h1, h2, and h3, and use cuckoo hashing to map the querying party's n data into a hash table. Assume that the length of the hash table is n0 = 1.2n + s, where s is the size of the stash area of the cuckoo hash table. The querying party fills the empty positions in the hash table with pseudo-random numbers. Here, the hash table is L = (l1, l2, .., l n0 ).
[0075] Step 2: The query party S initializes a random bit matrix T. The size of the matrix T is n0*k, that is, n0 rows and k columns. Each element of the matrix is 0 or 1. Use the random encoding function C to convert the query party's L=(l1,l2,..,l n0 ). Each element is encoded as a bit string of length k. The encoded ID can also be regarded as a bit matrix F of n0*k. It can be found that the size of F and T is the same.
[0076] Step 3: The searched parties X, Y, and Z share a random bit string p = (p1, p2, ..., p k ), the number of elements of p is the same as the number of columns of the matrix T of the query party S.
[0077] Step 4: Now let the querying party S perform 1-2 oblivious transmission with the querying parties X, Y, and Z respectively, where S is the sender and X, Y, and Z are the receivers. The data sent by S is where t i is the i-th column of T, f iis the i-th column of F. The selected data of X, Y, and Z are p=(p1, p2,…, p k ), after executing the OT protocol k times, X, Y, and Z obtain an n0*k matrix Q. (This step can also be done by one of X, Y, and Z obtaining Q and sending it to the other parties, which can reduce the number of times the OT protocol is executed)
[0078] Step 5: Based on the application of OT extension protocol and the principle of OPRF, the querying party S’s H(i,t i ) can be considered as the OPRF protocol (S input l i , that is, the pseudo-random number obtained by the i-th element in the hash table L, and at the same time X, Y, and Z get the corresponding seeds (q i ,s), a total of n0 seeds are obtained, and the method for X, Y, and Z to calculate pseudo-random numbers using their own data is Where m is an arbitrary ID. This takes advantage of cuckoo hashing. For each ID of X, Y, and Z, there are only two possible seeds: 1. After hashing the ID using three hash functions, three positions are generated, corresponding to the seeds; 2. All seeds in the stash. Therefore, the number of possible seeds corresponding to each ID of X, Y, and Z is 3+s, which means that 3+s possible pseudo-random numbers will be calculated. Ultimately, X calculates (3+s)*n1 pseudo-random numbers, Y calculates (3+s)*n2 pseudo-random numbers, and Z calculates (3+s)*n3 pseudo-random numbers. This is part of the OTE intersection calculation. If any ID among X, Y, and Z matches S, a pseudo-random number that intersects with S will be obtained. S obtains the union of the pseudo-random numbers obtained by X, Y, and Z and intersects this union with the random number obtained by S using the OPRF protocol.
[0079] Step 6: Secretly share the pseudo-random numbers obtained by X, Y, and Z. Each pseudo-random number is divided into three shards, which are distributed to X, Y, and Z respectively. Then the shard information is connected into a long vector (ensuring that the shards at the same position on each side can restore the original pseudo-random number). Take the shard obtained by X as an example:
[0080] Step 7: X, Y, and Z share a random seed and use the seed to scramble the locally obtained shard information. This ensures that the shards at the same position on each side can still restore the original pseudo-random number.
[0081] Step 8: X, Y, and Z send the shard information to S, who decrypts and removes duplicates to obtain the union U of the pseudo-random numbers of X, Y, and Z. S then intersects the union U with its own pseudo-random number.
[0082] This completes step 1. Since X, Y, and Z only received fragmented information from each other throughout the entire process, they did not receive any information from each other. Since S did not send any information to X, Y, and Z, they could not obtain any information from S. Since X, Y, and Z scrambled the pseudo-random numbers before sending them to S, S could not determine the source of a particular pseudo-random number. Furthermore, since the pseudo-random numbers were generated using the OPRF protocol, S did not have random bit penetration, so it could not determine the plaintext ID corresponding to pseudo-random numbers outside the intersection. Therefore, S could only obtain information about the intersection of itself and the entire set of X, Y, and Z, not specific information about any particular party.
[0083] Step 9: S obtains the union U and the intersection Intersect with U and locally generates two vectors, U_pos and U_tag, of equal length to U. U_pos is an index, starting from 1 and extending to the same length as U. The positions of the intersection elements in U_tag are 1, and the remaining positions are 0. S concatenates U and U_pos into a two-column dataset, Data_U.
[0084] Step 10: X, Y, Z, and S each perform a hidden query. There are many hidden query methods, and any one can be used. S is the party being searched, the searched data is Data_U, X, Y, and Z are the querying parties, and the query condition is a local pseudo-random number. After the query, taking X as an example, since Data_U is the entire set, each pseudo-random number in X will be found with a result, which is the position of the pseudo-random number in the entire set U. X then generates a vector Res_X with the same length as U. For each pseudo-random number in X, there is a corresponding value (X knows the plaintext ID corresponding to its pseudo-random number, and the ID has a corresponding value). At the same time, the position result is obtained through the hidden query, and the corresponding position in Res_X is filled with the value, and the remaining positions are filled with 0. The same method is used for Y and Z, respectively, to obtain vectors Res_Y and Res_Z with the same length as U.
[0085] Step 11: Sum Res_X, Res_Y, and Res_Z using secret sharing, but do not decrypt. X, Y, and Z each hold one shard.
[0086] X-square calculation:
[0087] Y-square calculation:
[0088] Z-square calculation:
[0089] Step 12: S uses the Paillier encryption method to encrypt U_tag to obtain Enc_tag and sends it to X, Y, and Z. X, Y, and Z use their local split_Sum x 、split_Sum y 、split_Sum z Multiplying by Enc_tag yields split_res_x, split_res_y, and split_res_z. Then, X, Y, and Z send split_res_x, split_res_y, and split_res_z to S, which decrypts the sum of the three vectors to obtain the plaintext result. In the result, only the Intersect element contains a result; all other positions are zero. S extracts the result at the intersection and concatenates it with the query ID to obtain the final query result.
[0090] Here, step 2 mentioned above is completed. Since X, Y, and Z multiply the local shard data with Enc_tag, it can be guaranteed that the non-intersection positions all become 0, so S can only get the value and corresponding to the intersection id, and cannot know the value corresponding to the id of a certain data party in X, Y, and Z. The final result is that the non-intersection positions all become 0, so S cannot know any value information corresponding to the non-intersection id. X, Y, and Z obtain the id position information through hidden query, so they cannot obtain any information other than the pseudo-random number owned locally. The union U is not sent to X, Y, and Z here because the three parties share the random bit p, so they can try to crack the id of other parties in a way similar to hash collision. X, Y, and Z only interact with the shard information and cannot decrypt it, so they do not know each other's value and id information.
[0091] As shown in Figure 5, the implementation method based on DH key exchange specifically includes:
[0092] Step 1: S first hashes the local ID, then selects a random number as the private key, encrypts the local ID to obtain Enc_S, and sends Enc_S to any party among X, Y, and Z.
[0093] Step 2: X, Y, and Z also hash the local ID first, then share a random number and use it as their private key. Here, we can see that X, Y, and Z use the same private key. X, Y, and Z use their own private keys to encrypt the hash value of the local ID, obtaining Enc_X, Enc_Y, and Enc_Z. The party that obtains Enc_S encrypts Enc_S with its private key to obtain Enc_S_R, which it sends to S.
[0094] Step 3: Using steps 6, 7, and 8 in the OT extension protocol implementation, S obtains the full set Enc_U of X, Y, and Z. S then encrypts Enc_U with the private key to obtain Enc_U_S. At this point, S can calculate the intersection of Enc_S_R and Enc_U_S.
[0095] Step 4: S locally generates vectors U_pos and U_tag of equal length to Enc_U_S. U_pos is an index, starting from 1 and extending to a number equal to U. The intersection position in U_tag is 1, and all other positions are 0. S concatenates Enc_U (note, not Enc_U_S) and U_pos into a two-column dataset, Data_U. The remaining steps are identical to those in steps 10, 11, and 12 of the OT extension protocol implementation, resulting in the final result.
[0096] The present invention provides two implementation methods, respectively suitable for use in situations with good or poor network conditions. One method utilizes the OT extension protocol to perform a small amount of oblivious transmission, improving algorithm performance to a certain extent while maintaining high security. Because of the high level of oblivious transmission, this method is suitable for situations with high network bandwidth. The other method utilizes DH key sharing, which requires less network bandwidth.
[0097] In the embodiments provided in this application, it should be understood that the disclosed methods, systems, and methods can also be implemented in other ways. The method and system embodiments described above are merely illustrative. For example, the flowcharts and block diagrams in the accompanying drawings show the possible architectures, functions, and operations of the methods, systems, methods, and computer program products according to multiple embodiments of the present application. In this regard, each box in the flowchart or block diagram can represent a module, a program segment, or a portion of code, and the module, program segment, or a portion of code contains one or more executable instructions for implementing the specified logical functions. It should also be noted that in some alternative implementations, the functions marked in the boxes can also occur in an order different from that marked in the accompanying drawings. For example, two consecutive boxes can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flowchart, and the combination of boxes in the block diagram and / or flowchart, can be implemented using a dedicated hardware-based system that performs the specified functions or actions, or can be implemented using a combination of dedicated hardware and computer instructions.
[0098] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Those skilled in the art will readily appreciate that various modifications and variations of the present invention are possible. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present invention shall be included within the scope of protection of the present invention.
[0099] It will be apparent to those skilled in the art that the present application is not limited to the details of the exemplary embodiments described above and that the present application can be implemented in other specific forms without departing from the spirit or essential characteristics of the present application. Therefore, the embodiments should be considered in all respects as illustrative and non-restrictive, and the scope of the present application is defined by the appended claims, not the foregoing description, and all variations within the meaning and range of equivalents of the claims are intended to be included therein. Any reference sign in a claim should not be construed as limiting the claim to which it relates.
Claims
1. A hidden query method supporting multiple parties, It is characterized in that The following steps are involved: Through interaction, the querying party and multiple queried parties generate corresponding local ID ciphertexts; The querying party obtains the ciphertext union of each queried party's ID by encryption, and obtains the intersection of the querying party's local ID ciphertext set and the union; The query side generates a vector of the same length as the union, fills the positions of the intersection elements with 1, and fills the remaining positions with 0; Each queried party generates a corresponding vector of the same length as the union, fills the local ID ciphertext at the position of the union with its corresponding value, and fills the remaining positions with 0; The vectors obtained by each queried party are summed up and then multiplied with the vector of the querying party to obtain the final query result.
2. According to claim 1, a method for hidden query supporting multiple parties, It is characterized in that The method of allowing the querying party to obtain the ciphertext union of each queried party's ID in an encrypted manner and obtaining the intersection of the querying party's local ID ciphertext set and the union comprises the following steps: The querying party and each queried party jointly determine three hash functions h1, h2, and h3, and use cuckoo hashing to map the querying party's n data into a hash table L; The querying party initializes a random bit matrix T, the size of which is n0*k, where n0 is the length of the hash table; The querying party's hash table L is encoded using a random encoding function C, where each element in the hash table L is encoded as a bit string of length k; Each queried party shares a random bit string p, the number of elements in p is the same as the number of columns k in the matrix T of the querying party S; Based on the OT protocol, the querying party performs oblivious transmission with each queried party, where the querying party acts as the sender and each queried party acts as the receiver; Based on the OPRF protocol, the pseudo-random number of the querying party is obtained, and the pseudo-random number of each queried party is determined; The pseudo-random numbers of each queried party are secretly shared. Each pseudo-random number is divided into three pieces and distributed to each queried party respectively. Then the piece information is connected into a long vector. Each queried party shares a random seed, uses the seed to shuffle the locally obtained shard information, and then sends the shard information to the querying party; The querying party performs decryption and deduplication to obtain the union U of the pseudo-random numbers of each queried party, and then uses the querying party's own pseudo-random number to intersect with the union U to obtain the corresponding intersection Intersect.
3. A method for hidden query supporting multiple parties according to claim 2, It is characterized in that The method of generating a vector of the same length as the union by the querying party, filling the position of the intersection element with 1 and the remaining positions with 0 includes the following steps: After the querying party obtains the union U and the intersection Intersect with U, it locally generates a vector U_pos and U_tag of the same length as U, where U_pos is an index starting from 1 and extending to the same length as U; the position of the intersection element in U_tag is 1, and the rest of the positions are 0.
4. A method for hidden query supporting multiple parties according to claim 3, It is characterized in that The following steps are also included: The querying party concatenates U and U_pos into a two-column data set Data_U.
5. A method for hidden query supporting multiple parties according to claim 4, It is characterized in that The method of each queried party generating a corresponding vector of the same length as the union, filling the position of the local ID ciphertext in the union with its corresponding value, and filling the remaining positions with 0 includes the following steps: Each queried party conducts a hidden query with the querying party respectively, and each pseudo-random number of each querying party obtains a corresponding The query result is the position of the pseudo-random number in the union U; Each queried party generates a vector of the same length as the union U, and fills the corresponding position with the corresponding value according to the query result, and fills the remaining positions with 0.
6. A method for hidden query supporting multiple parties according to claim 3, It is characterized in that The method of summing the vectors obtained by each queried party and then multiplying the sum by the vector of the querying party to obtain the final query result comprises the following steps: The vectors of each queried party are summed using secret sharing, and each queried party holds a shard; The querying party uses the Paillier encryption method to encrypt U_tag to obtain Enc_tag, and sends it to the queried party; The queried party uses the held shards and multiplies Enc_tag respectively to obtain and send the corresponding multiple result vectors to the querying party; The querying party sums and decrypts multiple result vectors to obtain the final plaintext query result.
7. A method for hidden query supporting multiple parties according to claim 1, It is characterized in that The method of allowing the querying party to obtain the ciphertext union of each queried party's ID in an encrypted manner and obtaining the intersection of the querying party's local ID ciphertext set and the union comprises the following steps: The querying party hashes the local ID, selects a random number as the private key, encrypts the local ID, obtains the corresponding ciphertext of the querying party's ID, and sends the ciphertext to any one of the multiple queried parties; Each queried party first hashes the local ID, then shares a random number among multiple parties, uses the random number as its own private key, and uses the private key to encrypt the hash value of the local ID to obtain the corresponding queried party's ID ciphertext; The party that obtains the ciphertext of the ID of the querying party encrypts the ciphertext of the ID of the querying party with its private key, obtains and sends the corresponding ciphertext data to the querying party; The querying party obtains the union U of the queried parties, and encrypts the union U using the querying party's private key to obtain the querying party's local ID ciphertext set; Obtain the intersection of the query party's local id ciphertext set and the union.
8. An electronic device, It is characterized in that include: A memory for storing one or more programs; processor; When the one or more programs are executed by the processor, the method according to any one of claims 1 to 7 is implemented.
9. A computer-readable storage medium having a computer program stored thereon, It is characterized in that When the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.
Citation Information
Patent Citations
Hidden query method and system based on secure multi-party computing technology and storage medium
CN114969128A
Hidden trace query method, device and system and storage medium
CN115688167A
Screening template-based hidden trace query method, medium, electronic equipment and system
CN115935340A
Hidden query method supporting multiple parties
CN116702190A
Web system, web server device, web client device, and control method of web information concealment
JP2012168703A
Cited By
Privacy query method and system based on unbalanced privacy set intersection
CN119293298A
Linear complexity enhanced security privacy set merging protocol construction method and system
CN119449460A
Privacy intersection method and system based on national secret algorithm
CN119885283A
Privacy intersection method and system based on national cryptographic algorithm
CN119885283B
Unbalanced privacy set union method and union set system based on fully homomorphic encryption
CN120223282A
