AI summaryⓘ
The authors studied how different cloud environments share files and memory in ways that can unintentionally leak timing information, even when using strong isolation methods like virtual machines and sandbox runtimes. They found that the operating system's page cache creates a side channel that attackers could observe by measuring how fast files are accessed, revealing some information about what others are doing. This happens because the shared hardware caches affect timing and cannot be fully hidden by software isolation alone. Their research shows that while some configurations reduce this leakage, the risk persists across many common setups. They suggest that better coordination between hardware, virtualization, and operating systems is needed to stop these timing leaks.
cloud platformscontainerssandboxed runtimesvirtual machinespage cacheside channel attackmicroarchitectural timingvirtualizationOverlayFSvirtio-fs
Authors
Alon Abudraham, Xingyu Chen, Itamar Levi, Ari Trachtenberg
Abstract
Modern cloud platforms increasingly combine strong software isolation mechanisms with shared hardware resources to improve performance and resource efficiency. Conventional containers do this by sharing the host kernel directly, whereas sandboxed runtimes (e.g., gVisor) and VM-based runtimes (e.g., Kata, QEMU/KVM) provide progressively stronger isolation. In all cases, when tenants access host-backed filesystem state, the host page cache can remain shared and observable. Although OS-managed, this page-cache channel forms an OS-mediated microarchitectural timing side channel whose signal is shaped by the processor microarchitecture, memory and storage hierarchies, and virtualization mechanisms. We thus investigate whether unprivileged timing measurements can reveal page-cache residency across these isolation boundaries. Our evaluation covers Docker; gVisor with systrap and KVM; Kata Containers using QEMU and Cloud Hypervisor with shared host filesystems; Kata using QEMU, Cloud Hypervisor, and Firecracker with block-device-backed storage; and QEMU/KVM virtual machines under multiple host cache policies. Our results show that the timing signal persists whenever the I/O path exposes shared, host-cacheable file-backed objects, including under OverlayFS layers, virtio-fs exports, and loop-backed block devices. However, direct I/O and dedicated block devices substantially attenuate or eliminate the signal. Virtualization therefore reshapes leakage through added latency and algorithmic noise but does not remove the underlying dependence on shared hardware and cache state. We showcase this through a case study in which we recover coarse-grained activity from a WordPress deployment backed by MySQL. These results place page-cache attacks within the broader class of OS-mediated microarchitectural timing channels and motivate coordinated hardware, virtualization, and OS support for timing isolation.