Linux Security Summit North America 2025

The Linux Kernel Self-Protection Project was announced in 2015 as a way to gather folks doing security hardening work under a single umbrella and gain upstream traction for killing bug classes and eliminating exploitation methods. Linux security has made significant advances over the last decade as a result of the project's contributors.

We'll review the bug classes that have been completely eliminated (e.g. VLAs, setfs(), switch fall-through, stack variable zeroing), as well as bug classes that have gained wide mitigation coverage (e.g. refcount overflow, FORTIFY_SOURCE, allocation overflow, array overflow). We'll take a look at exploit blocking methods now in place (e.g. vmap stack, W^X, KASLR, slab hardening, %p hashing, IBT/BTI, SCS, KCFI), and newly available attack surface reduction (e.g. seccomp, __ro_after_init, lockdown).

What has the impact been after all this work? We'll review bug class frequency and severity to examine the trends. With so much of the low hanging fruit getting handled, we're now faced with trickier problems such as Use After Free flaws. We'll take a look at what's on the horizon to solve this and other kernel self-protection concerns.

A Play Machine is what is called a system with root as the guest account with only Apparmor to restrict access. It aims to demonstrate that necessary security can be provided by Apparmor without any Unix permissions and thus that root is not everything in modern security.

This play machine uses the apparmor.d project with the Full System Policies (FSP) mode enabled and enforced.
FSP is a special mode of apparmor.d that aims to provide profiles and user roles for every process and users and that ensure no unconfined process can run on the system.

In this talk, we will review the main challenges we encountered — including the security architecture of the profiles, testing, and profile integration. We will also discuss the complications involved in providing open root access on a VM to everyone.

The profiles, tooling, and documentation for the project have been published at https://github.com/roddhjav/apparmor.d. The play machine itself is available at https://play.pujol.io/

In recent years, security researchers and companies have looked to eBPF to build innovative security mechanisms with kernel independent bytecode and a soft guarantee of runtime safety. eBPF and the eBPF LSM in particular are especially useful in environments with bespoke security requirements where other LSMs cannot be or are not used, or kernel rebooting/recompilation is undesirable.
However, eBPF programs, but their nature, present a unique security challenge: any privileged process can fully manipulate the inner workings of all eBPF objects. While SELinux provides a level of coarse-grained access control over eBPF, it is difficult for eBPF developers to tailor SELinux policy to protect their individual tools.
This talk attempts to fill the gap by presenting an eBPF-based mandatory access control framework for protecting eBPF-based tools. The framework uses a configurable policy and no code change required for other tools to opt-in. We will present the design, implementation, and a policy example. We will also highlight areas for future work in the eBPF and LSM subsystems to provide more granular access controls.

Kernel fuzzing has been traditionally done either via on-device fuzzing or using VMs and primarily targeting the attack surface exposed to user-space programs.
In this talk the authors introduce a novel approach towards fuzzing Linux kernel interfaces completely in user space without relying on hardware or virtualization solutions by leveraging an open-source project LKL (Linux kernel library). Using LKL it is possible to build Linux kernel as a user-space library and hook it with a coverage-guided engine such as libFuzzer to fuzz kernel interfaces. This approach enables us to create lightweight coverage-guided modular fuzzers targeting specific kernel interfaces. This approach provides such advantages as high fuzzing performance, scalability and ease of debugging crashes. One of the major highlights of this approach is the ability to target device-to-kernel interfaces exposed to the malicious peripheral devices which are difficult to cover using traditional fuzzing approaches. We will provide deep dive into LKL fuzzing details, like enabling ASAN for LKL, adding code coverage, and showcase examples of fuzzing USB HID and Android binder driver.

Incus is a project providing a private cloud platform that can be used by anyone from running on a simple laptop, Raspberry Pi to being run on thousands of servers in the datacenter.

The project began like most, making source code releases which found their way packaged in distros.

Over time, we developed tooling to automate deployment of those packages, allowing for more consistent deployments.
Unfortunately, this tooling still assumed quite a bit of familiarity with Linux distributions and configuration.

What we really wanted was a way to get reliable, identical deployments that could be used both by very large scale users running thousands of servers as well as by regular users at home who just want a working reliable virtualization platform.

This led to the development of Incus OS. A Debian based OS image made using systemd's mkosi, using a Secure Boot signed bootloader and Unified Kernel Image, TPM measurements throughout the boot process, an immutable OS image (using dm-verity) and full disk encryption for the data at rest based on TPM register state.

In this talk, we'll be diving into the design decisions behind Incus OS and look at its implementation.

