A method and system for retrieving privacy information

Abstract

This invention discloses a privacy information retrieval method and system, comprising: data digest extraction; preprocessing the database index before data retrieval to privatize client query requests; a first server storing the indexes of n data points from a public database DB in an array of l rows * m columns, arranging the elements of each subarray using a random algorithm to obtain random permutation groups; performing column-wise operations on each random permutation group to obtain m data digests; querying and responding; when a client wants to query data with index x, calculating the corresponding data digest, constructing a request that does not expose the real query using the data digest, and sending it to a second server; state reset; the data digest represents the latest state of the current retrieval method, and the state of the data digest is reset after each data retrieval; and re-performing the query and response tasks after the state reset. This invention will help promote privacy information protection in fields such as healthcare, finance, and media recording.

Description

Technical Field

[0001] This invention belongs to the field of network security, and specifically relates to a method and system for retrieving privacy information. Background Technology

[0002] In traditional information retrieval technologies, a client wanting to retrieve specific data from a server must expose its complete query information to the server. Privacy is a primary concern when accessing publicly available database services, such as those in the medical and financial sectors. Client query information, including user location, query frequency, and privacy concerns, could potentially be leaked. To address these issues, recent research has proposed privacy-preserving information retrieval technologies that allow clients to obtain relevant database information without revealing the specific query content to the server. However, existing privacy-preserving retrieval methods are difficult to implement and have security vulnerabilities. To avoid sending the query information to the server, a large amount of additional information must be sent, resulting in significant communication and storage overhead. Furthermore, there is a security risk that the server might infer the client's actual query based on non-query information. Summary of the Invention

[0003] To address the privacy protection issues associated with information retrieval in public data services, this invention provides a privacy information retrieval method and system. First, this invention proposes a client-side preprocessing mechanism as the basic framework for implementing privacy information retrieval. Second, this invention designs a specific privacy information retrieval algorithm, including data digest extraction, query and response, and state reset processes, comprehensively describing the core information retrieval method of this invention. Finally, this invention provides relevant solutions for different application scenarios.

[0004] To achieve the above objectives, the present invention adopts the following technical solution:

[0005] A method for retrieving privacy information, comprising:

[0006] Data digest extraction involves preprocessing the database index before data retrieval to protect client query requests. The first server stores the indexes of n data points from the public database DB in an array of l rows and m columns. The elements of each subarray are arranged using a random algorithm to obtain a random permutation group. Each random permutation group is processed column-wise to obtain m data digests. The first server and the client synchronize the data digests and random permutation groups, while the second server synchronously saves the public database.

[0007] In the query and response process, the client wants to query data with index x, calculates the corresponding data digest, constructs a request that does not expose the real query using the data digest, and sends it to the second server. The second server cannot deduce the client's real request from the request and returns the corresponding query response. The client then performs inverse operations using the query response and the data digest to obtain the actual search results.

[0008] The state is reset. The data digest represents the latest state of the current retrieval method. The state of the data digest is reset after each data retrieval. The client uses a random algorithm to construct a reset request and sends it to the first server. The first server randomly arranges the groups according to the request changes and calculates a new data digest. The data digest states of the client and the first server are reset synchronously. After the state is reset, the query and response tasks are performed again.

[0009] A further improvement of this invention lies in the data digest extraction, specifically including:

[0010] Define a public database DB containing n elements, with a corresponding data digest set of size m, where m = The data in a public database can be stored as l arrays, where l = n / Define DBi = DB[i·m:(i+1)·m] to represent each subarray of the database;

[0011] For each DBi, server SER1 calculates the corresponding random permutation pi, where the size of pi is the same as the size of the data digest set, which is m.

[0012] Each permutation pi of DBi has m elements, so all random permutations pi of each DBi can be regarded as an i*j two-dimensional array;

[0013] The first server computes a data digest hj for each column of a random permutation pi of DBi, where ;

[0014] Server SER1 sends the calculated data digest hj to client CLI, and at the same time, server SER1 sends the seed for generating a random permutation of pi to client.

[0015] A further improvement of this invention is that the data summary extraction is performed after the data in the database DB is grouped and randomly arranged.

[0016] A further improvement of this invention is that the grouped data arrangement is generated using a publicly available random permutation algorithm.

[0017] A further improvement of this invention lies in the query and response, specifically including:

[0018] Define the query element x = (i, k), where i ∈ [l] and k ∈ [m], that is, query the database element DBi[k]; let the query element x = (1, 2), that is, the client wants to query the data DB1[2] = DB1[p1(j)], then p1(j) = 2;

[0019] Since i=1, the client CLI traverses and searches for the random permutation p1 sent by the server SER1, and gets p1[3]=2, then j=3, so the data digest hj=h3 contains the element to be queried x=(1,2).

