CVE-2026-43206: Linux Kernel Privilege Escalation Flaw

CVE-2026-43206 Overview

CVE-2026-43206 is an out-of-bounds write vulnerability in the Linux kernel's AMD Kernel Fusion Driver (amdkfd) GPU compute subsystem. The flaw resides in the kfd_event_page_set() function, which writes KFD_SIGNAL_EVENT_LIMIT * 8 bytes via memset without validating the destination buffer size. Unprivileged userspace processes can pass an undersized buffer and trigger a kernel memory write past the allocated region. The condition can be leveraged for kernel memory corruption and potential local privilege escalation. The issue affects systems running the Linux kernel with the AMD KFD driver compiled in, which is standard on distributions supporting AMD GPU compute workloads through ROCm.

Critical Impact
Local unprivileged users can corrupt adjacent kernel memory through the AMD KFD interface, creating a path to privilege escalation on affected Linux systems.

Affected Products

Linux kernel with drm/amdkfd driver enabled
Distributions shipping AMD ROCm compute stack on AMD GPU hardware
Systems exposing the KFD device node to unprivileged users

Discovery Timeline

2026-05-06 - CVE-2026-43206 published to NVD
2026-05-06 - Last updated in NVD database

Technical Details for CVE-2026-43206

Vulnerability Analysis

The vulnerability is an out-of-bounds write [CWE-787] in the AMD Kernel Fusion Driver, the kernel component that exposes AMD GPU compute capabilities to userspace. The kfd_event_page_set() function unconditionally writes KFD_SIGNAL_EVENT_LIMIT * 8 bytes into a caller-provided buffer using memset. The function does not verify that the destination buffer is large enough to hold the fixed-size write. When userspace supplies a smaller buffer through the KFD ioctl path, the memset operation overruns the allocation and overwrites adjacent kernel memory.

Kernel memory adjacent to the target buffer may contain function pointers, kernel object metadata, or slab freelist pointers. Corrupting these structures provides primitives commonly used in Linux local privilege escalation exploits.

Root Cause

The root cause is missing buffer size validation. The function trusts the size implied by KFD_SIGNAL_EVENT_LIMIT rather than the actual size of the userspace-influenced buffer. The fix introduces a length check so the write is bounded by the verified buffer size before memset executes. The patch is distributed across multiple stable backport commits on git.kernel.org, including 3e04bc310d80 and 4e72f419e4ed.

Attack Vector

An unprivileged local user opens the /dev/kfd device and issues the relevant KFD ioctl with a buffer smaller than KFD_SIGNAL_EVENT_LIMIT * 8 bytes. The kernel writes past the end of the buffer, producing a controlled out-of-bounds write in kernel address space. Successful exploitation requires the AMD KFD driver to be loaded and accessible to the calling user, which is the default on workstations and servers running AMD ROCm.

// Vulnerable pattern (conceptual)
void kfd_event_page_set(void *buf /*, size_t buf_size */)
{
    // No check that buf_size >= KFD_SIGNAL_EVENT_LIMIT * 8
    memset(buf, 0, KFD_SIGNAL_EVENT_LIMIT * 8);
}

See the upstream commits referenced above for the authoritative fix.

Detection Methods for CVE-2026-43206

Indicators of Compromise

Unexpected kernel oops or BUG: messages referencing kfd_event_page_set or amdkfd in dmesg and /var/log/kern.log.
KASAN reports flagging out-of-bounds writes inside the amdkfd module on test or instrumented kernels.
Unprivileged processes opening /dev/kfd followed by privilege transitions to UID 0.

Detection Strategies

Audit execve and openat events targeting /dev/kfd correlated with subsequent setuid or capability changes on the same process tree.
Enable Linux audit rules on the KFD device node and review ioctl activity from non-GPU workloads.
Run kernels built with KASAN in pre-production to surface boundary violations originating from the AMD KFD path.

Monitoring Recommendations

Forward dmesg and auditd events to a centralized log platform and alert on kernel warnings tagged with amdkfd.
Track kernel package versions across the fleet and flag hosts running pre-patch builds with the AMD KFD driver loaded.
Monitor for new local processes accessing /dev/kfd outside of approved compute or rendering workloads.

How to Mitigate CVE-2026-43206

Immediate Actions Required

Apply the upstream stable kernel update containing the kfd_event_page_set() length check on all hosts running AMD GPU compute workloads.
Inventory systems with the amdkfd module loaded using lsmod | grep amdkfd and prioritize multi-user systems for patching.
Restrict access to /dev/kfd to trusted GPU compute users where the device is not required broadly.

Patch Information

The issue is fixed by upstream Linux kernel commits, including 3e04bc310d80, 4857c37c7ba9, 4e72f419e4ed, 75fb57efdd78, 8a70a26c9f34, b4034442cb09, bfcd6b53e1f4, and de8d7a25cd2e. Consume the fix through your distribution's kernel update channel.

Workarounds

If GPU compute is not required, blacklist the amdkfd module via /etc/modprobe.d/ and reboot.
Tighten permissions on /dev/kfd so only members of a dedicated GPU compute group can open the device.
On multi-tenant systems, consider isolating GPU compute workloads to dedicated hosts until patches are deployed.

bash

# Block the amdkfd module on systems that do not need GPU compute
echo 'blacklist amdkfd' | sudo tee /etc/modprobe.d/disable-amdkfd.conf
sudo update-initramfs -u
sudo reboot

# Verify the module is not loaded after reboot
lsmod | grep amdkfd || echo 'amdkfd not loaded'