Blockchain-Anchored Document Verification: Cryptographic Proof for Legal Contracts

import hashlib
import os
from datetime import datetime

def compute_document_hash(file_path, hash_algorithm='sha256', chunk_size=8192):
    """
    Compute cryptographic hash of a document.
    
    Args:
        file_path: path to document file
        hash_algorithm: 'sha256', 'sha3_256', or 'blake2b'
        chunk_size: bytes to read at once (for large files)
    
    Returns:
        tuple: (hex_digest, hash_algorithm, file_size, timestamp)
    """
    hash_functions = {
        'sha256': hashlib.sha256,
        'sha3_256': hashlib.sha3_256,
        'blake2b': hashlib.blake2b
    }
    
    if hash_algorithm not in hash_functions:
        raise ValueError(f"Unsupported hash algorithm: {hash_algorithm}")
    
    hasher = hash_functions[hash_algorithm]()
    file_size = os.path.getsize(file_path)
    
    # Stream file in chunks to handle large documents
    with open(file_path, 'rb') as f:
        while chunk := f.read(chunk_size):
            hasher.update(chunk)
    
    return {
        'hash': hasher.hexdigest(),
        'algorithm': hash_algorithm,
        'file_size': file_size,
        'file_name': os.path.basename(file_path),
        'timestamp': datetime.utcnow().isoformat()
    }


def verify_document_integrity(file_path, expected_hash, hash_algorithm='sha256'):
    """
    Verify document has not been modified by comparing hashes.
    
    Returns:
        bool: True if hashes match (document unchanged), False otherwise
    """
    current_hash = compute_document_hash(file_path, hash_algorithm)['hash']
    return current_hash == expected_hash


# Example: Hash a legal contract
contract_metadata = compute_document_hash('merger_agreement.pdf')
print(f"Document: {contract_metadata['file_name']}")
print(f"SHA-256 Hash: {contract_metadata['hash']}")
print(f"Size: {contract_metadata['file_size']:,} bytes")
print(f"Timestamp: {contract_metadata['timestamp']}")

# Output:
# Document: merger_agreement.pdf
# SHA-256 Hash: 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b
# Size: 2,458,624 bytes
# Timestamp: 2025-01-05T14:23:17.453829


# Later: Verify document hasn't been tampered with
is_authentic = verify_document_integrity(
    'merger_agreement.pdf',
    '3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b'
)
print(f"Document authentic: {is_authentic}")  # True if unchanged, False if modified
                    

import hashlib
from typing import List, Dict, Optional