[0020] Define the query set sent by the client CLI to the server SER2 as sq; the client replaces the i-th element of the data digest h3 with a random element r, where r∈pi; the client replaces the first element of h3 with a random element from p1 and sends the set sq=(3, r, 2, 1) to the server SER2.

[0021] The client CLI randomly selects a set sr, where sr[i] represents a random element of pi. Assuming sr = (0, 1, 2, 1), the client CLI will send sr to the server SER1.

[0022] After receiving the query set sq = (3, r, 2, 1) from the client CLI, server SER2 returns the corresponding query result rq = (DB0[3], DB1[r], DB2[2], DB3[1]). The client CLI performs an XOR operation on res1 to obtain rq', and performs an XOR operation on h3 and rq' to obtain DB1[r]. DB1[2], since r is calculated by the client CLI, the result DB1[2] can be queried;

[0023] After receiving the set sr=(0,1,2,1) sent by the client CLI, the server SER1 returns the result rr=(DB0[0],DB1[1],DB2[2],DB3[1]).

[0024] A further improvement of this invention lies in the state reset, specifically including:

[0025] Before a new query, the client CLI swaps and arranges the elements of pi according to sr, and the server SER1 also swaps and arranges the elements of pi according to sr.

[0026] A privacy information retrieval system, comprising:

[0027] The data summary extraction module preprocesses the database indexes before data retrieval to protect client query requests. The first server stores the indexes of n data points from the public database DB in the form of an array with l rows and m columns. The elements of each subarray are arranged using a random algorithm to obtain a random permutation group. Each random permutation group is processed by columns to obtain m data summaries. The first server and the client synchronize the data summaries and random permutation groups, while the second server synchronously saves the public database.

[0028] In the query and response module, if a client wants to query data with index x, it calculates the corresponding data digest, constructs a request that does not expose the real query using the data digest, and sends it to the second server. The second server cannot deduce the client's real request from the request and returns the corresponding query response. The client then performs inverse operations using the query response and the data digest to obtain the actual search results.

[0029] The state reset module resets the state of the data digest, which represents the latest state of the current retrieval method, after each data retrieval. The client constructs a reset request using a random algorithm and sends it to the first server. The first server randomly arranges the groups according to the request changes and calculates a new data digest. The data digest states of the client and the first server are reset synchronously, and the query and response tasks are performed again after the state is reset.

[0030] A further improvement of this invention is that the data summary extraction module specifically includes:

[0031] Define a public database DB containing n elements, with a corresponding data digest set of size m, where m = The data in a public database can be stored as l arrays, where l = n / Define DBi = DB[i·m:(i+1)·m] to represent each subarray of the database;

[0032] For each DBi, server SER1 calculates the corresponding random permutation pi, where the size of pi is the same as the size of the data digest set, which is m.

[0033] Each permutation pi of DBi has m elements, so all random permutations pi of each DBi can be regarded as an i*j two-dimensional array;

[0034] The first server computes a data digest hj for each column of a random permutation pi of DBi, where ;

[0035] Server SER1 sends the calculated data digest hj to client CLI, and at the same time, server SER1 sends the seed for generating a random permutation of pi to client.

[0036] A further improvement of this invention is that the data summary extraction is performed after the data in the database DB is grouped and randomly arranged.

[0037] A further improvement of this invention is that the grouped data arrangement is generated using a publicly available random permutation algorithm.

[0038] Compared with the prior art, the present invention has at least the following beneficial technical effects:

[0039] This invention provides a privacy information retrieval method and system that privatizes the database index during initialization, separating data querying from privacy retrieval calculations. This avoids privacy calculations during each query, significantly improving the efficiency of privacy information retrieval. The invention employs a secure and efficient data digest extraction scheme. By extracting data index summaries, data retrieval can be performed without revealing the user's true request, overcoming the problem of server-side speculation of user behavior in existing methods.

[0040] Furthermore, this invention effectively protects user query privacy by extracting data digests and privatizing client query requests. The client's request is constructed based on the data digest, without directly revealing the user's true query intent, thus preventing a second server or other potential attackers from obtaining the user's sensitive information. A second server cannot deduce the true query content from the client's request, further enhancing the system's privacy protection capabilities. The use of data digests and random permutations increases data complexity, making it difficult for unauthorized users to directly access or crack sensitive information in the database. A state reset mechanism ensures the continuous updating of data digests and random permutations, further improving the system's security and resistance to attacks. The construction and computation of data digests can reduce the amount of data that needs to be processed to some extent, thereby speeding up the query process. The client obtains the true search results through inverse computation of the data digest; this process is relatively efficient and provides fast query services while ensuring privacy. Attached Figure Description

