CVE-2026-7476 in Bifrost GPU Kernel Driver
Summary
by MITRE • 09/08/2026
Use After Free vulnerability in Arm Ltd Bifrost GPU Kernel Driver, Arm Ltd Valhall GPU Kernel Driver, Arm Ltd Arm 5th Gen GPU Architecture Kernel Driver allows a local non-privileged user process to perform improper GPU memory processing operations to access already freed memory.
This issue affects Bifrost GPU Kernel Driver: from r49p3 through r49p5, r51p0, from r54p1 through r54p2; Valhall GPU Kernel Driver: from r49p3 through r49p5, from r51p0 through r54p3, r55p0; Arm 5th Gen GPU Architecture Kernel Driver: from r49p3 through r49p5, from r51p0 through r54p3, r55p0.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 09/08/2026
The identified vulnerability represents a critical security flaw within the kernel-mode drivers for Arm’s Bifrost, Valhall, and 5th Generation GPU architectures. This issue is classified as an Use After Free condition, which occurs when software continues to use a pointer after it has been freed, leading to undefined behavior that can be exploited by malicious actors. In this specific context, the vulnerability resides in the memory management subsystem of these GPU drivers, where improper handling of allocated and deallocated graphics memory buffers allows for unauthorized access to memory regions that have already been released back to the system allocator. This flaw enables a local non-privileged user process to perform improper GPU memory processing operations, effectively bypassing standard isolation mechanisms provided by the operating system kernel.
From a technical perspective, the root cause lies in the lifecycle management of graphics buffers within the driver’s internal data structures. When a buffer is no longer needed and is freed, the driver fails to properly invalidate or nullify references to that memory region before subsequent operations are executed against it. Consequently, if an attacker can trigger specific sequences of GPU commands or memory allocations that reuse the same physical page previously occupied by the freed buffer, they gain read/write access to stale data. This scenario creates a classic race condition window where the timing between deallocation and reallocation is manipulated to ensure the malicious process interacts with the reclaimed memory space before it is repurposed for legitimate system functions or overwritten entirely.
The operational impact of this vulnerability is severe due to its potential for privilege escalation and information disclosure. Since GPU drivers operate at ring 0, which corresponds to kernel mode in many architectures, exploiting a flaw within them grants the attacker code execution privileges equivalent to those of the operating system kernel itself. A local non-privileged user can leverage this weakness to escalate their permissions from standard user level to root or SYSTEM level. Furthermore, accessing freed memory allows for sensitive data leakage, as previously allocated buffers may contain cryptographic keys, session tokens, passwords, or other confidential information belonging to privileged processes. This capability fundamentally breaks the trust boundary between untrusted applications and the core operating system infrastructure.
In terms of industry standard classifications, this vulnerability aligns with CWE-416: Use After Free, which describes errors resulting from using a pointer after it has been freed. The exploitation technique maps directly to MITRE ATT&CK tactic T1055: Process Injection, specifically under sub-techniques involving memory manipulation such as DLL injection or process hollowing, although in this case the primary goal is often privilege escalation rather than just persistence. Additionally, because the attack vector requires local access and non-privileged initial foothold, it falls under ATT&CK technique T1068: Exploitation for Privilege Escalation. The vulnerability also touches upon CWE-200: Information Exposure, as the ability to read freed memory often results in the disclosure of sensitive kernel or application data.
Mitigation strategies must focus on both immediate patching and long-term architectural improvements. The primary remediation is to apply the vendor-provided patches for the affected driver versions. For Bifrost GPU Kernel Driver, updates are available from revision r49p6 onwards, excluding the specific ranges listed as vulnerable. Similarly, Valhall and Arm 5th Gen GPU Architecture drivers require updates beyond the specified vulnerable revisions, specifically targeting releases after r49p5, r51p0 through r54p3 for Valhall, and corresponding updated builds for the 5th Gen architecture. Organizations should prioritize updating these components on all devices utilizing affected SoCs to close the privilege escalation vector.
Beyond patching, defensive measures include enforcing strict memory safety practices in driver development, such as using static analysis tools that detect use-after-free patterns during code review. Runtime protection mechanisms like Kernel Address Space Layout Randomization (KASLR) and Data Execution Prevention (DEP) can mitigate exploitation success rates by making it harder for attackers to predict memory layouts or execute injected shellcode. Additionally, implementing least-privilege principles at the application layer ensures that even if a vulnerability is exploited, the potential blast radius remains contained within user-space boundaries where possible. Regular security audits of GPU driver codebases and adherence to secure coding standards are essential to prevent similar logic errors in future releases.