Tree-Based Data Storage With Bilinear Accumulator Verification
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data storage methods are inefficient and insecure, particularly for large datasets, lacking secure and efficient mechanisms for storing and verifying data entries.
Innovation Solution
A method using a tree structure with cryptographic hashing and bilinear accumulators to securely store data entries, where each parent node's hash value is computed from its children, with a root node representing the data set, enabling privacy-preserving proofs of inclusion.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If data is stored using traditional database methods, then data storage is simple and straightforward, but security and verification efficiency deteriorate for large datasets
Solution Approach 1:
The patent segments the dataset into a hierarchical tree structure where data entries are organized in leaf nodes and parent nodes contain aggregated information. This segmentation allows the system to verify individual entries efficiently without compromising the security of the entire dataset, resolving the contradiction between maintaining simple storage and achieving secure verification.
Solution Approach 2:
The patent implements a nested structure where each parent node contains hash values derived from its child nodes, creating a nested hierarchy. The root node ultimately contains the aggregated representation of all data entries. This nesting enables efficient verification while maintaining security, as each level provides cryptographic proof of the data below it without exposing the actual data.
2Measurement precision
If all data entries are stored and verified individually, then verification accuracy is high, but processing time and computational resources increase significantly
Solution Approach 1:
The patent merges multiple data entry verifications into a single root node verification process. By combining the cryptographic hashes of all data entries through the tree structure, the system can verify the integrity of the entire dataset or individual entries by checking only the relevant path from leaf to root, dramatically reducing verification time while maintaining accuracy.
Solution Approach 2:
The patent enables partial verification where only the necessary portion of the tree needs to be checked to verify a specific data entry. Instead of verifying all n data entries individually, the system performs partial action by checking only the path from the target leaf node to the root, significantly reducing computational overhead while maintaining verification accuracy.
3Reliability
If data inclusion proofs are generated for privacy preservation, then security and privacy are improved, but computational complexity and processing overhead increase
Solution Approach 1:
The patent performs preliminary action by pre-computing and storing the hierarchical hash structure (Merkle tree) during data ingestion. This preliminary setup creates the verification framework in advance, so that when privacy-preserving proofs are needed, the system can efficiently generate them by simply traversing the pre-built tree structure rather than performing complex computations from scratch.
Solution Approach 2:
The patent uses cryptographic hashing to create simplified copies or representations of the data structure. Instead of storing and transmitting actual sensitive data for verification, the system uses hash copies that preserve verification functionality while eliminating privacy risks. The root hash serves as a compact copy that represents the entire dataset's integrity.
Data Source
AI summary
The present disclosure relates to storing a set of n data entries. The method includes creating a tree of ary l such that n leaf nodes of the tree comprise a set of hash values of the set of data entries respectively. For each parent node of the tree, a bilinear accumulator of hash values of l children of the parent node may be computed. A hash value of the bilinear accumulator may be computed. The root node of the tree may be stored as a representation of the content of the set of data entries.