A 0-click exploit chain for the Pixel 9

A 0-click exploit chain for the Pixel 9

Speakers: Natalie Silvanovich (Team Lead and Security Engineer, Google Project Zero); Seth Jenkins (Security Engineer, Google Project Zero)

Conference: DistrictCon

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

Overview

This talk, presented by Google Project Zero's Natalie Silvanovich and Seth Jenkins, meticulously details a zero-click exploit chain targeting the Google Pixel 9. The presentation unveils two critical vulnerabilities – a heap overflow in the Dolby Digital Plus (DD+) audio decoder and a Use-After-Free (UAF) in a custom Google kernel driver named dev_bigwave – that together allowed for remote code execution (RCE) and subsequent kernel-level privilege escalation, culminating in full root access.

The significance of this research lies not only in the technical prowess demonstrated in chaining these vulnerabilities but also in its broader implications for Android security. The talk highlights how seemingly robust security measures, such as SELinux sandboxing and KASLR, can be circumvented, particularly when multiple weaknesses align. It serves as a stark reminder that even well-resourced organizations like Google can have critical vulnerabilities in their flagship devices, especially in less-audited attack surfaces like media codecs and custom hardware drivers.

Beyond the exploit itself, Silvanovich and Jenkins provide a critical analysis of the defensive failures that enabled this chain. They discuss the surprisingly fast discovery and exploitation times, the dangerously long patch timelines, and the concrete steps device manufacturers can take to significantly harden Android against such sophisticated attacks. This talk is essential viewing for security researchers, Android developers, and anyone involved in system-level security.

Background

▶ Watch: Initial 0-click exploit in Dolby decoder (0:00)

The landscape of Android security has long recognized media codecs as a high-risk attack surface. Historical vulnerabilities, most notably the Stagefright bugs, have demonstrated that processing complex, untrusted media formats can lead to critical remote code execution. In response, Android implemented robust sandboxing mechanisms, such as the media_codec SELinux context, designed to isolate these potentially vulnerable components and mitigate the impact of successful exploits. The assumption was that even if an RCE occurred within media_codec, further privilege escalation would be significantly challenging.

However, as Seth Jenkins eloquently explains, this defensive mindset often concentrates disproportionately on the untrusted_app SELinux context, which houses standard user applications. This focus overlooks other "dangerous" contexts, including isolated_app (used by Chrome), media_extractor, platform_app, and crucially, media_codec. Attackers seeking a zero-click exploit will naturally target remote entry points, which frequently reside in these less-scrutinized, yet network-facing, media processing components. The problem, therefore, isn't just the existence of bugs in media codecs but the underestimation of the media_codec sandbox as a launchpad for further privilege escalation.

Furthermore, the talk touches upon the perceived efficacy of Kernel Address Space Layout Randomization (KASLR). While KASLR is a fundamental memory safety mitigation in modern operating systems, its implementation in the Linux kernel has known weaknesses. Unlike userland ASLR, kernel ASLR is not always as robustly maintained, with some Linux kernel maintainers considering it "mostly dead" due to potential bypasses via speculative execution attacks and other architectural quirks. This context sets the stage for how the Project Zero team approached the challenge of escalating privileges from a sandboxed userland RCE to full kernel root.

Key Findings

▶ Watch: Discovering the dev bigwave kernel driver bug (8:00)

The Project Zero team's investigation into the Pixel 9 revealed a potent zero-click exploit chain built upon two distinct, critical vulnerabilities and several ingenious bypasses:

1. Dolby Digital Plus (DD+) Decoder Heap Overflow (CVE-YYYY-XXXX): Natalie Silvanovich discovered a heap overflow within the media_codec process's Dolby Digital Plus (DD+) audio decoder. This vulnerability allowed for arbitrary writes after the heap, specifically enabling the partial overwrite of function pointers and their associated parameters. This provided the initial remote code execution (RCE) capability within the highly constrained media_codec userland sandbox. The discovery of this bug was remarkably fast, taking only "days."