[0041] Figure 1 This is a schematic diagram of the preprocessing mechanism architecture.

[0042] Figure 2 This is a flowchart of the privacy information retrieval process.

[0043] Figure 3 This is a schematic diagram of a privacy information retrieval scheme.

[0044] Figure 4 This is a structural block diagram of a privacy information retrieval system according to the present invention. Detailed Implementation

[0045] In the following description, only certain exemplary embodiments are briefly described. As those skilled in the art will recognize, the described embodiments can be modified in various ways without departing from the spirit or scope of the invention. Therefore, the drawings and description are considered to be exemplary in nature and not restrictive.

[0046] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0047] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0048] It should also be further understood that the term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0049] The accompanying drawings illustrate various structural schematic diagrams according to embodiments disclosed in this invention. These drawings are not to scale, and some details have been enlarged for clarity, and some details may have been omitted. The shapes of the various regions and layers shown in the drawings, as well as their relative sizes and positional relationships, are merely exemplary and may deviate from reality due to manufacturing tolerances or technical limitations. Furthermore, those skilled in the art can design regions / layers with different shapes, sizes, and relative positions as needed.

[0050] The embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0051] Example 1

[0052] This embodiment provides a privacy information retrieval method, including:

[0053] Data digest extraction involves preprocessing the database index before data retrieval to protect client query requests. The first server stores the indexes of n data points from the public database DB in an array of l rows and m columns. The elements of each subarray are arranged using a random algorithm to obtain a random permutation group. Each random permutation group is processed column-wise to obtain m data digests. The first server and the client synchronize the data digests and random permutation groups, while the second server synchronously saves the public database.

[0054] In the query and response process, the client wants to query data with index x, calculates the corresponding data digest, constructs a request that does not expose the real query using the data digest, and sends it to the second server. The second server cannot deduce the client's real request from the request and returns the corresponding query response. The client then performs inverse operations using the query response and the data digest to obtain the actual search results.

[0055] The state is reset. The data digest represents the latest state of the current retrieval method. The state of the data digest is reset after each data retrieval. The client uses a random algorithm to construct a reset request and sends it to the first server. The first server randomly arranges the groups according to the request changes and calculates a new data digest. The data digest states of the client and the first server are reset synchronously. After the state is reset, the query and response tasks are performed again.

[0056] In this embodiment, data digest extraction specifically includes:

[0057] Define a public database DB containing n elements, with a corresponding data digest set of size m, where m = The data in a public database can be stored as l arrays, where l = n / Define DBi = DB[i·m:(i+1)·m] to represent each subarray of the database;

[0058] For each DBi, server SER1 calculates the corresponding random permutation pi, where the size of pi is the same as the size of the data digest set, which is m.

[0059] Each permutation pi of DBi has m elements, so all random permutations pi of each DBi can be regarded as an i*j two-dimensional array;

[0060] The first server computes a data digest hj for each column of a random permutation pi of DBi, where ;

[0061] Server SER1 sends the calculated data digest hj to client CLI, and at the same time, server SER1 sends the seed for generating a random permutation of pi to client.

[0062] Data digest extraction involves grouping and randomly arranging the data in the database (DB). The grouped data arrangement is generated using a publicly available random permutation algorithm.

[0063] In this embodiment, the query and response specifically include:

[0064] Define the query element x = (i, k), where i ∈ [l] and k ∈ [m], that is, query the database element DBi[k]; let the query element x = (1, 2), that is, the client wants to query the data DB1[2] = DB1[p1(j)], then p1(j) = 2;

[0065] Since i=1, the client CLI traverses and searches for the random permutation p1 sent by the server SER1, and gets p1[3]=2, then j=3, so the data digest hj=h3 contains the element to be queried x=(1,2).

[0066] Define the query set sent by the client CLI to the server SER2 as sq; the client replaces the i-th element of the data digest h3 with a random element r, where r∈pi; the client replaces the first element of h3 with a random element from p1 and sends the set sq=(3, r, 2, 1) to the server SER2.

[0067] The client CLI randomly selects a set sr, where sr[i] represents a random element of pi. Assuming sr = (0, 1, 2, 1), the client CLI will send sr to the server SER1.

[0068] After receiving the query set sq = (3, r, 2, 1) from the client CLI, server SER2 returns the corresponding query result rq = (DB0[3], DB1[r], DB2[2], DB3[1]). The client CLI performs an XOR operation on res1 to obtain rq', and performs an XOR operation on h3 and rq' to obtain DB1[r]. DB1[2], since r is calculated by the client CLI, the result DB1[2] can be queried;

[0069] After receiving the set sr=(0,1,2,1) sent by the client CLI, the server SER1 returns the result rr=(DB0[0],DB1[1],DB2[2],DB3[1]).