The Linux Security Module (LSM) infrastructure has a limited ability to support multiple concurrent security policies. Expanding this capability to eventually encompass supporting arbitrary combination of modules is an ongoing activity. This talk will cover the current state of LSM stacking and the pending proposed changes. It will include a discussion of the limitations imposed when multiple modules have expectation on networking resources, how audit filtering is impacted and the implications for integrity. Opportunities for development of supporting features in parallel with the infrastructure changes will be presented.

TEE Device Interface Security Protocol (TDISP) is an industry standard that defines how to:
a) Establish trust between a Confidential VM (CVM) and a device, through attestation,
b) Secure the interconnect between the host and the device, and
c) Securely attach/detach a device interface to/from a CVM.

The main benefit of a CVM using a TDISP device vs a non-TDISP device is that the former is more performant, while still maintaining the confidentiality and integrity guarantees that Confidential Computing provides. Hence, TDISP plays a crucial part in making CVMs more performant, less expensive and, thus, easier to adopt.

An issue that currently exists with TDISP is that there is no standard way to prove that a TDISP attestation report and a platform attestation report originated from the same CVM. As a result, an attacker could replay an old TDISP attestation report with a CVM that doesn't have that TDISP device and cause a relying party to disclose secrets that wouldn't otherwise.

In this talk we would like to holistically explore this issue, the intended use cases and, finally, discuss a proposed solution using TPM NVIndex.

At present, SELinux only supports defining and enforcing a single system-wide security policy. As a result, for Linux containers, SELinux is generally only used to provide coarse-grained sandboxing and isolation of entire containers, and Linux distributions cannot effectively leverage SELinux from within a container. With the increasing trend toward containerized applications and cloud-native container workloads, there is a growing need for SELinux to better support containers. SELinux namespaces are a proposed feature enhancement that are intended to enable per-container security policies, i.e. each SELinux namespace can load its own policy, while remaining confined by its parent (and other ancestor) policies. SELinux namespaces bring benefits for Linux developers and users by enabling full use of SELinux within containers, whether or not the host OS uses SELinux itself. In this talk we present the background, design, implementation, performance, and residual challenges associated with the work to bring SELinux namespaces to the mainline Linux kernel.

The popularity of fuzzing has led to its tight integration
into the software development process as a routine part
of the build and test, i.e., continuous fuzzing. This has
resulted in a substantial increase in the reporting of bugs
in open-source software, including the Linux kernel. To
keep up with the volume of bugs, it is crucial to automatically analyze the bugs to assist developers and maintain-
ers. Bug bisection, i.e., locating the commit that introduced a vulnerability, is one such analysis that can reveal
the range of affected software versions and help bug prioritization and patching. However, existing automated
solutions fall short in a number of ways: most of them either (1) directly run the same PoC on older software ver-
sions without adapting to changes in bug-triggering conditions and are prone to broken dynamic environments
or (2) require patches that may not be available when
the bug is discovered. In this work, we take a different approach to looking for evidence of fuzzer-exposed
vulnerabilities by looking for the underlying bug logic.
In this way, we can perform bug bisection much more
precisely and accurately.

This talk will present an empirical study of layered attestation for a cross-domain system. The presentation will overview how we boot the system into a trusted state and extend trust to a runtime.

Using IMA and TPM 2.0 we boot a verified attestation manager into a measured state where it may access its signing key. We prove the key can be used only if the right attestation system makes a request in a good state. Thus, a signature's presence on evidence strongly binds that evidence to the attestation manger.

Once booted, the attestation manger measures and appraises the cross-domain system according to a Copland attestation protocol. It calls LKIM and checks SELinux policy to ensure the underlying Linux system is in a good state. Then it measures CDS components and configurations for runtime appraisal.

We then discuss formal verification and empirical study of the attestation system. Specifically, why should trust the link from boot to runtime and the signing key's signature. We then discuss empirical studies that simulate various attacks illustrating design choices, assumptions and limitations.

Note: Co-authors are - Will Thomas, Logan Schmalz, Adam Petz and Sarah Scott

DNS remains a primary attack vector for data exfiltration and Command-and-Control (C2) operations, exploiting its inherent security flaws to bypass traditional defenses. This session presents a real-time, kernel-integrated security framework that actively prevents DNS-based data exfiltration using eBPF over Traffic Control (TC) scalable for large-scale distributed environments. Unlike passive detection approaches relying on anomalies, this solution dynamically intercepts DNS traffic at the kernel level, leveraging Deep Packet Inspection (DPI) and real-time lexical analysis to identify and block malicious requests before they leave the endpoint.

The framework also terminates C2 channels instantaneously, prevents DNS exfiltration over arbitrary transport ports, and dynamically blacklists domains across enterprise resolvers. With deep Linux kernel integration, it ensures minimal data loss, enhanced observability, and resilience against evolving threats. This session will explore the technical architecture, performance benchmarks, and deployment strategies to secure enterprise networks against modern DNS-based attacks.