A dynamic single-server client preprocessing private information retrieval method

Abstract

The application discloses a dynamic single-server client preprocessing private information retrieval method, and belongs to the technical field of private information retrieval. The method comprises a preprocessing stage: a client generates a private hint and stores the private hint in a local device; a query and response stage: the client uses the private hint to accelerate query; a refreshing stage: the client repositions the used private hint and updates the locally stored private hint; and a dynamic updating stage: when the server updates or deletes original data items or adds new data items, the client directly updates the locally stored private hint. The application realizes the best trade-off between the client storage and the server online calculation time, and supports efficient updating of a dynamic database. When the database of the server dynamically changes, the private hint stored in the local device of the client can be updated within the expected PRP calling time, and the updating efficiency of the private hint in a dynamic database scenario is remarkably improved.

Description

Technical Field

[0001] This invention relates to the field of private information retrieval technology, and more specifically, to a dynamic single-server client preprocessing method for private information retrieval. Background Technology

[0002] Private Information Retrieval (PIR) is a privacy-preserving technology that allows clients to retrieve data items from a server's database without revealing their query privacy. In standard settings, the server only stores the raw data from the database, which inevitably incurs linear server computational overhead when the client queries the data. Therefore, academia and industry are exploring technological paths to overcome the lower bound of linear computation, and one of the most promising approaches is client-side preprocessing in private information retrieval.

[0003] In client-side preprocessing for private information retrieval, the client obtains private hints and stores them on its local device during the preprocessing phase. During the online phase, the client can use these private hints for fast queries, thus reducing server computational overhead. Furthermore, depending on the number of servers, private information retrieval is divided into single-server and dual-server private information retrieval. However, dual-server retrieval requires a strong assumption of non-collusion, making deployment more difficult in practice. Single-server private information retrieval, on the other hand, does not require multi-server collaboration and is therefore more suitable for real-world scenarios.

[0004] In a single-server client-preprocessed private information retrieval model, existing work has demonstrated that the database size is... And the data item is Bit time, client storage Online calculation time of the server The lower bound is This model, which aims to achieve an optimal trade-off between client storage and server computation time, is based on the assumption that the database size is static. However, in real-world applications, databases are typically dynamically incremental, meaning new data items are added in real-time. In this case, the client's local storage must be updated synchronously to ensure the correctness of subsequent queries. However, current single-server protocols supporting incremental databases do not achieve an optimal trade-off between client storage and server online computation time; therefore, with each increase in database size… When adding a new data item, the private notification should be updated within a certain timeframe. The private update time amortized for each PRF call is... This is a PRF call, but if a private hint update is performed for each new data item, it still requires... This single PRF call is insufficient to meet the high-efficiency update requirements of private hints in dynamic database scenarios. Summary of the Invention

[0005] To address the technical problems existing in the prior art, this invention provides a dynamic single-server client preprocessing private information retrieval method that achieves an optimal balance between client storage and server online computing time, while also supporting efficient updates to the dynamic database. When the server's database changes dynamically—that is, when the server updates or deletes existing data items or adds new data items—the private information stored locally on the client can be retrieved as expected. The update is implemented within a single PRP call, thereby significantly improving the efficiency of private hint updates in dynamic database scenarios.

[0006] To achieve the above objectives, the present invention provides a dynamic single-server client preprocessing method for retrieving private information, comprising the following steps:

[0007] M1, Preprocessing Stage: The client initializes private hint parameters and publishes them to the server. The server divides the database using the private hint parameters. The client selects a key for a pseudo-random function and derives a pseudo-random permutation key set to obtain the hint table. The client streams the database and calculates the parity check value for each private hint. The client initializes the private hint usage history. The client generates a complete private hint and stores it on the local device.

[0008] In the M2 query and response phase, the client generates a query request based on the query index; the client sends the query request to the server, the server retrieves the data from the database and returns the response results to the client; the client reconstructs the query results based on the response results and locally stored private hints.