[0070] In this embodiment, state reset specifically includes:

[0071] Before a new query, the client CLI swaps and arranges the elements of pi according to sr, and the server SER1 also swaps and arranges the elements of pi according to sr.

[0072] Example 2

[0073] like Figure 1 As shown in the figure, this embodiment provides a privacy information retrieval method, including:

[0074] Preprocessing mechanisms include:

[0075] Step 1, assuming a public database DB on the server contains n The client can retrieve data using the index {0,...,n-1}. The purpose of the privacy information retrieval protocol is to allow the client to retrieve data from the database. i When [the index is accessed], the client does not need to disclose any information about the index to the server. i Privacy information retrieval has many applications, such as tracing third-party electronic contracts, anonymizing internet advertising, and transmitting private streaming media.

[0076] Step 2: Store all additional information used for queries on the client side; the server does not store any data other than the database itself. This setup helps clients initiate a large number of queries.

[0077] Step 3, the main workflow of this invention is described in [link to documentation]. Figure 2 Assume there are two independent servers, SER1 and SER2, and the database DB is stored repeatedly on both servers.

[0078] Step 4, Data Preprocessing Stage, Client CLI Selection There are three independent random sets si, where si is a subset of the set {0,...,n-1}. Each set si contains Each element. The specific random selection method of this invention is detailed in the privacy information retrieval scheme section.

[0079] Step 5, the data preprocessing stage: The client CLI sends these sets {si} to the server SER1, and SER1 uses these sets to generate a data digest for each set. Where {hi} and {si} are of equal size, This invention relates to a method for calculating data summaries. The specific data summary calculation method described in this invention can be found in the section on privacy information retrieval schemes.

[0080] Step 6, the data preprocessing stage: Server SER1 sends the calculated data digest hi to client CLI, and client CLI stores the data digest hi and set si as a pair. The data preprocessing of this invention is primarily implemented offline, thus concluding the data preprocessing stage.

[0081] Step 7, the retrieval interaction phase: When the client CLI wants to retrieve data with index x, the client CLI locally searches for the preprocessed set sj and the corresponding paired data digest hj. The preprocessed set sj contains index x.

[0082] Step 8, the retrieval interaction phase, where the client CLI sends the information sj / {x} to the server SER2, where / indicates hiding the real index. For the specific retrieval interaction design of this invention, please refer to the Privacy Information Retrieval Scheme section.

[0083] Step 9, the retrieval interaction phase: Server SER2 calculates the data digest hk corresponding to the information sj / {x} sent by client CLI. Server SER2 then sends the data digest hk to client CLI.

[0084] Step 10, the retrieval interaction phase, the client CLI uses the data digest hk returned by server SER2 and hj returned by server SER1 to calculate hk hj can retrieve the desired data content DB[x]. For details on the specific data content retrieval method of this invention, please refer to the Privacy Information Retrieval Scheme section.

[0085] The preprocessing mechanism framework of this invention is only used to describe the main process. For performance overhead and server information exposure issues, the privacy information retrieval scheme of this invention will specifically describe a low-cost and secure privacy information retrieval scheme.

[0086] Privacy information retrieval includes: the privacy information retrieval scheme, which describes the specific processes of data digest extraction, querying and response, and status reset, with the following specific steps:

[0087] Step 1, Data Digest Extraction Process: Define a public database DB containing n elements, with the corresponding data digest set size being m, where m = The data in a public database can be stored as l arrays, where l = n / Define DBi = DB[i·m:(i+1)·m] to represent each subarray of the database.

[0088] Step 2, data digest extraction process: For each DBi, server SER1 calculates the corresponding random permutation pi, where the size of pi is the same as the size of the data digest set, which is m.

[0089] Step 3, data summary extraction process, please see Figure 3 (1) Each permutation pi of DBi has m elements, so all random permutations pi of each DBi can be regarded as an i*j two-dimensional array.

[0090] Step 4, data summary extraction process, please see Figure 3 (1) The first server calculates a data summary hj for each column of a random permutation pi of DBi, where The data digest extraction of this invention involves grouping and randomly arranging the data in the database DB. The grouped data arrangement in this invention is generated using a publicly available random arrangement algorithm.

[0091] Step 5, Data Digest Extraction Process: Server SER1 sends the calculated data digest hj to the client CLI. Simultaneously, server SER1 also sends a seed containing a random permutation of pi to the client.

[0092] The data digest extraction process for this invention has ended. Please see the client CLI's data status below. Figure 3 (1). For the sake of illustration, n=16, l=4, m=4. When the index of element x is to be obtained as i=0, k=1, p0(j)=k=1, then j=1, and the corresponding data digest hj=h1 contains data element DB0[1].

