Secret Hash Table Construction via Secure Computation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for constructing secret hash tables require a user-server communication cost of O(N log N), which can be inefficient due to insufficient communication and computing resources on the user side.
Innovation Solution
A secret hash table construction system using a coordination protocol among multiple servers via secure computation, where the system constructs a secret hash table with a data structure having B address values and storing a maximum of Z pieces of data for each address value, reducing user-server communication to O(1).
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a user encrypts all data and constructs a hash table locally, then the table structure is concealed from the server, but the storage area required by the user becomes O(N)
Solution Approach 1:
The patent extracts the data encryption and hash table construction functions from the user side and relocates them to the server side. The server receives only encrypted data values without keys, performs the hash table construction using secure computation techniques, and returns the constructed table. This extraction eliminates the need for the user to store all encrypted data locally while maintaining concealment of the table structure.
Solution Approach 2:
The patent introduces secure computation as an intermediary mechanism between the user and server. The server performs computations on encrypted data using cryptographic protocols that allow computation on ciphertext without decrypting it. This intermediary enables the server to construct the hash table while the user only needs to provide encrypted data values, reducing user storage requirements to O(1).
2Reliability
If existing secret hash table construction methods are used, then the table structure is concealed, but the user-server communication cost becomes O(N log N)
Solution Approach 1:
The patent segments the hash table construction process into multiple phases: (1) The user encrypts data values and sends them to the server; (2) The server performs secure computation to construct the hash table using encrypted data; (3) The server returns the constructed table to the user. This segmentation allows the communication to occur only in two directions (user→server and server→user) rather than requiring bidirectional communication for every data element, reducing the communication cost from O(N log N) to O(1).
Solution Approach 2:
The patent performs preliminary actions by having the user encrypt all data values before sending them to the server. The server then receives pre-encrypted data and performs the hash table construction using secure computation. This preliminary encryption action eliminates the need for subsequent decryption and re-encryption operations during communication, significantly reducing the communication overhead.
3Loss of time
If multiple servers are used in the present invention, then the user-server communication cost is reduced to O(1), but the system complexity increases
Solution Approach 1:
The patent merges multiple server functionalities into a coordinated protocol where servers work together to construct the secret hash table. Instead of requiring each server to independently handle all operations, the servers combine their computational power through secure computation protocols. This merging approach reduces the communication cost to O(1) while distributing the computational burden across multiple servers, managing system complexity through collaboration rather than isolation.
Data Source
AI summary
A server determines an array [[addr]] indicating a storage destination of each piece of data, generates an array of concealed values, and connects the generated array to the array [[addr]] to determine an array [[addr′]]. The server generates a sort permutation [[σ1]] for the array, applies the sort permutation [[σ1]] to the array [[addr′]], and converts the array [[addr′]] into an array with a sequence composed of first Z elements set to [[i]] followed by αi elements set to [[B]]. The server generates a sort permutation [[σ2]] for the converted array [[addr′]], generates dummy data, imparts the generated dummy data to the concealed data sequence, applies the sort permutations [[σ1]] and [[σ2]] to the data array imparted with the dummy data, and generates, as a secret hash table, a data sequence obtained by deleting the last N pieces of data from the sorted data array.