[0009] In the M3 refresh phase, the client updates the private hint usage history stored on the local device and updates the parity value of the private hints. When all the private hints stored on the client's local device have been used, all private hints are reset and the client needs to re-enter the preprocessing phase.

[0010] During the M4 dynamic update phase, when the server updates or deletes existing data items or adds new data items, the server sends the database update results to the client, and the client updates the private prompts stored on the local device.

[0011] Preferably, step M1 includes:

[0012] M101, Database Size Each data item is Bits; Client selects time parameter ,definition , Expose private prompt parameters to the server The server divides the database into... Rows, each row is [size missing] ,for ,make For database The Okay, among them, ;

[0013] M102, Client selects small domain [ Pseudo-random permutation schemes on ] Select safety parameters ,in ; For a positive permutation, denoted as This indicates the use of a key. For the original input Execute forward permutation function The operation yields the permutation output. , This is a reverse permutation, denoted as This indicates that the same key is used. Permutation output Execute the inverse permutation function The operation restores the original input. ; requires for any key ,function yes arrive A bijection on the , satisfying any ,have ;

[0014] Choose a pseudo-random function And randomly select As a pseudo-random function The key, then the pseudo-random function Key Parameterization, let the parameterized function instance be denoted as This indicates that the function accepts a binary string of arbitrary length as input and outputs a string of length . The binary string; the client will send the key. Keep it secret;

[0015] The client uses a pseudo-random function Derivation of the key set used to obtain pseudo-random permutations of the hint table ,Right now ,in, ;

[0016] M103, The client initializes a length of... The private hint parity value array Among them, for , The client downloads and processes database data items sequentially in a streaming manner. For the first data item in the database... The first line Data items Calculate the private hint index corresponding to this data item. Update the parity value of the corresponding private hint. After traversing the entire database, obtain the updated array of parity values ​​for the private hints. ;

[0017] M104, The client initializes an empty array. and an empty hash , An index used to store all private hints used in a query. Used to establish the index of the used private hint into its array The mapping of location indices is stored in the middle. and As a private notification history usage record ;

[0018] The client will privately prompt relevant parameters. Private notification history usage records Pseudo-random functions key and the parity value array of private hints Constitutes a complete private prompt And stored on the local device; a private prompt generated during one preprocessing step. Available for This is the second query.

[0019] Preferably, step M2 includes:

[0020] M201, Client query index is Data items Calculate data items The row in the partitioned database ; Calculate the query index Corresponding private hint index First, calculate the private hint index. Further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For query index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? The above process is repeated in the middle;

[0021] The client found the index containing the query. Corresponding private hint index Then, a query request is generated. Among them, for Make the private hint index ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process; through this process, extract rows from the prompt table. In the private hint index Target index at ;

[0022] For query index The row containing the corresponding data item In order to hide the query index Use the prompt table row A random index replacement prompt table row In the private hint index The index at that location is randomly selected from unused private hint indexes. ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process;

[0023] M202, The client will send a query request. Send to the server, of which each For the database The target index in the row, The server retrieves data items from each row of the database. Receive response results Return to the client;

[0024] M203, The client responds to the response. And the parity value used in the prompt. Reconstruct query results .

[0025] Preferably, step M3 includes:

[0026] M301, Private prompt for client to update local device storage Private prompt history usage records By indexing the private hints that have already been used Append to array In the middle, and update the private hint index. To its in array The mapping of location indices is stored in ,in, For array Length;

[0027] M302. The client needs to relocate the indexes in the used private hints to the unused private hints in order to refresh the private hints; based on the private hint indexes used in the query... Query request Response results , The row in the partitioned database and query results First of all, let , For each satisfied and ,calculate Private hint index for relocation First, let the private hint index of the current relocation be set. Through mapping Get the private hint index of the current relocation In array Storage location index Update the private hint index for the current relocation. And determine the private hint index of the current relocation. Does it exist in the array? In the context of the currently relocated private hint index Not present in array If the current location is in the middle, then return the private hint index of the current relocation. for Private hint index for relocation End the loop, and if it exists, return the private hint index for the current relocation. In array Storage location index And update the private hint index for the current relocation. And continue to determine the private hint index of the current relocation. Does it exist in the array? This process is repeated in the middle;

