In the evolution of cloud computing, containers have become the standard unit of deployment because they offer "near-native" performance. Unlike traditional Virtual Machines (VMs), which emulate an entire hardware stack and run a complete guest operating system, containers share the host’s operating system kernel.
As Joel Mandebi Mbongue, Danielle Tchuinkou Kwadjo, and Christophe Bobda explore in Performance Exploration of Virtualization Systems, this architectural choice eliminates the overhead of hardware emulation. However, this efficiency creates a fundamental security paradox: the very mechanism that makes containers fast—the shared kernel—is also their greatest vulnerability.
The Shared Kernel as an Attack Surface
In a standard container environment, the boundary between a tenant and the host is enforced by software features like namespaces and control groups (cgroups). While these provide a logical separation, they do not provide a physical one. Udit Gupta points out in Comparison between security majors in virtual machine and linux containers that this lack of a "hard" hardware-level boundary makes the host kernel a single point of failure.
If an attacker compromises a process inside a container, they are only one kernel exploit away from total system control. Because the kernel is monolithic, a vulnerability in a single subsystem can expose the entire environment. Ujas Dhami notes in the context of NIJAS OS that monolithic kernels execute instructions in a shared memory space, meaning a leak in one area can compromise sensitive data across the entire kernel.
The System Call Bottleneck
The primary interface between a container and the shared kernel is the system call (syscall). Modern kernels provide hundreds of syscalls, but most applications only need a small fraction of them. Haney Kang and colleagues demonstrate in BEACON that default container configurations often permit access to hundreds of unnecessary syscalls, unnecessarily widening the attack surface.
To address this, researchers are moving toward "least-privilege" syscall filtering. The challenge is determining exactly which syscalls an application needs without breaking it. Seungyong Yang and Brent ByungHoon Kang propose Optimus, a framework for dynamic syscall filtering that reduces the attack surface by associating syscalls with specific application behaviors. Similarly, the BEACON tool uses environment-aware dynamic analysis to stress-test containers and automatically generate tighter security policies.
The Performance-Isolation Tension
Why not simply use VMs if they are more secure? The answer lies in latency. In high-performance domains like Serverless computing or High-Performance Computing (HPC), even a few milliseconds of overhead is unacceptable. Marcin Copik and Torsten Hoefler describe in RFaaS how achieving microsecond-level latency often requires bypassing virtualization layers entirely, yet this "bare metal" approach sacrifices the multi-tenant isolation required for cloud safety.
Furthermore, even when we attempt to isolate the kernel, performance optimizations can undermine us. Yueqiang Cheng and Surya Nepal show in Still Hammerable and Exploitable that "zero-copy" mechanisms—designed to speed up data transfer by mapping kernel buffers directly into user space—can create backdoors that allow attackers to bypass physical memory isolation.
Toward Stronger Lightweight Isolation
The research direction is currently shifting from merely restricting the kernel interface to partitioning the kernel itself.
Hang Huang, Jia Rao, and Song Wu propose a middle ground called vKernel. Instead of a fully shared or fully separate kernel, vKernel provides containers with private versions of sensitive kernel code and data structures. This approach aims to provide the physical isolation of a VM with the startup speed and execution efficiency of a container.
By moving away from a "one-size-fits-all" shared kernel toward environments that are formally defined (Qian Liu et al.) and dynamically hardened, the field seeks to resolve the conflict between the speed of lightweight virtualization and the security of hardware-level isolation. As G. Marra and colleagues conclude in their study of CubeSat sandboxing, while no software sandbox is immune to zero-day exploits, the goal is to make the cost of escape so high that the shared-kernel model becomes viable even for mission-critical systems.