Immutable Datastore Using Merkle Trees for Tamper-Evident Storage
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional databases fail to adequately protect against internal threats and tampering, as they often rely on mutable audit logs and lack robust security features for large data sets, particularly in latency-sensitive applications, where blockchain systems are not well-suited for storing large objects and may suffer from scalability issues.
Innovation Solution
The implementation of an immutable datastore using a directed acyclic graph with cryptographic hash pointers, such as Docuchain, which stores data directly in Merkle Trees, preventing tampering and reducing latency through O(log(n)) get/put operations, and fragments data across multiple storage structures for enhanced security and scalability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional databases are used for storing large data sets, then ease of operation and scalability are maintained, but security against internal threats and tampering is insufficient
Solution Approach 1:
The patent segments data into fixed-size chunks and stores them as leaves in a Merkle Tree structure. Each chunk is independently hashed and linked to parent nodes, creating a hierarchical segmentation that enables both security (through cryptographic verification) and efficiency (through selective retrieval). This segmentation resolves the contradiction by making large data sets manageable while maintaining tamper evidence.
Solution Approach 2:
The patent implements nested hashing where child node hashes are embedded within parent node hashes in a Merkle Tree structure. The root hash encapsulates all leaf hashes, and each intermediate node encapsulates its children. This nesting provides cryptographic verification at multiple levels, ensuring security while maintaining a compact hierarchical structure that scales efficiently.
2Reliability
If blockchain systems are used for storing large objects, then security and immutability are improved, but scalability and performance suffer
Solution Approach 1:
The patent extracts the actual data content from the immutable structure, storing only cryptographic hashes (root hash, leaf hashes) in the Merkle Tree while keeping the full data chunks in a separate, mutable storage location. This extraction allows the immutable structure to remain compact and fast for verification purposes, while the actual large objects are stored externally, resolving the scalability and performance issues.
Solution Approach 2:
The patent performs preliminary hashing of data chunks into fixed-size hashes before storing them in the Merkle Tree. This preliminary cryptographic transformation allows the system to work with compact hash representations rather than large data objects, enabling fast write operations and efficient storage while maintaining the ability to verify data integrity through the immutable hash structure.
3Reliability
If cryptographic hashing is performed on all data nodes, then tamper evidence is achieved, but computational overhead and latency increase
Solution Approach 1:
The patent applies cryptographic hashing selectively rather than uniformly to all data. Only the essential structural elements (leaf hashes representing data chunks and parent node hashes for verification) are hashed and stored in the Merkle Tree. This local application of cryptography provides tamper evidence for the critical integrity-checking components while avoiding the computational overhead of hashing entire large data sets, thus reducing latency.
Data Source
AI summary
Provided is a process including: receiving a write command requesting that a document associated with the write command be stored in an immutable data structure that prevents an attacker attempting to modify the document from concealing that the document was modified after storing the document in the data structure; forming a tamper-evident, immutable directed acyclic graph having the document in one or more nodes of the graph; and storing the directed acyclic graph.