[0093] Step 6, query and response process: Define the query element x = (i, k), where i ∈ [l] and k ∈ [m], that is, query the database element DBi[k]. For ease of understanding, let the query element x = (1, 2), that is, the client wants to query the data DB1[2] = DB1[p1(j)], then p1(j) = 2.

[0094] Step 7, the query and response process, please see Figure 3 (1) Since i=1, the client CLI traverses and searches for the random permutation p1 sent by the server SER1, and gets p1[3]=2, then j=3, so the data digest hj=h3 contains the element to be queried x=(1,2).

[0095] Step 8, the query and response process, please see Figure 3 (2) Define the query set sent by the client CLI to the server SER2 as sq. The client replaces the i-th element of the data digest h3 with a random element r, where r∈pi. Here, the client replaces the first element of h3 with a random element from p1 and sends the set sq=(3, r, 2, 1) to the server SER2.

[0096] Step 9, Query and Response Process: The client CLI randomly selects a set sr, where sr[i] represents a random element of pi. See [link to documentation]. Figure 3 (2) Assume that sr = (0, 1, 2, 1). The client CLI will send sr to the server SER1.

[0097] Step 10, the query and response process, please see Figure 3 (2) After receiving the query set sq=(3, r, 2, 1) from the client CLI, the server SER2 returns the corresponding query result rq=(DB0[3], DB1[r], DB2[2], DB3[1]). The client CLI performs an XOR operation on res1 to obtain rq', and performs an XOR operation on h3 and rq' to obtain DB1[r]. DB1[2], since r is calculated by the client CLI, the result DB1[2] can be queried.

[0098] In this invention, the client obtains the data content DB1[2] without revealing any data index (1, 2) to the server. There is no risk that the server with existing work will use the inversion of all data to deduce the actual content retrieved by the client. The cost of a single query is much smaller than sending existing work (all data minus the queried element).

[0099] Step 11, the query and response process, please see Figure 3 (2) After receiving the set sr=(0,1,2,1) sent by the client CLI, the server SER1 returns the result rr=(DB0[0],DB1[1],DB2[2],DB3[1]).

[0100] Step 12, the state reset process, please see... Figure 3 (3) Before the new query, the client CLI swaps the elements of pi according to sr, and the server SER1 also swaps the elements of pi according to sr.

[0101] This invention updates the sorting order after each client query and re-retrieves the data digest before the next query. Server SER1 only knows the method by which the client CLI retrieves the data sorting and data digest, but not the specific query information. Server SER2 only knows that the client CLI requests queries to retrieve certain elements, and these elements do not contain any of the information the client actually wants; it does not know how these queries are constructed. For scenarios where there may only be one data server, please refer to the following server-side application scheme for adaptation instructions.

[0102] Example 3

[0103] This embodiment proposes a privacy information retrieval method, specifically describing a privacy information retrieval scheme that includes processes such as data digest extraction, query and response, and state reset. For the privacy information retrieval process, please refer to [link to relevant documentation]. Figure 2 The specific steps are as follows:

[0104] Step 1, define basic parameters. Assume the public database DB contains N elements, and the public database is stored on two servers, SER1 and SER2. Assume the N elements of the public database can be represented as an array, let λ=1, and each subarray contains M elements, where M=λ· = There are a total of L arrays, where L = N / M.

[0105] Step 2, define the basic parameters. Define DBi = DB[i·m:(i+1)·m], to identify each subarray, where i∈L. Define the random permutation pi, where i∈L. Define the data digest hj, where j∈M.

[0106] For ease of understanding, this embodiment assumes that the public database has N=16 data elements, then M=4, L=4. That is, the database can be represented as a 4*4 two-dimensional array. Random permutation and data digest refer to the indices of the data elements, not the data content itself. `pi` identifies the random permutation of the indices of each row of data, where i∈{0,...,3}. `pi` is an array, and `pi(j)` represents the j-th data element in the i-th permutation. `hj` identifies the data digest of each column's random permutation.

[0107] Step 3, Data Digest Extraction. In this embodiment, the data digest extraction process first stores the database elements as an array, then randomly arranges the indices of each subarray, and finally extracts the randomly arranged data digest. This is primarily to avoid leaking the indexes of the data elements the client actually wants to retrieve to the server.