[0028] For each satisfying and ,turn up Private hint index for relocation Then, update the parity value of the private hint. The private notification refresh is now complete.

[0029] M303, if array length If the client's local device storage is reset, all private prompts will be reset, and the client will need to re-enter the preprocessing stage. Otherwise, the client will store the existing private prompts locally, and no further action is required.

[0030] Preferably, step M4 includes:

[0031] M401. For updating existing data items in the database, i.e., the first data item in the database... Item from old value Update to new value The server will send the index that needs to be updated. Parity check values ​​of data items before and after the update Provided to the client; the client calculates the index. The row and calculate the index. Corresponding private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. ;

[0032] M402. For deleting existing data items in the database, i.e., the first data item in the database... If an item is deleted from the database, then use a random number of bits Replace the original data items The server will send the indexes that need to be deleted. Parity check values ​​of data items before and after deletion For the client; the client performs the same operation as when updating existing data items, finding the index. Corresponding private hint index Then, update the parity value of this private hint. ;

[0033] M403. For adding new data items to the database, i.e., adding an index to the database. Data items The server will add indexes. and data items Send to the client, the client calculates. ;if The client uses a pseudo-random function Derive a new pseudo-random permutation key ,Right now ,renew ; Calculate new indexes in the database Placement of private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index Place the private hint index, end the loop, and return the private hint index if it exists. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. The client and server update database size is... .

[0034] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0035] 1. This invention is the first to achieve an optimal balance between client-side storage and server-side online computing time in a dynamic database environment, and can achieve the expected results. This invention provides a single-server client-side preprocessing method for private information retrieval that achieves client-side private suggestion updates within the time of a single PRP call. It overcomes the bottleneck of private suggestion update efficiency in existing technologies for single-server dynamic database scenarios, especially when new data items are added to the database. This invention offers a practical solution for privacy retrieval in dynamic database scenarios.

[0036] 2. This invention successfully constructs a secure and efficient "private hint" system through one-time, offline "data preprocessing and local caching," achieving the best balance between online server computing and client storage. Furthermore, it enables the client to update local hints extremely efficiently when the database changes subsequently.

[0037] 3. This invention executes a specific, privacy-preserving query protocol based on preprocessing. It successfully and correctly obtains the data required by the client, efficiently providing query services, and the client's access mode is hidden. That is, throughout the process, the server cannot know the specific content of the client's query, further proving the effectiveness of the "private hints" constructed in the preprocessing stage, and achieving the goal of privacy retrieval with extremely low online overhead.

[0038] 4. This invention constructs an efficient private information retrieval scheme based solely on the assumption of a one-way function. Under the premise of protecting client privacy, this scheme is easy to implement in real-world scenarios. Attached Figure Description

[0039] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0040] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0041] Figure 1 A flowchart illustrating the dynamic single-server client preprocessing private information retrieval method provided by the present invention;

[0042] Figure 2 This is a schematic diagram of the structure of the dynamic single-server client preprocessing private information retrieval method provided by the present invention. Detailed Implementation

[0043] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0044] It should be noted that all directional indications (such as up, down, left, right, front, back, etc.) in the embodiments of the present invention are only used to explain the relative positional relationship and movement of each component in a certain specific posture (as shown in the figure). If the specific posture changes, the directional indication will also change accordingly.

[0045] Furthermore, the use of terms such as "first" and "second" in this invention is for descriptive purposes only and should not be construed as indicating or implying their relative importance or implicitly specifying the number of technical features indicated. Therefore, features defined with "first" and "second" may explicitly or implicitly include at least one of those features. Additionally, the technical solutions of the various embodiments can be combined with each other, but only on the basis of being achievable by those skilled in the art. When the combination of technical solutions is contradictory or impossible to implement, such a combination of technical solutions should be considered non-existent and not within the scope of protection claimed by this invention.

[0046] Example 1

