VIMA: A Privacy-Preserving Integrity Measurement Architecture for Containerized Environments

Omar Jarkas, Ryan K. L. Ko, Naipeng Dong, Md. Redowan MahmudIACR Trans. Cryptogr. Hardw. Embed. Syst 2025 · DOI

TL;DR

This paper introduces VIMA, a novel architecture that enhances Linux's Integrity Measurement Architecture (IMA) for containerized environments. VIMA uses a Two-Tree Architecture (2TA) with nested Merkle trees and Zero-Knowledge (ZK) proofs to provide granular, privacy-preserving integrity verification and attestation for containers, addressing key limitations of traditional IMA.

What Problem Does This Paper Address?

Containers have revolutionized application deployment due to their efficiency and scalability, making them ideal for multi-tenant, enterprise, and confidential computing. However, their reliance on a shared kernel creates significant security risks, as kernel exploits or misconfigurations can compromise isolation and lead to integrity and privacy breaches. Traditional Linux IMA, while crucial for verifying the integrity of executed binaries, falls short in containerized settings. This is due to:

  • Limited Container Autonomy: IMA's centralized policy control doesn't accommodate the varied security needs of different tenants.
  • Privacy Concerns: Measurements during remote attestation can inadvertently reveal sensitive information about software and container specifics.
  • Lack of Granular Integrity Verification: IMA struggles to perform thorough integrity checks for individual containers, hindering robust verification in large-scale deployments.

These gaps undermine container autonomy, escalate privacy risks, and impede fine-grained integrity checks, necessitating a more container-aware integrity measurement solution.

Methods

VIMA introduces a Virtual IMA (VIMA) framework built upon a novel Two-Tree Architecture (2TA). This architecture leverages nested Merkle trees and Zero-Knowledge (ZK) proofs:

  • Container Merkle Trees (Tcᵢ): Each container maintains its own lightweight Merkle tree, capturing the integrity measurements of all files executed within it. Leaf nodes are formed by hashing file content and metadata.
  • System-Wide Merkle Tree (TM): The roots of individual container Merkle trees (root(Tcᵢ)) are linked as leaf nodes in a system-wide Merkle tree. This creates a cryptographic linkage between containers and the overall system, providing a unified integrity view.
  • Privacy-Preserving Remote Attestation: VIMA integrates ZK proofs with Merkle proofs. This allows a verifier to confirm the integrity of a container or the entire system without accessing detailed measurements, thus protecting sensitive information and addressing privacy concerns.
  • Namespace-Based Container Identification: VIMA uses Linux namespaces to identify and associate executed files with their respective containers from system boot.

The architecture is implemented as a standalone kernel module, avoiding invasive kernel modifications and aiming for compatibility with existing LSM frameworks.

Datasets

Not discussed in the paper. The evaluation uses microbenchmarks and real-world containerized applications.

Key Insights and Ideas

  • Container-Awareness is Crucial: Traditional IMA's monolithic approach is insufficient for the dynamic and multi-tenant nature of containerized environments. VIMA's container-specific Merkle trees are key to addressing this.
  • Merkle Trees for Granularity and Efficiency: Nested Merkle trees provide a scalable way to represent and verify integrity at both the container and system levels, offering a compact proof of integrity.
  • ZK Proofs are Essential for Privacy: The integration of ZK proofs is critical for enabling privacy-preserving remote attestation, a significant improvement over traditional methods that can leak sensitive information.
  • Unified View with Decentralized Autonomy: VIMA successfully balances granular container autonomy with a unified system integrity view, a challenging but important goal.
  • Minimal Performance Overhead: Despite adding complexity, VIMA's design and optimizations (like a quick lookup cache) result in performance overhead comparable to or even better than traditional IMA in many scenarios.

Key Results

  • Performance: VIMA introduces minimal CPU and memory overhead, often comparable to or slightly better than baseline Linux IMA. For most microbenchmarks, the overhead is within 3-16%. Shell-script workloads showed a significant slowdown (around 43-44% of baseline), identified as an outlier due to the specific test's append-heavy nature.
  • AI/ML Frameworks: Workloads like AlexNet and OpenVINO showed less than 10% overhead and maintained full scalability up to 32 threads.
  • Databases and Web Servers: Redis and SQLite showed performance at or slightly above the no-IMA baseline in most operations. Web servers (Lighttpd and Nginx) maintained throughput within 10% of the no-IMA baseline, even at peak concurrency.
  • Security: VIMA effectively mitigates threats like tainted kernel attacks, container tampering, and remote attestation privacy breaches by leveraging hardware roots of trust, cryptographic linkage, and ZK proofs.

Limitations and Future Work

  • Shell-Script Outlier: The significant slowdown observed in shell-script workloads is acknowledged as a limitation, attributed to the test's specific append-heavy nature. Future work could explore further optimizations for such scenarios.
  • Fileless Kernel Exploits: VIMA primarily focuses on file integrity and may not detect all forms of fileless kernel exploits that occur entirely in memory without file modifications. The authors suggest integrating runtime behavioral analysis, memory integrity checks, or anomaly detection systems for enhanced detection.
  • ZK Proof Implementation: While the architecture supports ZK proofs, the current prototype does not generate them directly but transfers Merkle proofs. Future work involves integrating ZK proof generation using libraries like libSTARK.
  • Heuristic Container Detection: Container detection relies on heuristics (PID and mount namespaces) which, while robust, are not a first-class container object.

Summary updated

BibTeX
@article{jarkas2025vima,
  author = {Omar Jarkas and Ryan K. L. Ko and Naipeng Dong and Md. Redowan Mahmud},
  title = {{VIMA: A Privacy-Preserving Integrity Measurement Architecture for Containerized Environments}},
  journal = {IACR Trans. Cryptogr. Hardw. Embed. Syst.},
  year = {2025},
  doi = {10.46586/tches.v2025.i4.1053-1076},
}
Figure