class MerkleTree:
    """Merkle tree for efficient batch document verification."""
    
    def __init__(self, document_hashes: List[str]):
        """
        Build Merkle tree from document hashes.
        
        Args:
            document_hashes: List of SHA-256 hashes (hex strings)
        """
        if not document_hashes:
            raise ValueError("Cannot create Merkle tree from empty list")
        
        self.leaves = document_hashes.copy()
        self.tree = self._build_tree(document_hashes)
        self.root = self.tree[-1][0] if self.tree else None
        
    def _hash_pair(self, left: str, right: str) -> str:
        """Hash two nodes together (lexicographically sorted)."""
        # Sort to ensure consistent ordering
        if left > right:
            left, right = right, left
        combined = left + right
        return hashlib.sha256(combined.encode()).hexdigest()
    
    def _build_tree(self, hashes: List[str]) -> List[List[str]]:
        """Build Merkle tree bottom-up."""
        if not hashes:
            return []
        
        tree = [hashes]
        current_level = hashes
        
        while len(current_level) > 1:
            next_level = []
            
            # Process pairs
            for i in range(0, len(current_level), 2):
                left = current_level[i]
                # If odd number of nodes, duplicate last node
                right = current_level[i + 1] if i + 1 < len(current_level) else left
                parent = self._hash_pair(left, right)
                next_level.append(parent)
            
            tree.append(next_level)
            current_level = next_level
        
        return tree
    
    def get_root(self) -> str:
        """Get Merkle root hash."""
        return self.root
    
    def get_proof(self, document_hash: str) -> Optional[List[Dict]]:
        """
        Generate Merkle proof for a document.
        
        Returns list of sibling hashes needed to reconstruct root.
        Format: [{'hash': sibling_hash, 'position': 'left'|'right'}, ...]
        """
        try:
            # Find leaf index
            leaf_index = self.leaves.index(document_hash)
        except ValueError:
            return None  # Document not in tree
        
        proof = []
        current_index = leaf_index
        
        # Traverse from leaf to root
        for level_idx in range(len(self.tree) - 1):
            level = self.tree[level_idx]
            
            # Determine sibling
            if current_index % 2 == 0:
                # Current node is left child
                sibling_index = current_index + 1
                position = 'right'
            else:
                # Current node is right child
                sibling_index = current_index - 1
                position = 'left'
            
            # Handle case where sibling doesn't exist (odd number of nodes)
            if sibling_index < len(level):
                sibling_hash = level[sibling_index]
            else:
                sibling_hash = level[current_index]  # Duplicate
            
            proof.append({
                'hash': sibling_hash,
                'position': position
            })
            
            # Move to parent level
            current_index = current_index // 2
        
        return proof
    
    def verify_proof(self, document_hash: str, proof: List[Dict], root: str) -> bool:
        """
        Verify a Merkle proof.
        
        Args:
            document_hash: hash of document to verify
            proof: list of sibling hashes from get_proof()
            root: expected Merkle root
        
        Returns:
            True if proof valid (document in tree), False otherwise
        """
        current_hash = document_hash
        
        # Reconstruct path to root
        for step in proof:
            sibling = step['hash']
            position = step['position']
            
            if position == 'left':
                current_hash = self._hash_pair(sibling, current_hash)
            else:
                current_hash = self._hash_pair(current_hash, sibling)
        
        return current_hash == root


# Example: Batch verification for 8 documents
document_hashes = [
    '3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b',  # contract1.pdf
    '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',  # contract2.pdf
    'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',  # deed.pdf
    '2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae',  # invoice.pdf
    'fcde2b2edba56bf408601fb721fe9b5c338d10ee429ea04fae5511b68fbf8fb9',  # agreement.pdf
    'bef57ec7f53a6d40beb640a780a639c83bc29ac8a9816f1fc6c5c6dcd93c4721',  # policy.pdf
    'e7f6c011776e8db7cd330b54174fd76f7d0216b612387a5ffcfb81e6f0919683',  # memo.pdf
    'cd2662154e6d76b2b2b92e70c0cac3ccf534f9b74eb5b89819ec509083d00a50',  # report.pdf
]

# Build Merkle tree
tree = MerkleTree(document_hashes)
merkle_root = tree.get_root()
print(f"Merkle Root (to be stored on blockchain):")
print(f"{merkle_root}\n")

# Generate proof for contract1.pdf
target_hash = document_hashes[0]
proof = tree.get_proof(target_hash)

print(f"Merkle Proof for contract1.pdf:")
print(f"Document Hash: {target_hash}")
print(f"Proof (3 hashes for 8 documents = log₂(8)):")
for i, step in enumerate(proof):
    print(f"  Level {i+1}: {step['hash'][:16]}... (position: {step['position']})")

# Verify proof
is_valid = tree.verify_proof(target_hash, proof, merkle_root)
print(f"\nProof Valid: {is_valid}")