[0047] Combination Figures 1 to 2 This invention provides a dynamic single-server client preprocessing method for retrieving private information, which includes steps M1 to M4, each step as follows:

[0048] M1, Preprocessing Stage: The client initializes and generates private hint parameters, and exposes these parameters to the server. The server partitions the database using these parameters. The client selects a key for a pseudo-random function, derives a pseudo-random permutation key set using the pseudo-random function, and uses this key to obtain the hint table. The client streams the database and calculates the parity check value for each private hint. The client initializes the private hint history usage record. The client generates a complete private hint and stores it on the local device. Specifically, step M1 includes the following steps:

[0049] M101, Configure Database Size Each data item is Bits; Client selects time parameter ,definition , Expose private prompt parameters to the server The server divides the database into... Rows, each row is [size missing] ,for ,make For database The Okay, among them, ;

[0050] M102, Client selects small domain [ Pseudo-random permutation schemes on ] Select safety parameters ,in ; For a positive permutation, denoted as This indicates the use of a key. For the original input Execute forward permutation function The operation yields the permutation output. , This is a reverse permutation, denoted as This indicates that the same key is used. Permutation output Execute the inverse permutation function The operation restores the original input. ; requires for any key ,function yes arrive A bijection on the , satisfying any ,have ;

[0051] Choose a pseudo-random function And randomly select As a pseudo-random function The key, then the pseudo-random function Key Parameterization, let the parameterized function instance be denoted as This indicates that the function accepts a binary string of arbitrary length as input and outputs a string of length . The binary string; the client will send the key. Keep it secret;

[0052] The client uses a pseudo-random function Derivation of the key set used to obtain pseudo-random permutations of the hint table ,Right now ,in, ;

[0053] M103, The client initializes a length of... The private hint parity value array Among them, for , The client downloads and processes database data items sequentially in a streaming manner. For the first data item in the database... The first line Data items Calculate the private hint index corresponding to this data item. Update the parity value of the corresponding private hint. After traversing the entire database, obtain the updated array of parity values ​​for the private hints. ;

[0054] M104, The client initializes an empty array. and an empty hash array An index used to store all private hints used in a query, a hash. Used to establish the index of the used private hint into its array The array stores a mapping of position indices. and hash As a private notification history usage record ;

[0055] The client will privately prompt relevant parameters. Private notification history usage records Pseudo-random functions key and the parity value array of private hints Constitutes a complete private prompt And stored on the local device; a private prompt generated during one preprocessing step. Available for This is the second query.

[0056] This invention performs a one-time, offline "data preprocessing and local caching" in step M1, successfully constructing a secure and efficient "private hint" system. It achieves the best balance between online server computing and client storage, and provides the possibility for the client to update local hints extremely efficiently when the database changes in the future.

[0057] M2, Query and Response Phase: The client generates a query request based on the query index; the client sends the query request to the server, the server retrieves data from the database and returns the response results to the client; the client reconstructs the query results based on the response results and locally stored private hints. Specifically, step M2 includes the following steps:

[0058] M201, Client query index is Data items Calculate data items The row in the partitioned database ; Calculate the query index Corresponding private hint index First, calculate the private hint index. Further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For query index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? The above process is repeated in the middle;

[0059] The client found the index containing the query. Corresponding private hint index Then, a query request is generated. Among them, for Make the private hint index ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process; through this process, extract rows from the prompt table. In the private hint index Target index at ;

[0060] For query index The row containing the corresponding data item In order to hide the query index Use the prompt table row A random index replacement prompt table row In the private hint index The index at that location is randomly selected from unused private hint indexes. ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process;

[0061] M202, The client will send a query request. Send to the server, of which each For the database The target index in the row, The server retrieves data items from each row of the database. Receive response results Return to the client;

[0062] M203, The client responds to the response. And the parity value used in the prompt. Reconstruct query results .