1. dev_bigwave Kernel Driver Use-After-Free (UAF) (CVE-YYYY-XXXX): Following the userland RCE, Seth Jenkins quickly identified a Use-After-Free (UAF) vulnerability in the dev_bigwave kernel driver, a custom Google-made silicon component responsible for AV1 video decoding on the Pixel 9. This UAF, residing in the IOCX_PROCESS ioctl, stemmed from a race condition between the ioctl caller's 16-second timeout and a worker thread's 1-second job processing limit. The UAF provided an arbitrary write-where primitive in the kernel, crucial for privilege escalation. This kernel bug was also found within "days" of focused auditing.

Exploitation Efficiency: The speed of both bug discoveries underscores the inherent risk in media processing components and custom kernel drivers. The full exploit chain, from zero-click RCE to kernel root, was developed into a proof-of-concept (PoC) in an astonishingly short timeframe: approximately "eight person-weeks" for the userland component and "three person-weeks" for the kernel component, totaling "six to eight person-weeks" for the complete exploit. This demonstrates that sophisticated zero-click attacks are not necessarily prohibitively expensive or time-consuming for determined attackers.

Critical Bypass Mechanisms:

• SELinux Bypass: The team successfully bypassed the media_codec SELinux policy to achieve Pwrite capability on /proc/self/mem, which was crucial for writing shellcode into executable memory. This was facilitated by the surprising absence of a seccomp policy on the Pixel's media_codec sandbox, despite its presence in AOSP/ALSP.
• KASLR Bypass: A significant finding was the practical bypass of KASLR on the Pixel 9. This was achieved by leveraging the fixed address of the Linux kernel linear map (a one-to-one mapping of physical to virtual memory) combined with the Pixel bootloader's failure to randomize the kernel's physical memory address. Unlike Qualcomm bootloaders, the Pixel consistently places the kernel at the same physical location, effectively nullifying KASLR for this attack.

Patching Delays: A critical, non-technical finding was the extended patch timelines. The Dolby issue took 193 days to be fixed on Pixel, and the dev_bigwave issue took 199 days. This meant both vulnerabilities were public for 84 days and 114 days, respectively, violating Project Zero's 90-day disclosure policy and leaving users exposed to a zero-click RCE for an extended period. This delay was attributed to "diffusion of responsibility" in prioritization, where individual components were rated as "moderate" rather than recognizing the critical impact of their chainability.

Technical Deep Dive

▶ Watch: Using LLMs to generate syscall shellcode (20:00)

The exploit chain commences with a heap overflow in the Dolby Digital Plus (DD+) audio decoder, residing within the media_codec process. Natalie Silvanovich identified that by crafting a malicious DD+ frame, she could overflow a buffer and achieve an arbitrary write after the heap. Conveniently, nearby parameters and a function pointer were also pulled from this buffer. This allowed for a partial overwrite of a function pointer, enabling calls to desired addresses with controlled parameters.

A major hurdle was bypassing SELinux to execute shellcode. Initial attempts to write and DL_open a file or map a page as read-write-execute were blocked. The solution involved writing shellcode into memory (limited to 32KB due to DD+ frame size constraints), then repeatedly calling Fopen on /proc/self/mem to guess a file descriptor. With this descriptor, the plan was to use Pwrite to inject shellcode into a low-contention function like stack_check_fail and then call it. However, Pwrite was not directly available in the binary. Silvanovich resorted to a creative "best gadget ever" approach: a gadget that took a value from register X1, added 0x157 (hex) to it, and stored it back at the address in X1. By repeatedly calling this gadget on a copied libc pointer (derived from the Global Offset Table or GOT), she could increment the pointer until its last byte matched that of Pwrite, thus enabling a call to the desired function. This achieved arbitrary code execution within the media_codec SELinux context.

The next phase involved escalating privileges from the media_codec sandbox to the kernel. Seth Jenkins targeted Linux kernel drivers accessible from this context, using a tool called driver cartographer. This led to the discovery of dev_bigwave, a Google-proprietary driver for AV1 video decoding. The critical vulnerability was a Use-After-Free (UAF) in the IOCX_PROCESS ioctl. When an ioctl is called, an instance struct, associated with the file's private data, is created and placed on a priority queue. A separate worker thread picks up jobs from this queue and processes them using big_old_run_job. The big_old_run_job function has a 1-second timeout, while the original IOCX_PROCESS ioctl has a 16-second timeout.

