New Linux Kernel Vulnerability Directly Exploited from Chrome Renderer Sandbox

August 9, 2025 — A critical vulnerability in the Linux kernel, identified as CVE-2025-38236, has exposed a flaw that could allow attackers to escalate privileges from within the Chrome renderer sandbox on Linux systems. 

Google Project Zero researcher Jann Horn Discovered the bug affects Linux kernels version 6.9 and above, stemming from the obscure MSG_OOB (out-of-band) feature in UNIX domain sockets. 

This finding underscores the risks posed by esoteric kernel features and highlights gaps in browser sandbox security.

Uncovering the MSG_OOB Vulnerability

The vulnerability, identified during a code review in early June, originates from a flaw in the MSG_OOB implementation, introduced in Linux 5.15 in 2021. 

Though rarely used outside specific Oracle products, MSG_OOB was enabled by default in kernels supporting UNIX sockets and was accessible within Chrome’s renderer sandbox due to unfiltered syscall flags. 

The bug enables a use-after-free (UAF) condition, which Horn demonstrated can be triggered with a simple sequence of socket operations, potentially allowing attackers to manipulate kernel memory and gain elevated privileges. 

The Linux kernel has since been patched, and Chrome has blocked MSG_OOB messages in its renderer sandbox to mitigate the issue.

Horn’s exploit, detailed on Google Project Zero’s bug tracker, shows how an attacker could escalate from native code execution in the Chrome renderer sandbox to kernel-level control on a Debian Trixie system running x86-64 architecture. 

By exploiting a UAF, the attack leverages a read primitive to copy arbitrary kernel memory to user space, navigating usercopy hardening restrictions. 

Techniques like reallocating freed memory as pipe pages or kernel stacks, combined with page table manipulation and mprotect() for delay injection, enable precise memory corruption. 

Notably, the exploit uses Debian’s CONFIG_RANDOMIZE_KSTACK_OFFSET feature, turning a security mitigation into an advantage for aligning memory targets.

Challenges in Fuzzing and Sandbox Design

The vulnerability was initially spotted during Horn’s review of a new kernel feature, with a related issue later caught by Google’s syzkaller fuzzing tool in August 2024. 

The first bug required six syscalls to trigger, while a second, more complex issue found by Horn needed eight, revealing the difficulty fuzzers face in exploring complex kernel data structures like socket buffers (SKBs).

Horn suggests that fuzzers could improve by targeting specific kernel subsystems to better uncover such vulnerabilities.

The exploit also exposes the extensive kernel interfaces available in Chrome’s Linux renderer sandbox, including anonymous VMAs, UNIX sockets, pipes, and syscalls like sendmsg() and mprotect(). 

Many of these interfaces are unnecessary for renderer functionality, unnecessarily expanding the attack surface. 

Past Chrome vulnerabilities involving futex(), memfd_create(), and pipe2() further highlight how obscure kernel features can introduce risks when exposed in sandboxes.

 Horn’s findings also question the effectiveness of probabilistic mitigations, like per-syscall stack randomization, against attackers with arbitrary read primitives, as these can be bypassed by repeatedly checking randomization outcomes.

The discovery calls for stricter sandbox restrictions and a reevaluation of kernel features exposed to unprivileged processes. 

Horn plans a deeper analysis of Chrome’s Linux renderer sandbox in a future report. Linux users are urged to apply the latest kernel patches, and developers should scrutinize esoteric kernel features in core system interfaces.

Find this News Interesting! Follow us on Google News, LinkedIn, and X to Get Instant Updates!