[0063] This invention, through step M2, executes a specific, privacy-preserving query protocol based on preprocessing. It successfully and correctly obtains the data required by the client, efficiently providing query services while keeping the client's access pattern hidden. That is, throughout the process, the server cannot know the specific content of the client's query, further demonstrating the effectiveness of the "private hints" constructed in the preprocessing stage, and achieving the goal of privacy retrieval with extremely low online overhead.

[0064] M3, Refresh Phase: The client updates the historical usage records of private hints stored on its local device and updates the parity value of the private hints. When all private hints stored on the client's local device have been used, all private hints are reset, and the preprocessing phase needs to be restarted. Specifically, step M3 includes the following steps:

[0065] M301, Private prompt for client to update local device storage Private prompt history usage records By indexing the private hints that have already been used Append to array In the middle, and update the private hint index. To its in array The mapping of location indices is stored in ,in, For array Length;

[0066] M302. The client needs to relocate the indexes in the used private hints to the unused private hints in order to refresh the private hints; based on the private hint indexes used in the query... Query request Response results , The row in the partitioned database and query results First of all, let , For each satisfied and ,calculate Private hint index for relocation First, let the private hint index of the current relocation be set. Through mapping Get the private hint index of the current relocation In array Storage location index Update the private hint index for the current relocation. And determine the private hint index of the current relocation. Does it exist in the array? In the context of the currently relocated private hint index Not present in array If the current location is in the middle, then return the private hint index of the current relocation. for Private hint index for relocation End the loop, and if it exists, return the private hint index for the current relocation. In array Storage location index And update the private hint index for the current relocation. And continue to determine the private hint index of the current relocation. Does it exist in the array? This process is repeated in the middle;

[0067] For each satisfying and ,turn up Private hint index for relocation Then, update the parity value of the private hint. The private notification refresh is now complete.

[0068] M303, if array length If the condition is met, all private hints stored on the client's local device will be reset, and the client will need to re-enter the preprocessing stage; otherwise, the client will store the existing private hints locally, and no further action is required.

[0069] Step M3 of this invention serves as a maintenance bridge between the query phase (M2) and subsequent operations. By relocating data, it maintains the effectiveness of local prompts, greatly enhancing the practical value of the entire solution.

[0070] M4, Dynamic Update Phase: When the database changes dynamically—that is, when the server updates or deletes existing data items or adds new data items—the server sends the database update results to the client, and the client updates the private information stored on its local device. Step M4 includes the following steps:

[0071] M401. For updating existing data items in the database, i.e., the first data item in the database... Item from old value Update to new value The server will send the index that needs to be updated. Parity check values ​​of data items before and after the update Provided to the client; the client calculates the index. The row and calculate the index. Corresponding private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. ;

[0072] M402. For deleting existing data items in the database, i.e., the first data item in the database... If an item is deleted from the database, then use a random number of bits Replace the original data items The server will send the indexes that need to be deleted. Parity check values ​​of data items before and after deletion For the client; the client performs the same operation as when updating existing data items, finding the index. Corresponding private hint index Then, update the parity value of this private hint. ;

[0073] M403. For adding new data items to the database, i.e., adding an index to the database. Data items The server will add indexes. and data items Send to the client, the client calculates. ;if The client uses a pseudo-random function Derive a new pseudo-random permutation key ,Right now ,renew ; Calculate new indexes in the database Placement of private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index Place the private hint index, end the loop, and return the private hint index if it exists. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. The client and server update database size is... .

[0074] The above technical solution of the present invention, client storage and server online time To achieve the optimal trade-off, i.e., within a database size of The size of the data item is At that time, to achieve Furthermore, when the server updates or deletes existing data items or adds new data items, the client's locally stored private hints can be displayed as expected. The update is completed within the time limit of each PRP call, which is beneficial for the practical application of private information retrieval.

[0075] Example 2

[0076] The present invention also provides an electronic device, including: a processor, a transmitting device, an input device, an output device, and a memory. The processor may be implemented using a general-purpose CPU (Central Processing Unit), a microprocessor, an application-specific integrated circuit, or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this application. The memory may be implemented using a read-only memory (ROM), a static storage device, a dynamic storage device, or a random access memory (RAM), and is used to store computer program code. The computer program code includes computer instructions. When the processor executes the computer instructions, the electronic device executes a method as described in any of the above possible implementation methods.

