Private Structured Database Hash Trees for Blockchain Verification
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for securing private structured databases on public blockchains face challenges in ensuring data confidentiality and integrity while allowing for efficient data updates and transactions.
Innovation Solution
A method involving the generation of hash trees and non-interactive proofs of inclusion to secure private structured databases on public blockchains, enabling secure data updates and transactions by obfuscating content from public inspection and verifying data integrity using root hashes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If private structured databases are stored on public blockchains, then data confidentiality is improved, but data integrity verification becomes complex
Solution Approach 1:
The database is segmented into individual data units, each with its own hash value. These hash values are organized into a Merkle tree structure where leaf nodes represent data unit hashes and internal nodes represent composite hashes. This segmentation allows selective verification of individual data units without requiring verification of the entire database, thus improving confidentiality while simplifying integrity verification.
Solution Approach 2:
A Merkle root hash serves as an intermediary between the private database and the public blockchain. The Merkle root is stored on the blockchain and acts as a compact representation of the entire database state. This intermediary enables verification of data integrity without exposing the actual database contents, resolving the contradiction between confidentiality and verification simplicity.
2Reliability
If hash trees are generated for each data update, then data integrity is improved, but computational overhead increases
Solution Approach 1:
Hash values for data units are pre-computed and organized into a Merkle tree structure before being submitted to the blockchain. The Merkle tree is constructed with leaf nodes containing data unit hashes and internal nodes containing composite hashes. This preliminary organization allows for efficient incremental updates where only affected portions of the tree need to be recalculated, maintaining data integrity while reducing computational overhead compared to regenerating entire hash trees for each update.
3Adaptability or versatility
If all data units are made accessible for transactions, then transaction flexibility is improved, but data security deteriorates
Solution Approach 1:
Different data units within the database are assigned different access permissions and visibility levels. Some data units can be made accessible for transactions while others remain private. The Merkle tree structure allows selective exposure of specific data unit hashes without revealing the contents of other data units. This local differentiation of access quality enables transaction flexibility for permitted data while maintaining security for sensitive data.
Solution Approach 2:
Only the necessary components for transaction verification (data unit hashes and their Merkle proofs) are extracted and made accessible, while the actual sensitive data contents remain private and stored locally. This extraction approach allows transactions to be performed on verified data representations without exposing the underlying sensitive information, thus achieving transaction flexibility without compromising data security.
Data Source
AI summary
A method includes, by a first node in a distributed network: generating a hash tree representing a structured data object including a data unit, the hash tree including a root hash and a data unit hash representing the data unit; accessing a non-interactive proof of inclusion representing membership of the data unit hash within the hash tree; generating a transaction configured to generate a blockchain object including the root hash; and transmitting the transaction and the non-interactive proof of inclusion to a second data node in the distributed network.