Cross-Cache Attacks for the Linux Kernel via PCP Massaging

Cross-Cache Attacks for the Linux Kernel via PCP Massaging

Speakers: Claudio Migliorelli

Conference: NDSS Symposium

YouTube: https://www.youtube.com/watch?v=xvMdPlWdNXg

Overview

Kernel heap exploitation has become increasingly difficult as memory pools isolate vulnerable and target objects from each other. This talk introduces PCP-Lost, a novel cross-cache memory massaging technique that exploits overlooked interactions between the Linux kernel's SLAB allocator and the page frame (buddy) allocator to force physical page adjacency between different memory pools. The technique achieves approximately 90% reliability in establishing cross-cache layouts favorable for spatial bugs like out-of-bounds writes, even under noise and existing kernel mitigations.

Presented by Claudio Migliorelli from IBM Research and EPFL, the work demonstrates that the per-CPU page lists (PCP lists) -- a fast-path optimization in the page frame allocator -- expose a timing side channel from user space that can be used to detect allocation states and force the allocator into producing physically contiguous pages. The technique bypasses mainline mitigations including SLAB freelist randomization and SLAB freelist hardened, and was evaluated against six real-world CVEs.

Background

▶ Watch: Classical kernel exploitation and the cross-cache problem (0:00)

In Linux kernel exploitation, attackers typically leverage memory corruption bugs on the kernel heap. In the classical scenario, both the vulnerable object and the target object reside in the same memory pool (SLAB cache), and the attacker arranges them adjacently to exploit an overflow. However, modern kernels increasingly separate objects into different memory pools, meaning the vulnerable object and the desired target are allocated from different kmem_caches.

Cross-cache attacks are an emerging strategy to bridge this gap by forcing two different memory pools to be adjacent in physical memory. Prior work in this area includes P-Spray (2023), which assessed the feasibility of timing side channels on the dynamic memory allocator, and SLUBStick and CrossEx, which explored page recycling attacks for temporal bugs (use-after-free, double-free). However, previous work either focused on timing side channels alone or on page recycling for temporal bugs -- none addressed achieving physical page adjacency for spatial bugs like out-of-bounds writes.

The Linux kernel's page allocation uses a hierarchical system: the SLAB allocator manages dynamic objects within memory pages, and the page frame allocator (buddy allocator) manages the pages themselves. Between them sits an optimization called PCP lists (per-CPU page lists) -- local per-CPU caches of free pages that provide a fast allocation path without requiring global locks.

Key Findings

▶ Watch: SLAB allocator, PCP lists, and the buddy page split insight (4:00)

The core finding is that PCP list internals expose a user-space-detectable timing side channel with three distinct allocation paths: allocations from existing objects within a slab, allocations from the PCP list (fast path), and allocations requiring interaction with the free area (slow path). These three paths have distinctly different latencies measurable from user space via system call timing.

The technique achieves approximately 90% reliability for establishing cross-cache layouts in both idle and noisy conditions (tested with stress-ng). It works across a full cross-product of vulnerable and target cache combinations, covering both same-order cases (where both caches request the same page order) and cross-order cases (different page orders).

The technique bypasses three existing kernel defenses: SLAB freelist randomization, SLAB freelist hardened, and the publicly available patch of SLAB virtual (designed for page recycling attacks). However, a newer version of SLAB virtual with guard pages does mitigate PCP-Lost for linear writes, as overflows would hit the guard page and cause a crash.

The researchers successfully exploited six real-world CVEs, including both spatial bugs (out-of-bounds writes) and temporal bugs (use-after-free, double-free) via pivoting to spatial primitives.

Technical Deep Dive

▶ Watch: Three-step massaging technique: probe-drain, allocate, trigger overflow (8:00)

PCP-Lost operates in three main steps:

Step 1 -- Probe and Drain: The attacker repeatedly drains the PCP list for the target page order by allocating many pages and using the timing side channel to detect interactions with the free area. This process forces the page frame allocator to split higher-order pages, creating physically contiguous pages in the PCP list. The key insight is that buddy pages obtained via splits are guaranteed to be contiguous in memory -- a left and right buddy produced by splitting a higher-order page are always adjacent.