The UAF race condition was exploited as follows:

1. The attacker queues 15 "dummy" jobs, each taking 1 second to process.
2. Immediately after, the attacker queues the target job via IOCX_PROCESS.
3. This setup ensures that by the time the 16-second ioctl timeout expires, the worker thread is precisely processing the attacker's target job.
4. When the IOCX_PROCESS ioctl returns after 16 seconds, the ref count on the struct file is dropped, leading to the instance (and the associated job) being freed.
5. However, the worker thread is still actively referencing the freed instance in big_old_run_job.

This UAF was then transformed into an arbitrary write-where primitive. The big_old_run_job function, specifically big_old_poll_regs, performs a memcpy from a regs pointer within the freed job structure. Crucially, this regs pointer initially points to attacker-controlled data copied from userland. By reclaiming the freed instance memory using Unix domain sockets (a technique suggested by Jann Horn, which allows precise kernel heap spray), the attacker could control the regs pointer. This allowed the subsequent memcpy operation to write a large chunk of attacker-controlled data (2,144 bytes) to an arbitrary kernel memory address.

Initially, this arbitrary write-where primitive faced two limitations: its large size (clobbering 2,144 bytes, or 4,200 bytes across two writes) and the lack of KASLR information. The KASLR bypass proved surprisingly straightforward. While userland ASLR significantly hampered the initial RCE, kernel ASLR on the Pixel 9 was weak. The Linux kernel linear map, a direct one-to-one mapping of physical memory to kernel virtual memory, resides at a fixed virtual address. Furthermore, the Pixel bootloader, unlike Qualcomm's, does not randomize the physical address where the kernel (VM Linux) is loaded. This meant the attacker could directly calculate the kernel base address, effectively rendering KASLR ineffective.

With arbitrary kernel write and KASLR bypassed, the final step was to achieve root. The 32KB shellcode space in the media_codec process was a constraint, requiring the conversion of a 500KB ELF binary into an 8KB blob. This involved compiling with -fPIC, removing libc dependencies, implementing syscalls directly (with assistance from Gemini AI for initial scaffolding), removing alignment requirements, and prepending a relative jump to the entry point. The kernel shellcode then performed two key actions:

1. Set the SELinux_enforcing variable in the SELinux_state struct to 0, effectively disabling SELinux.
2. Walked the kernel's task list, located its own process, and then borrowed the init_cred struct (which holds root privileges) from .data to set its UID to root. A reference count was incremented to prevent premature freeing.

The entire exploit was demonstrated by embedding a script within the shellcode that used the device camera to take a picture and exfiltrate it to a remote IP address, confirming full device compromise.

Demo / Proof of Concept

▶ Watch: Achieving root by disabling SELinux and borrowing init creds (22:00)

The culmination of this sophisticated exploit chain was a compelling demonstration of full device compromise. Once kernel root was achieved, the embedded shellcode executed a pre-defined script. This script leveraged the newly acquired root privileges to interact directly with the device's hardware, specifically the camera. The demonstration involved the device taking a picture using its camera and then transmitting that image to a "random IP address," simulating data exfiltration by an attacker. The presentation showed the actual picture taken by the exploited Pixel 9, featuring both speakers looking somewhat bewildered at their screens, humorously implying their surprise that the exploit had already succeeded. This practical proof-of-concept clearly illustrated the devastating impact of a zero-click kernel exploit: remote, unauthenticated access to sensitive device functions and data.

Defensive Implications

▶ Watch: Promising memory mitigations like Fbound safety and MTE (27:00)

The detailed analysis of this exploit chain provides several critical lessons for device manufacturers and security defenders:

1. Aggressive Attack Surface Reduction: The most straightforward mitigation for zero-click vulnerabilities is to eliminate unnecessary attack surfaces. The speakers highlight that the Dolby Digital Plus (DD+) encoder is not required on any mobile device for user-facing features, yet its presence contributed to the attack surface. Removing such unused or non-essential components from zero-click contexts can significantly reduce risk.

