Kernel extension verification is untenable

Jinghao Jia, Raj Sahu, Adam Oswald, Dan Williams, Michael V. Le, Tianyin Xu

Abstract

The Linux kernel's eBPF verifier, the gatekeeper of "safe" kernel extensions, has become a complex, buggy liability. As the verifier grows in size and complexity to meet developer demands, it introduces its own security vulnerabilities. This paper argues that the current verification model is untenable and proposes a shift toward a Rust-based framework combining language-level safety, signed binaries, and lightweight runtime guards.

Introduction

For years, eBPF has been the gold standard for safely extending the Linux kernel without rebooting or risking system crashes. It works by forcing programs into a restricted bytecode format that an in-kernel verifier checks for safety properties like termination and memory safety. However, this model is reaching its breaking point. As developers demand more power, the verifier has grown massively in complexity, leading to security vulnerabilities. To bypass strict limitations, the kernel community has introduced hundreds of "helper functions"—unverified C code that acts as an escape hatch, often re-introducing the very bugs eBPF was designed to prevent.

Methods

The authors employed a multi-pronged approach to evaluate the current state of eBPF:

  1. Complexity Analysis: Tracking the growth of the verifier's source code (Lines of Code) from versions 3.18 to 6.1 and mapping the call-graph complexity of helper functions in Linux v5.18.
  2. Bug Mining: Manually auditing Linux commit logs and CVEs from 2021 and 2022 to identify security-related bugs in the verifier and its helpers.
  3. Exploit Demonstration: Crafting proof-of-concept exploits to show how "verified" code can still crash the kernel or cause infinite loops.
  4. Architectural Design: Proposing a new system based on Safe Rust and signed binaries.

The Complexity Crisis

The complexity analysis revealed a significant increase in the trusted computing base within the kernel.

Growth of the eBPF verifier's source code (Lines of Code) from 2014 to 2022.

As shown in Figure 4, the eBPF verifier has quadrupled in size, growing from approximately 3,000 lines of code in 2014 to over 12,000 in 2022. This bloat makes static analysis computationally expensive and prone to logic gaps. Furthermore, the "Helper Function Paradox" introduces unverified C code; some helpers call over 500 other functions, creating a massive unverified attack surface that the verifier cannot effectively inspect.

Security Vulnerabilities in Practice

The audit of Linux commit logs identified 40 security-related bugs specifically within the eBPF ecosystem during a two-year period.

Summary of 40 security vulnerabilities and bugs identified in the eBPF verifier and helper functions (2021-2022).

As detailed in Figure 6, these bugs are split between the verifier itself (22 bugs) and the "safe" helper functions (18 bugs). The authors successfully demonstrated exploits, such as crashing the kernel by passing a NULL pointer through a union in the bpf_sys_bpf helper—a deep inspection the verifier currently skips. They also crafted programs using nested bpf_loop calls that could run for millions of years while holding kernel locks, despite the verifier's termination guarantees.

A Proposed Alternative: Safe Rust

The paper proposes a fundamental architectural shift. Instead of an in-kernel verifier attempting to prove safety for arbitrary bytecode, the kernel should rely on:

  • Safe Rust: Using Rust’s ownership and type system to guarantee memory safety at compile-time in userspace.
  • Signed Binaries: A trusted userspace toolchain signs the code, allowing the kernel to verify the origin and integrity of the extension.
  • Lightweight Runtime Guards: Using simple mechanisms like watchdog timers to handle properties that are hard to check statically, such as program termination.

Conclusion

The current trajectory of eBPF verification is unsustainable. The increasing complexity of the verifier and the reliance on unverified helper functions undermine the safety guarantees of the system. Transitioning to a model based on language-level safety and signed binaries offers a more robust and scalable path for kernel extensibility.

Summary updated

BibTeX
@inproceedings{jia2023kernel,
  author = {Jinghao Jia and Raj Sahu and Adam Oswald and Dan Williams and Michael V. Le and Tianyin Xu},
  title = {{Kernel extension verification is untenable}},
  booktitle = {HotOS},
  year = {2023},
  doi = {10.1145/3593856.3595892},
}

Loading related content...

Figure