CVE-2026-53144: Linux Kernel AMD KFD NULL Pointer Dereference (Kernel Panic)

Technical summary

CVE-2026-53144 is a NULL pointer dereference in the drm/amdkfd module's get_queue_ids() function. The vulnerability exists in the error-handling logic: when usr_queue_id_array is NULL but num_queues is non-zero, the function returns NULL. Callers (suspend_queues and resume_queues) check only IS_ERR() on the return value, which evaluates false for NULL pointers. This allows NULL to propagate to q_array_invalidate(), which dereferences it while iterating num_queues times without a NULL guard, causing a kernel panic. The fix distinguishes between a legitimate no-op (NULL pointer with zero queues) and an error condition (NULL pointer with non-zero queues), returning ERR_PTR(-EINVAL) only in the latter case so callers' existing IS_ERR() checks properly catch it.

Business impact

This vulnerability enables a denial-of-service attack against systems running affected Linux kernel versions with AMD GPU support. An unprivileged local attacker can crash the kernel without requiring special privileges, administrative access, or user interaction. For organizations relying on GPU workloads (HPC, machine learning, rendering), unexpected kernel panics disrupt operations, interrupt long-running jobs, and degrade system availability. The impact is amplified in multi-tenant environments or shared compute clusters where untrusted users have shell access.

Affected systems

The Linux kernel is affected across multiple versions (specific stable branch versions traceable to the cherry-picked commit f165a82cdf503884bb1797771c61b2fcc72113d4). Vulnerability exists only on systems with AMD KFD functionality compiled in and GPU hardware capable of supporting kernel fusion operations. Systems without AMD GPUs or with KFD disabled are unaffected. Verify affected kernel versions against the vendor advisory and your distribution's kernel release notes.

Exploitability

Exploitability is straightforward: an unprivileged local user with access to a shell can trigger the vulnerability via kfd_ioctl_set_debug_trap() by calling the ioctl with num_queues > 0 and queue_array_ptr set to zero. No special privileges, elevated capabilities, or kernel module loading are required. The flaw does not require user interaction or complex setup. However, exploitation is limited to local attackers; the ioctl interface is not network-accessible. The vulnerability is not listed in CISA's Known Exploited Vulnerabilities catalog, but the simplicity of triggering it makes exploitation likely once disclosure occurs.

Remediation

Apply a kernel update containing the fix from commit f165a82cdf503884bb1797771c61b2fcc72113d4 or later. Distributions should backport this commit to all affected stable kernel branches. Verify the patch version in your distribution's advisory. As a temporary mitigation (not a substitute for patching), restrict local shell access to trusted users and disable GPU access via AppArmor, SELinux, or similar mandatory access controls if GPU functionality is not required.

Patch guidance

Check your Linux distribution's security advisory for updated kernel packages. Kernel patches are typically distributed as security updates through your package manager (apt, yum, dnf, zypper, etc.). Test patches in a non-production environment first, as kernel updates require reboot. Verify that the update includes the fix for CVE-2026-53144 before deploying. If running a custom kernel, apply commit f165a82cdf503884bb1797771c61b2fcc72113d4 or cherry-pick the NULL-pointer check logic into your local branches.

Detection guidance

Monitor kernel logs for NULL pointer dereference panics originating from the drm/amdkfd module, particularly in calls to suspend_queues() or q_array_invalidate(). Kernel oops/panic messages will reference drm_amdkfd or amdkfd in the stack trace. On systems with sysstat or systemd-journal, search for kernel panic events coinciding with GPU-related ioctl calls. Intrusion detection systems can flag suspicious ioctl sequences to kfd_ioctl_set_debug_trap() with crafted parameters; however, the attack is trivial and leaves no signature distinct from accidental misuse. The most reliable detection is patching, followed by auditing application code that interacts with KFD ioctls.

Why prioritize this

Although rated MEDIUM severity (CVSS 5.5), this vulnerability merits prompt patching because: (1) local exploitability is trivial, requiring only standard user-level ioctl calls; (2) no privilege escalation is needed, lowering the barrier to exploitation; (3) the impact (kernel panic / denial of service) directly affects system availability and business-critical GPU workloads; (4) in shared compute environments or cloud/HPC clusters, untrusted users commonly have shell access, making exploitation likely. Organizations with AMD GPU infrastructure should prioritize this ahead of lower-impact remote vulnerabilities.

Risk score, explained

The CVSS 3.1 score of 5.5 (MEDIUM) reflects a local attack vector (AV:L) requiring low privileges (PR:L), low complexity (AC:L), no user interaction (UI:N), and impact only to availability (A:H, no C or I impact). The score appropriately captures the narrow scope (single-system impact) and local-only attack surface. However, the actual organizational risk may be higher in specific contexts: GPU-dependent workloads amplify availability impact; multi-tenant systems increase likelihood of untrusted local users; and the trivial exploitability means the practical gap between discovery and weaponization is minimal. Consider internal risk ratings that account for your infrastructure's specific reliance on AMD GPU functionality.

Frequently asked questions