Lightweight Tamper-Evident Log Integrity Verification for IoT Edge Environments: A Merkle Tree Pipeline with Adaptive Chunking

1. Problem Statement

The integrity of audit logs generated by Internet-of-Things (IoT) devices is critical for post-incident forensics, regulatory compliance, and operational accountability. However, existing solutions face significant barriers when deployed at the IoT edge:

• Blockchain-based approaches: While offering strong non-repudiation, they impose high consensus overhead, network dependencies, and deployment complexity that exceed the resource constraints (sub-GHz processors, limited RAM, intermittent connectivity) of edge devices.
• Key-evolution and Signature-based schemes: These often require sequential verification ($O(n)$ complexity) or per-entry cryptographic signing, which is computationally expensive and lacks random-access capabilities.
• Hardware-rooted trust: Solutions relying on Trusted Platform Modules (TPMs) are not universally available on commodity IoT hardware.

There is a gap for a lightweight, resource-aware, distributed-ledger-free solution that provides tamper evidence with low latency and minimal memory footprint.

2. Methodology

The authors propose a three-stage pipeline architecture designed specifically for resource-constrained environments:

A. Adaptive Chunking (Stage 1)

To balance memory usage and throughput, the system does not ingest logs monolithically or one-by-one. Instead, it uses a resource-aware chunking mechanism:

• Dynamic Sizing: The chunk size ($C$) is dynamically adjusted based on available system memory ($M_{avail}$) and memory pressure ($P$).
• Policy: If memory pressure is high, the chunk size decreases to prevent allocation failures; if pressure is low, it increases to maximize throughput.
• Goal: This ensures graceful degradation under memory constraints rather than abrupt system failure, crucial for devices without swap space.

B. Merkle-Tree Construction (Stage 2)

• Structure: Log entries are hashed (using SHA-256 or BLAKE2b) to form leaf nodes. A binary hash tree is constructed where internal nodes are hashes of their children ($H(h_{left} || h_{right})$).
• Optimization: The system rebuilds the tree once per batch after all new leaves are appended, avoiding redundant full-tree rebuilds for every single entry.
• Commitment: Only the root hash ($R$) is stored in a trusted anchor (e.g., a hardware security module, TPM, or remote append-only store).

C. Verification (Stage 3)

• Inclusion Proofs: To verify a specific log entry $L_i$, the system generates an inclusion proof consisting of the sibling hashes along the path from the leaf to the root.
• Complexity: The proof size and verification cost are $O(\log n)$, allowing for random-access verification without processing preceding entries.
• Process: The verifier recomputes the root using the entry and the proof path, comparing it against the trusted anchor $R$.

3. Key Contributions

The paper makes four distinct contributions:

1. Audited Implementation & Correctness:
   • The authors conducted a rigorous code audit that identified and fixed two critical evaluation defects in their initial prototype:
     • Double-counting bug: A logic error in tampering metrics that yielded impossible accuracy values (>1.0).
     • Redundant rebuild bug: An inefficiency that rebuilt the entire tree after every single log insertion within a batch ($O(bn)$), which was corrected to rebuild once per batch ($O(n)$).
2. Adaptive Merkle Pipeline:
   • A novel architecture combining adaptive ingestion with Merkle trees, achieving >130,000 logs/s throughput and <5 MB peak memory on a standard workstation, with $O(\log n)$ proof sizes.
3. Formal Security Analysis:
   • Provided proof sketches under standard hash-function assumptions (collision and second-preimage resistance).
   • Analyzed resistance against modification, deletion (truncation), injection, and replay attacks.
   • Demonstrated that adaptive chunking does not weaken cryptographic security properties.
4. Systematic Comparative Positioning:
   • A multi-dimensional comparison against key-evolution, signature-based, authenticated-structure, and blockchain systems, highlighting the trade-offs in trust models, verification complexity, and edge suitability.

4. Experimental Results

Experiments were conducted on a single workstation (Intel Core i7, 32 GB RAM) using synthetic IoT logs.

• Throughput:
  • At 100,000 records, the system sustained 134,242 logs/s (adaptive) and 138,850 logs/s (fixed chunking).
  • Both modes stabilized above 130,000 logs/s for large datasets.
• Verification & Proof Generation:
  • Single-entry verification: ~22 ms.
  • Proof generation: ~22 ms.
  • Proof Size: Average of 1,006 bytes (14 sibling hashes for 10,000 entries), confirming $O(\log n)$ scaling.
• Memory Footprint:
  • Peak memory usage remained below 5 MB (specifically ~4.23 MB) even at 100,000 entries, making it feasible for constrained edge devices.
• Tampering Detection:
  • Achieved Precision, Recall, and F1 scores of 1.0 across corruption ratios from 1% to 50%.
  • Detection was deterministic; any modification to a leaf hash propagated to the root with overwhelming probability.
• Hash Algorithm Comparison:
  • BLAKE2b offered a 7.2% higher ingestion throughput compared to SHA-256 with comparable verification latency, suggesting it as a preferred option for throughput-constrained scenarios.

5. Significance

This work addresses a critical gap in IoT security by providing a practical, lightweight alternative to blockchain for log integrity.

• Edge-Ready: It eliminates the need for distributed consensus and heavy network dependencies, making it deployable on single-device edge gateways with limited resources.
• Forensic Utility: The $O(\log n)$ random-access capability allows investigators to verify specific events without re-processing the entire log history, a significant advantage over sequential key-evolution schemes.
• Scientific Rigor: The paper sets a high standard for security research by explicitly documenting and correcting implementation bugs that would have otherwise invalidated the performance and accuracy claims.
• Reproducibility: The authors provide full source code, synthetic log generators, and benchmark scripts, establishing a reproducible baseline for future research in edge log integrity.

In conclusion, the proposed pipeline offers a robust, high-throughput, and low-latency solution for ensuring the integrity of IoT audit logs, balancing cryptographic security with the strict resource constraints of edge computing environments.