Step 2 -- Allocate Vulnerable and Target: Using the same timing side channel to detect page allocations, the attacker allocates the vulnerable cache first (receiving page 1 from the PCP list), then sprays the target objects (receiving page 2 from the PCP list). Since pages 1 and 2 were the output of a split, they are physically contiguous.

Step 3 -- Trigger the Overflow: The attacker triggers the out-of-bounds write from the vulnerable object, which now overflows into the physically adjacent target cache slab.

The timing side channel is measurable from user space through system call timing. Two distinct histograms demonstrate that PCP list allocations (fast path) and free area allocations (slow path) produce clearly separable latency distributions for different cache sizes (e.g., kmalloc-4k and kmalloc-2k).

For temporal bugs, the technique supports pivoting: a use-after-free or double-free can be converted into a spatial primitive, and then the contiguous layout is exploited to leak information or corrupt objects in a different cache. The evaluation uses target objects like pipe_buffer and struct cred, which are standard exploitation targets in the Linux kernel.

Demo / Proof of Concept

▶ Watch: Evaluation: 90% reliability across cache combinations and six CVEs (10:00)

The evaluation covers a full cross-product of vulnerable and target cache combinations, measuring reliability under both idle conditions and stress (using stress-ng). The researchers achieved approximately 90% reliability across configurations. Six real-world CVEs were successfully exploited, bypassing mainline mitigations including SLAB freelist randomization and SLAB freelist hardened.

The researchers disclosed PCP-Lost to Linux kernel maintainers, who acknowledged the technique but stated they are "fine with us publishing this work because you still need a memory corruption primitive to make this massaging strategy effective." The researchers are also in discussion with Google engineers developing SLAB virtual, advocating for its merger into mainline as a comprehensive mitigation against both page recycling and page adjacency cross-cache attacks.

Defensive Implications

▶ Watch: Q&A: Rowhammer connection, SLAB virtual status, exploitation constraints (14:00)

Current mainline kernel defenses are insufficient against PCP-Lost. SLAB freelist randomization and SLAB freelist hardened do not prevent cross-cache exploitation because PCP-Lost operates at the page allocator level, below the SLAB allocator's protections. The publicly available SLAB virtual patch, designed for page recycling attacks, is also bypassed because it does not address page adjacency.

The newer version of SLAB virtual with guard pages does mitigate PCP-Lost for linear writes, as the guard page between slab pages would be hit by an overflow, causing a crash. However, this version has not been merged into the mainline kernel because it does not support DMA, and Linus Torvalds has declined to merge it.

The researchers argue that kernel defenses must be applied at the page allocator level, not just the SLAB allocator level. Either the page allocator must be modified to eliminate the timing side channel and prevent predictable physical adjacency, or the SLAB allocator must be fully decoupled from the page allocator (as SLAB virtual attempts to do). Until such mitigations are mainlined, any kernel memory corruption vulnerability has a 90% reliable path to cross-cache exploitation.

Key Takeaways

• PCP lists in the Linux page frame allocator expose a timing side channel detectable from user space that reveals the allocation state of the system
• The PCP-Lost technique achieves approximately 90% reliability in establishing physically contiguous cross-cache layouts, even under noise and existing mitigations
• Buddy pages from page splits are guaranteed contiguous in memory -- a fundamental property exploited by this technique
• Mainline defenses (SLAB freelist randomization, SLAB freelist hardened) do not prevent cross-cache attacks because they operate above the page allocator level
• SLAB virtual with guard pages is an effective mitigation but has not been merged into mainline Linux due to DMA compatibility issues
• The technique was demonstrated against six real-world CVEs covering both spatial and temporal vulnerability classes

About the Speaker(s)

Claudio Migliorelli is a researcher at IBM Research and EPFL (Swiss Federal Institute of Technology in Lausanne). He demonstrated deep expertise in Linux kernel memory management internals, engaging substantively with audience questions about SLAB virtual, Rubicon (concurrent work on PCP exploitation for Rowhammer), and practical exploitation constraints around freelist randomization. He is actively collaborating with Google engineers on pushing SLAB virtual as a mainline mitigation for cross-cache attacks.