[0077] Example 3

[0078] The present invention also provides a computer-readable storage medium storing a computer program, the computer program including program instructions, which, when executed by a processor of an electronic device, cause the processor to perform a method as described in any of the above possible implementations.

[0079] In the description of this specification, the references to terms such as "an embodiment," "example," "specific example," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0080] The above description is merely a specific embodiment of the present invention, enabling those skilled in the art to understand or implement the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the present invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

1. A dynamic single-server client preprocessing method for retrieving private information, characterized in that, Includes the following steps: M1, Preprocessing stage: The client initializes private hint parameters and publishes them to the server. The server divides the database using the private hint parameters. The client selects a key for the pseudo-random function and derives a pseudo-random permutation key set through the pseudo-random function to obtain the hint table. The client streams the database and calculates the parity check value for each private hint. The client initializes the private hint usage history; the client generates a complete private hint and stores it on the local device; In the M2 query and response phase, the client generates a query request based on the query index. The client sends a query request to the server, the server retrieves the data from the database and returns the response to the client; the client then reconstructs the query results based on the response and locally stored private hints. During the M3 refresh phase, the client updates the private prompt history usage records stored on the local device and updates the parity value of the private prompt. When all private hints stored on the client's local device are used, all private hints are reset, and the preprocessing stage needs to be re-entered. M4, during the dynamic update phase, when the server updates or deletes existing data items or adds new data items, the server sends the database update results to the client, and the client updates the private prompts stored on the local device. Step M1 includes the following steps: M101, Configure Database Size Each data item is Bits; Client selects time parameter ,definition , Expose private prompt parameters to the server The server divides the database into... Rows, each row is [size missing] ,for ,make For database The Okay, among them, ; M102, Client selects small domain [ Pseudo-random permutation schemes on ] Select safety parameters ,in ; For a positive permutation, denoted as This indicates the use of a key. For the original input Execute forward permutation function The operation yields the permutation output. , This is a reverse permutation, denoted as This indicates that the same key is used. Permutation output Execute the inverse permutation function The operation restores the original input. ; requires for any key ,function yes arrive A bijection on the , satisfying any ,have .

2. The dynamic single-server client preprocessing private information retrieval method according to claim 1, characterized in that, Step M102 also includes: The client selects a pseudo-random function. And randomly select As a pseudo-random function The key, then the pseudo-random function Key Parameterization, let the parameterized function instance be denoted as This indicates that the function accepts a binary string of arbitrary length as input and outputs a string of length . The binary string; the client will send the key. Keep it secret; The client uses a pseudo-random function Derivation of the key set used to obtain pseudo-random permutations of the hint table ,Right now ,in, .

3. The dynamic single-server client preprocessing private information retrieval method according to claim 2, characterized in that, Step M1 also includes the following steps: M103, The client initializes a length of... The private hint parity value array Among them, for , The client downloads and processes database data items sequentially in a streaming manner. For the first data item in the database... The first line Data items Calculate the private hint index corresponding to this data item. Update the parity value of the corresponding private hint. After traversing the entire database, obtain the updated array of parity values ​​for the private hints. ; M104, The client initializes an empty array. and an empty hash , An index used to store all private hints used in a query. Used to establish the index of the used private hint into its array The mapping of location indices is stored in the middle. and As a private notification history usage record ; The client will privately prompt relevant parameters. Private notification history usage records Pseudo-random functions key and the parity value array of private hints Constitutes a complete private prompt And stored on the local device; a private prompt generated during one preprocessing step. Available for This is the second query.