1. Robust SELinux and Seccomp Policies: The absence of a seccomp policy for the media_codec sandbox on the Pixel 9, despite its presence in AOSP/ALSP, was a major enabler for the userland RCE. Device manufacturers must ensure that comprehensive and restrictive seccomp policies are consistently applied across all sensitive SELinux contexts, especially those processing untrusted input. Furthermore, all "dangerous" SELinux contexts beyond untrusted_app (e.g., isolated_app, media_extractor, platform_app, media_codec, baseband, Wi-Fi, Bluetooth) require rigorous auditing and strong isolation.

1. Prioritization of Chained Vulnerabilities: The "diffusion of responsibility" in vulnerability prioritization, where individual bugs were rated "moderate" instead of "critical" when chained, led to dangerously long patch timelines. Security teams must adopt a holistic view, assessing the potential impact of vulnerabilities in combination, particularly when they contribute to zero-click chains. Android has reportedly changed its prioritization guidelines in response to this issue.

1. Enhanced Memory Safety Mitigations:

• Managed Languages: Shifting critical components, especially media codecs and drivers, to memory-safe languages like Rust or Java could prevent entire classes of vulnerabilities (e.g., heap overflows, UAFs).
• Compiler Flags: The talk specifically mentions the Clang -Fbounds-safety flag, which injects runtime bounds checks into struct accesses. This flag successfully prevented the Dolby decoder bug on the iPhone, demonstrating its effectiveness. Widespread adoption of such compiler-level mitigations is crucial.
• Hardware Mitigations: Technologies like Memory Tagging Extension (MTE) and Memory Isolation Engine (MIE), while still emerging, offer significant promise in preventing memory corruption bugs (like the dev_bigwave UAF) at a hardware level. Investment in and deployment of these technologies are key for future device security.

1. Strengthening KASLR: The KASLR bypass on the Pixel 9 was a critical enabler for kernel root. Pixel bootloaders should implement randomization of the kernel's physical memory address, similar to Qualcomm's approach, to prevent attackers from relying on fixed linear map addresses. While KASLR has known weaknesses, consistent implementation across the board can still raise the bar for exploitation.

Key Takeaways

• Zero-click exploits remain highly feasible and efficient to develop: Both critical bugs were found in days, and the full exploit chain for the Pixel 9 took only 6-8 person-weeks, highlighting the continued threat from sophisticated attackers.
• Overlooked SELinux contexts are prime targets for privilege escalation: The media_codec sandbox, while designed for isolation, was successfully leveraged due to insufficient seccomp policies and a general under-auditing compared to untrusted_app.
• KASLR can be surprisingly weak on specific devices: The Pixel 9's bootloader failing to randomize the kernel's physical memory address, combined with the fixed Linux kernel linear map, effectively nullified KASLR for this attack.
• Effective memory safety mitigations exist but require consistent implementation: Compiler flags like -Fbounds-safety and hardware features like MTE/MIE have proven capabilities to prevent these types of bugs, but their widespread adoption and rigorous testing are essential.
• Vulnerability prioritization must account for exploit chainability: Dangerous delays in patching critical zero-click vulnerabilities (193 and 199 days) were caused by a "diffusion of responsibility" in rating individual components as "moderate."
• Aggressive attack surface reduction is crucial: Removing non-essential components, like the DD+ encoder from zero-click contexts, can prevent entire classes of attacks without impacting user features.

About the Speaker(s)

Natalie Silvanovich is a Team Lead and Security Engineer at Google Project Zero, a renowned team of security researchers dedicated to finding zero-day vulnerabilities in widely used software and hardware. Her work often focuses on deeply technical analysis of complex systems, as demonstrated by her expertise in identifying and exploiting the heap overflow in the Dolby Digital Plus decoder and her insights into effective mitigation strategies.

Seth Jenkins is also a Security Engineer at Google Project Zero, specializing in kernel-level vulnerabilities and privilege escalation. As he humorously states, his "whole job" is "getting root." His deep understanding of Linux kernel drivers, SELinux contexts, and KASLR bypass techniques was evident in his rapid discovery and exploitation of the Use-After-Free in the dev_bigwave driver, providing the critical kernel-level component of the exploit chain. Together, their combined expertise showcases the formidable capabilities of Project Zero in uncovering and analyzing cutting-edge security flaws.