# Try to verify tampered document (should fail)
tampered_hash = '0000000000000000000000000000000000000000000000000000000000000000'
is_valid_tampered = tree.verify_proof(tampered_hash, proof, merkle_root)
print(f"Tampered Document Valid: {is_valid_tampered}")
                    

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DocumentVerification {
    
    // Event emitted when Merkle root anchored
    event MerkleRootAnchored(
        bytes32 indexed merkleRoot,
        uint256 timestamp,
        uint256 blockNumber,
        uint32 documentCount,
        string batchId
    );
    
    // Event emitted when document verified
    event DocumentVerified(
        bytes32 indexed documentHash,
        bytes32 indexed merkleRoot,
        address verifier,
        uint256 timestamp
    );
    
    // Struct for anchor record
    struct Anchor {
        uint256 timestamp;
        uint256 blockNumber;
        uint32 documentCount;
        string batchId;
        bool exists;
    }
    
    // Mapping: Merkle root => Anchor metadata
    mapping(bytes32 => Anchor) public anchors;
    
    // Owner (for access control)
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    /**
     * @notice Anchor a Merkle root representing a batch of documents
     * @param merkleRoot The root hash of the Merkle tree
     * @param documentCount Number of documents in batch
     * @param batchId Unique identifier for this batch
     */
    function anchorMerkleRoot(
        bytes32 merkleRoot,
        uint32 documentCount,
        string calldata batchId
    ) external {
        require(msg.sender == owner, "Only owner can anchor");
        require(!anchors[merkleRoot].exists, "Root already anchored");
        require(documentCount > 0, "Document count must be positive");
        
        anchors[merkleRoot] = Anchor({
            timestamp: block.timestamp,
            blockNumber: block.number,
            documentCount: documentCount,
            batchId: batchId,
            exists: true
        });
        
        emit MerkleRootAnchored(
            merkleRoot,
            block.timestamp,
            block.number,
            documentCount,
            batchId
        );
    }
    
    /**
     * @notice Verify a document is part of an anchored Merkle tree
     * @param documentHash SHA-256 hash of the document
     * @param merkleRoot The Merkle root to verify against
     * @param proof Array of sibling hashes (Merkle proof)
     * @param positions Array of positions ('0' = left, '1' = right)
     * @return bool True if proof valid, false otherwise
     */
    function verifyDocument(
        bytes32 documentHash,
        bytes32 merkleRoot,
        bytes32[] calldata proof,
        bool[] calldata positions
    ) external returns (bool) {
        require(anchors[merkleRoot].exists, "Merkle root not anchored");
        require(proof.length == positions.length, "Proof/position length mismatch");
        
        bytes32 computedHash = documentHash;
        
        // Reconstruct Merkle root from proof
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 sibling = proof[i];
            
            if (positions[i]) {
                // Sibling is on the right
                computedHash = keccak256(abi.encodePacked(computedHash, sibling));
            } else {
                // Sibling is on the left
                computedHash = keccak256(abi.encodePacked(sibling, computedHash));
            }
        }
        
        bool isValid = (computedHash == merkleRoot);
        
        if (isValid) {
            emit DocumentVerified(
                documentHash,
                merkleRoot,
                msg.sender,
                block.timestamp
            );
        }
        
        return isValid;
    }
    
    /**
     * @notice Get anchor metadata for a Merkle root
     * @param merkleRoot The Merkle root to query
     * @return timestamp Block timestamp when anchored
     * @return blockNumber Block number when anchored
     * @return documentCount Number of documents in batch
     * @return batchId Batch identifier
     */
    function getAnchor(bytes32 merkleRoot) external view returns (
        uint256 timestamp,
        uint256 blockNumber,
        uint32 documentCount,
        string memory batchId
    ) {
        require(anchors[merkleRoot].exists, "Merkle root not found");
        Anchor memory anchor = anchors[merkleRoot];
        return (
            anchor.timestamp,
            anchor.blockNumber,
            anchor.documentCount,
            anchor.batchId
        );
    }
    
    /**
     * @notice Check if a Merkle root has been anchored
     * @param merkleRoot The Merkle root to check
     * @return bool True if anchored, false otherwise
     */
    function isAnchored(bytes32 merkleRoot) external view returns (bool) {
        return anchors[merkleRoot].exists;
    }
}