Application Sandboxing

Principles, Technologies, and Secure Isolation

Introduction: When Isolation Fails

1. The Promise of Sandboxing
2. What This Book Covers
3. What This Book Does Not Cover
4. How to Read This Book
5. A Note on the Evolving Landscape

Chapter 1: Why Sandboxing? — The Threat Model and the Promise of Isolation

1. The Cost of Unbounded Execution: Real Incidents
2. Blast Radius and the Defense-in-Depth Philosophy
3. A Taxonomy of Isolation Mechanisms
4. What This Book Will (and Won’t) Cover

Chapter 2: The Kernel as Enforcer — Namespaces, Cgroups, and the Linux Sandboxing Stack

1. Namespaces: Partitioning What You See
2. Cgroups: Controlling What You Can Do
3. User Namespaces and Unprivileged Containers
4. Composing Isolation: From Primitives to Containers
5. Limitations and Known Gaps in Linux Isolation

Chapter 3: Mandatory Access Control — SELinux, AppArmor, and Smack

1. Discretionary vs Mandatory Access Control
2. SELinux: Architecture and Policy Model
3. AppArmor: Profile-Based Protection
4. Smack and Alternative MAC Frameworks
5. Operational Challenges and Adoption Barriers

Chapter 4: System Call Filtering — seccomp, Landlock, and Capability Dropping

1. Linux Capabilities: Fine-Grained Privilege Splitting
2. seccomp-bpf: Filtering the System Call Surface
3. Landlock: A New Era of Unprivileged Sandboxing
4. Composing Filters with Capability Dropping
5. Real-World seccomp Profiles and Case Studies

Chapter 5: eBPF — The Universal Sandbox Primitive

1. From TCPdump to Trusted Kernel Runtime: The eBPF Revolution
2. How eBPF Works: Verifier, Programs, and Maps
3. eBPF for Network and Filesystem Sandboxing
4. Observability-Driven Security with eBPF
5. Trust Boundaries and the eBPF Threat Model
6. The eBPF Security Model in Practice

Chapter 6: Container Runtimes and the OCI Ecosystem

1. The OCI Standard: Making Containers Portable
2. Docker Architecture Deep Dive
3. containerd and CRI-O: Kubernetes-Native Runtimes
4. Rootless Containers and User Namespace Remapping
5. Storage Drivers and Image Layers

Chapter 7: Virtual Machines and MicroVMs — Hardware-Level Isolation

1. Virtualization Fundamentals and the Hypervisor Stack
2. KVM and QEMU: The Linux Virtualization Foundation
3. MicroVMs: Firecracker, Crosvm, and the Edge of Performance
4. Security Comparison: VMs vs Containers
5. When to Choose Hardware Isolation Over OS-Level Sandboxing

Chapter 8: Desktop and Mobile Sandboxes — macOS, Windows, Android, iOS, and Browsers

1. macOS Sandbox: Seatbelt and Entitlements
2. Windows AppContainer and Virtual-Based Sandboxing
3. Android’s Per-App Isolation Model
4. iOS Application Sandboxing and Entitlements
5. Browser Sandboxes: Process Isolation and Site Separation

Chapter 9: Language and Runtime Sandboxes — From chroot to WebAssembly

1. chroot: The Oldest Trick in the Book
2. FreeBSD Jails: BSD’s Isolation Philosophy
3. LXC and LXD: System Containers on Linux
4. WebAssembly and WASI: Sandboxing at the Bytecode Level
5. Language and Runtime Sandboxing Approaches

Chapter 10: Sandbox Escapes — How Isolation Fails and What to Do About It

1. Container Escape Techniques and Case Studies
2. VM Escape: Hypervisor Vulnerabilities and Side Channels
3. Browser Sandbox Bypasses
4. Desktop OS Sandbox Escapes
5. Defense Strategies and the Ongoing Arms Race

Chapter 11: Designing and Operating Sandboxed Environments

1. Threat Modeling Your Sandboxing Strategy
2. Selecting Isolation Technology for Different Workloads
3. Hardening Container Images and Runtimes
4. Network Segmentation and Zero-Trust Networking
5. Observability, Debugging, and Operational Excellence

Chapter 12: The Future of Sandboxing — Serverless, Confidential Computing, and Beyond

1. Serverless Isolation: The Function-as-a-Service Model
2. Confidential Computing: When the Kernel Can’t Be Trusted
3. WebAssembly’s Expanding Sandbox Horizon
4. The Convergence Playbook: Containers, VMs, and Wasm Together
5. Open Challenges and Where the Field Is Heading

Conclusion: The Principle of Measured Trust

References