4. The dynamic single-server client preprocessing private information retrieval method according to claim 3, characterized in that, Step M2 includes the following steps: M201, Client query index is Data items ,calculate The row in the partitioned database ; Calculate the query index Corresponding private hint index First, calculate the private hint index. Further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For query index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? The above process is repeated in the middle; The client found the index containing the query. Corresponding private hint index Then, a query request is generated. Among them, for Make the private hint index ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process; through this process, extract rows from the prompt table. In the private hint index Target index at ; For query index The row containing the corresponding data item In order to hide the query index Use the prompt table line A random index replacement prompt table row In the private hint index The index at that location is randomly selected from unused private hint indexes. ,if , Otherwise, check the private hint index. Whether it is a private hint index that has already been used for relocation, i.e., check. Does it exist? If it doesn't exist, return 0. End the loop; if it exists, update the private hint index. And continue calculating Determine whether Repeat the above process.

5. The dynamic single-server client preprocessing private information retrieval method according to claim 4, characterized in that, Step M2 also includes the following steps: M202, The client will send a query request. Send to the server, of which each For the database The target index in the row, The server retrieves data items from each row of the database. Receive response results Return to the client; M203, the client responds to the result. And the parity value used in the prompt. Reconstruct query results .

6. The dynamic single-server client preprocessing private information retrieval method according to claim 5, characterized in that, Step M3 includes the following steps: M301, Private prompt for client to update local device storage Private prompt history usage records By indexing the private hints that have already been used Append to array In the middle, and update the private hint index. To its in array The mapping of location indices is stored in ,in, For array Length; M302. The client needs to relocate the indexes in the used private hints to the unused private hints in order to refresh the private hints; based on the private hint indexes used in the query... Query request Response results , The row in the partitioned database and query results First of all, let , For each satisfied and ,calculate Private hint index for relocation First, let the private hint index of the current relocation be set. Through mapping Get the private hint index of the current relocation In array Storage location index Update the private hint index for the current relocation. And determine the private hint index of the current relocation. Does it exist in the array? In the context of the currently relocated private hint index Not present in array If the current location is in the middle, then return the private hint index of the current relocation. for Private hint index for relocation End the loop, and if it exists, return the private hint index for the current relocation. In array Storage location index And update the private hint index for the current relocation. And continue to determine the private hint index of the current relocation. Does it exist in the array? This process is repeated in the middle; For each satisfying and ,turn up Private hint index for relocation Then, update the parity value of the private hint. The private notification refresh is now complete. M303, if array length If the client's local device storage is reset, all private prompts will be reset, and the client will need to re-enter the preprocessing stage. Otherwise, the client will store the existing private prompts locally, and no further action is required.

7. The dynamic single-server client preprocessing private information retrieval method according to claim 6, characterized in that, Step M4 includes the following steps: M401. For updating existing data items in the database, i.e., the first data item in the database... Item from old value Update to new value The server will send the index that needs to be updated. Parity check values ​​of data items before and after the update Provided to the client; the client calculates the index. The row And calculate the index. Corresponding private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index The loop ends at the private hint index where the suggestion exists; if it does, the private hint index is returned. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. ; M402. For deleting existing data items in the database, i.e., the first data item in the database... If an item is deleted from the database, then use a random number of bits Replace the original data items The server will send the indexes that need to be deleted. Parity check values ​​of data items before and after deletion For the client; the client performs the same operation as when updating existing data items, finding the index. Corresponding private hint index Then, update the parity value of this private hint. .

8. The dynamic single-server client preprocessing private information retrieval method according to claim 7, characterized in that, Step M4 also includes the following steps: M403. For adding new data items to the database, i.e., adding an index to the database. Data items ; The server will add indexes and data items Send to the client, the client calculates. ;if The client uses a pseudo-random function Derive a new pseudo-random permutation key ,Right now ,renew ; Calculate new indexes in the database Placement of private hint index First, calculate the private hint index. And further examine the private hint index. Does it exist in the array? In the private hint index Not present in array If the condition is met, a private hint index will be returned. For index Place the private hint index, end the loop, and return the private hint index if it exists. In array Storage location index And update the private hint index. And continue to determine the private hint index. Does it exist in the array? In the middle, repeat the above process; find the index. Corresponding private hint index Then, update the parity value of this private hint. ; The size of the database update for both the client and server is [size to be specified]. .

Images