[0108] Step 4, Data Summary Extraction. Server SER1 calculates the random permutation pi corresponding to all subarrays DBi of database DB. Please see... Figure 3 (1) Assume that the random permutations are p0={0,1,2,3}, p1={3,0,1,2}, p2={1,0,3,2}, and p3={3,2,0,1}. The random permutation algorithm used in this embodiment is the publicly available full permutation algorithm (Heap's algorithm).

[0109] Step 5, Data Digest Extraction. Server SER1 calculates the data digest hj based on a random permutation. Wherein... That is, calculate the two-dimensional array composed of all random permutations of pi, take pi(j) in the same column as the database index k, i∈L, j∈M, calculate the XOR value of i database elements DBi[k], and obtain i data digests.

[0110] In this embodiment, please see Figure 3 (1), Data summary h0= {DB0[0],DB1[1], DB2[0],DB3[2]}, Data digest h1= {DB0[1],DB1[0], DB2[3],DB3[3]}, Data digest h2= {DB0[2],DB1[3],DB2[2],DB3[1]}, Data digest h3= {DB0[3],DB1[2], DB2[1],DB3[0]}.

[0111] Step 6, Data Digest Extraction. Server SER1 sends the calculated data digest hj to client CLI, and simultaneously sends a random seed to generate a random permutation pi.

[0112] In this embodiment, both the client and the server SER1 clearly define the data digest calculation process. The above steps are preprocessing performed on the client before the actual data retrieval query.

[0113] Step 7, Query and Response. The client initiates a data retrieval query, defining the coordinates of the query element x as (i, k), meaning the client wants to query the content of database DBi[k].

[0114] Step 8, Query and Response. The client receives the random permutation pi and data digest hj previously sent by server SER1, and locates the data digest containing the data to be retrieved.

[0115] In this embodiment, it is assumed that the index of the element x to be queried is (1,2), that is, the element DB1[2] to be queried, whose corresponding random permutation is p1[j]=2. Since p1[3]=2, then j=3. Therefore, the data digest h3 contains the element to be queried, that is, h3 is derived from elements such as DB1[2].

[0116] Step 9, Query and Response. The client initiates a data retrieval query to server SER2. The query set from the client to server SER2 is defined as sq, where sq is the index of the element corresponding to the data digest hj containing the query element, i.e., the index value of the column containing pi corresponding to hj.

[0117] Step 10, Query and Response. Please see Figure 3 (2) In this embodiment, the client constructs a query set sq=(3,r,1,0), where the actual element to be queried is DB1[2]. In order to avoid protecting the actual query, the client replaces the element of sq[1] with a random index r, where r∈M.

[0118] Step 11, Query and Response. Please see Figure 3 (2) After receiving the query set sq, server SER2 returns the corresponding query result rq = (DB0[3], DB1[r], DB2[1], DB3[0]). The client performs an XOR operation on the contents of the result rq to obtain rq'. In this embodiment, rq' and data element h3 differ only from the actual element to be queried, DB1[2], so the client then performs an XOR operation on rq' and h3 to obtain DB1[2]. DB1[r]. Since the client calculates r, it can calculate the content DB1[2] of the element x to be queried.

[0119] In this embodiment, the client randomly arranges the elements of the database and removes the element to be queried from the index value corresponding to the data summary before sending it to the parallel server SER2. The query result can ultimately obtain the actual data content to be queried without leaking any information.

[0120] Step 12, Status Reset. Please see... Figure 3 (2) In this embodiment, the client constructs a reset query set sr. Each element sr[i] of sr is a randomly selected index in pi, and the same random algorithm is used to select r as in sq.

[0121] Step 13, Status Reset. Please see... Figure 3 (2) In this embodiment, assuming sr = (0, 1, 2, 1), the client sends sr to the server SER1.

[0122] Step 14, State Reset. After the client resets the query set sr in the SER1 structure of the server, the result rr is returned as (DB0[0], DB1[1], DB2[2], DB3[1]).

[0123] Step 15, Status Reset. Please see... Figure 3 (3) After receiving rr, the client sequentially swaps the elements of pi according to sr, and the server SER1 also synchronously swaps the elements of pi. This facilitates the calculation of new data summaries and initiates a new round of data query cycle.

[0124] In this embodiment, after each data retrieval query by the client, the server SER1 will synchronize and update the randomized state and data summary with the client, which to some extent avoids the threat of collusion attacks between servers.

[0125] In this embodiment, server SER1 performs data preprocessing with the client, random permutation calculation, data digest calculation, and state update synchronization, but is unaware of the client's specific query information. Server SER2 performs data retrieval queries with the client, but is unaware of the specific query content and cannot perform reverse guessing.

[0126] In this embodiment, the client only stores a random permutation of the database content and related or calculated data summaries, without storing a large amount of database element content. This saves significant storage overhead. During the retrieval interaction, only the following data needs to be transmitted: The query set of each element can be updated with each query, making it difficult for the server to perform data inference. This ensures the security and usability of the privacy information retrieval scheme of this invention.

[0127] Example 4

[0128] like Figure 4As shown, this embodiment provides a privacy information retrieval system, including:

[0129] The data summary extraction module preprocesses the database indexes before data retrieval to protect client query requests. The first server stores the indexes of n data points from the public database DB in the form of an array with l rows and m columns. The elements of each subarray are arranged using a random algorithm to obtain a random permutation group. Each random permutation group is processed by columns to obtain m data summaries. The first server and the client synchronize the data summaries and random permutation groups, while the second server synchronously saves the public database.

[0130] In the query and response module, if a client wants to query data with index x, it calculates the corresponding data digest, constructs a request that does not expose the real query using the data digest, and sends it to the second server. The second server cannot deduce the client's real request from the request and returns the corresponding query response. The client then performs inverse operations using the query response and the data digest to obtain the actual search results.

[0131] The state reset module resets the state of the data digest, which represents the latest state of the current retrieval method, after each data retrieval. The client constructs a reset request using a random algorithm and sends it to the first server. The first server randomly arranges the groups according to the request changes and calculates a new data digest. The data digest states of the client and the first server are reset synchronously, and the query and response tasks are performed again after the state is reset.

[0132] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. It will be apparent to those skilled in the art that the invention is not limited to the details of the exemplary embodiments described above, and that the invention can be implemented in other specific forms without departing from its spirit or essential characteristics. Therefore, the embodiments should be considered illustrative and non-limiting in all respects, and the scope of the invention is defined by the appended claims rather than the foregoing description. Thus, all variations falling within the meaning and scope of equivalents of the claims are intended to be included within the scope of the invention. No reference numerals in the claims should be construed as limiting the scope of the claims.

[0133] Furthermore, it should be understood that although this specification describes embodiments, not every embodiment contains only one independent technical solution. This narrative style is merely for clarity. Those skilled in the art should consider the specification as a whole, and the technical solutions in each embodiment can be appropriately combined to form other embodiments that can be understood by those skilled in the art. The above content is only for illustrating the technical concept of the present invention and should not be construed as limiting the scope of protection of the present invention. Any modifications made based on the technical concept proposed in this invention shall fall within the scope of protection of the claims of this invention.

Claims

1. A method of private information retrieval, characterized by, Comprising: Data summary extraction, preprocessing the index of the database before data retrieval, privatizing the client query request; The first server stores indexes of n data of the public database DB in the form of an array with l rows m columns, and arranges elements of each sub-array by a random algorithm to obtain a random arrangement group; performs operation on each random arrangement group according to columns to obtain m data summaries; the first server and the client synchronize the data summaries and the random arrangement group, and the second server synchronously saves the public database; Query and response, the client wants to query the data indexed as x, calculate the corresponding data summary, use the data summary to build a request that does not expose the real query, send to the second server; the second server cannot infer the real request of the client according to the request, and returns the corresponding query response; The client obtains the real retrieval result by performing an exclusive or operation on the query response and the data summary; specifically comprising: Define the query element x= (i, k), where i∈[l] and k∈[m], that is, query the database element DBi[k]; Let the query element x= (1, 2), that is, the client wants to query the data DB1[2]=DB1[p1(j)], then p1(j)=2; DBi represents the ith subarray of the database; Pi represents the random permutation group corresponding to DBi; Since i=1, the client CLI traverses to find the random permutation p1 sent by the server SER1, and obtains p1[3]=2, so j=3, and the data summary hj contains the query element x= (1, 2); Define the query set sent by the client CLI to the server SER2 as sq; the client replaces the ith element of the data summary h3 with a random element r, where r∈pi; the client replaces the first element of h3 with a random element in p1, and sends the set sq= (3, r, 2, 1) to the server SER2; The client CLI randomly selects a set sr, where sr[i] represents a random element of pi, and assumes that sr= (0, 1, 2, 1) is obtained, the client CLI sends the set sr to the server SER1; After the server SER2 receives the query set sq= (3, r, 2, 1) of the client CLI, the corresponding query result rq= (DB0[3], DB1[r], DB2[2], DB3[1]) is returned; the client CLI performs exclusive-OR on rq to obtain rq', and performs exclusive-OR on h3 and rq' to obtain DB1[r] DB1[2], since r is calculated by the client CLI, the result DB1[2] can be queried; After receiving the set sr= (0, 1, 2, 1) sent by the client CLI, the server SER1 returns the result rr= (DB0[0], DB1[1], DB2[2], DB3[1]); State reset, the data summary represents the latest state of the current retrieval method, and the state of the data summary is reset after each data retrieval; the client uses a random algorithm to build a reset request and sends it to the first server; the first server changes the random permutation group according to the request and calculates a new data summary; the data summary states of the client and the first server are synchronized and reset, and the query and response task is performed again after the state reset.

2. The method of claim 1, wherein, Data summary extraction, specifically comprising: The definition discloses the database DB contains n elements, and the size of the corresponding data digest set is m, wherein m= , the data of the disclosed database can be stored as l arrays, wherein l = n / ; the definition DBi = DB[i·m:(i+1)·m] represents each subarray of the database; For each DBi, the server SER1 calculates the corresponding random permutation pi, where the size of pi is the same as the size of the data summary set, which is m; Each permutation pi of DBi has m elements, so all the random permutations pi of each DBi are considered as one i a two-dimensional array of j; The first server computes a data digest hj for each column of the random permutation pi of DBi, where ; The server SER1 sends the calculated data summary hj to the client CLI, and the server SER1 also sends the seed for generating the random permutation pi to the client.

3. The method of claim 2, wherein, Data summary extraction is performed after grouping and randomly arranging the data of the database DB.

4. The method of claim 2, wherein, The grouped data arrangement is generated using a public random permutation algorithm.

5. The method of claim 2, wherein, State reset, specifically comprising: Before a new query, the client CLI exchanges the elements of pi according to sr, and the server SER1 also exchanges the elements of pi according to sr.

6. A private information retrieval system characterized by, Comprising: A data abstract extraction module, which preprocesses indexes of a database before data retrieval, and privatizes a client query request; The first server stores indexes of n data of the public database DB in the form of an array with l rows m columns, and arranges elements of each sub-array by a random algorithm to obtain a random arrangement group; performs operation on each random arrangement group according to columns to obtain m data summaries; the first server and the client synchronize the data summaries and the random arrangement group, and the second server synchronously saves the public database; A query and response module, in which a client wants to query data with an index x, calculates a corresponding data abstract, uses the data abstract to construct a request that does not expose a real query, and sends the request to a second server; the second server cannot infer the real request of the client according to the request, and returns a corresponding query response; The client obtains a real retrieval result by performing an exclusive or operation on the query response and the data abstract; the specific operation includes: Defining a query element x=(i, k), wherein i∈[l] and k∈[m], that is, querying a database element DBi[k]; assuming that the query element x=(1, 2), that is, the client wants to query data DB1[2]=DB1[p1(j)], and p1(j)=2; DBi represents an i-th subarray of the database; Pi represents a random permutation group corresponding to DBi; Since i=1, the client CLI finds the random permutation p1 sent by the server SER1, obtains p1[3]=2, and thus j=3, so the data abstract hj contains the query element x=(1, 2); Defining a query set sent by the client CLI to the server SER2 as sq; the client replaces an i-th element of the data abstract h3 with a random element r, wherein r∈pi; the client replaces an i-th element of h3 with a random element in p1, and sends the set sq=(3, r, 2, 1) to the server SER2; The client CLI randomly selects a set sr, wherein sr[i] represents a random element in pi; assuming that sr=(0, 1, 2, 1) is obtained, the client CLI sends the set sr to the server SER1; After the server SER2 receives the query set sq= (3, r, 2, 1) of the client CLI, the corresponding query result rq= (DB0[3], DB1[r], DB2[2], DB3[1]) is returned; the client CLI performs exclusive-OR on rq to obtain rq', and performs exclusive-OR on h3 and rq' to obtain DB1[r] DB1[2], since r is calculated by the client CLI, the result DB1[2] can be queried; After receiving the set sr=(0, 1, 2, 1) sent by the client CLI, the server SER1 returns a result rr=(DB0[0], DB1[1], DB2[2], DB3[1]); A state resetting module, in which a data abstract represents a latest state of a current retrieval mode, and the state of the data abstract is reset after each data retrieval; the client uses a random algorithm to construct a resetting request, and sends the request to a first server; the first server changes a random permutation group according to the request, and calculates a new data abstract; the state of the data abstract of the client and the first server is synchronously reset, and the query and response task is performed again after the state is reset.

7. The private information retrieval system of claim 6, wherein, The data abstract extraction module specifically includes: The definition discloses the database DB contains n elements, and the size of the corresponding data digest set is m, wherein m = n The data of the disclosed database can be stored as l arrays, wherein l = n ; the definition DBi = DB[i m:(i + 1) m] represents each subarray of the database; For each DBi, the server SER1 calculates a corresponding random permutation pi, wherein the size of pi is the same as that of a data abstract set, that is, m; Each permutation pi of DBi has m elements, so all the random permutations pi of each DBi are considered as one i A two-dimensional array of j; The first server computes a data digest hj for each column of the random permutation pi of DBi, where ; The server SER1 sends the calculated data abstract hj to the client CLI, and simultaneously sends a seed for generating the random permutation pi to the client.

8. The private information retrieval system of claim 7, wherein, The data abstract extraction is performed after grouping and randomly arranging data of the database DB.

9. The private information retrieval system of claim 7, wherein, The grouped data arrangement is generated by using a public random arrangement algorithm.

Images