Skip to main content

Linux Kernel CVE-2026-97496

| EUVDEUVD-2026-86094 HIGH
2026-09-24 Linux GHSA-qvg3-fh9p-wjpx
7.1
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain local access to AMD KFD device
  2. Delivery
    Call AMDKFD_IOC_RESTORE_PROCESS with crafted MQD
  3. Exploit
    Underflow cp_hqd_cntl_stack offset/size
  4. Execution
    Trigger unbounded copy_to_user in get_wave_state
  5. Impact
    Leak adjacent kernel/GTT memory to userspace

Vulnerability Assessment

Exploitation Conditions

Requires local access to the AMD KFD device node (/dev/kfd) on a system with an AMD GPU using the GFXv9-class compute stack, plus the ability to invoke the AMDKFD_IOC_RESTORE_PROCESS ioctl (CRIU restore, H3) to supply a malicious MQD with attacker-controlled cp_hqd_cntl_stack_size/cp_hqd_cntl_stack_offset. Exploitation is limited to unprivileged-but-local attackers (PR:L, AV:L) - there is no remote or network vector - and only affects unpatched kernels prior to 6.12.111 / 6.18.53 / 7.2 running AMD KFD; systems without an AMD GPU/KFD driver are not exposed.

Impact

This is a local, low-privilege kernel information-disclosure with a real technical basis, not merely a high-CVSS paper cut. The provided CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H, base 7.1) is internally consistent with the description: an attacker with access to the AMD KFD device node feeds attacker-controlled cp_hqd_cntl_stack_size/offset values through the CRIU-restore path, causing an integer underflow that produces a ~4 GiB copy_to_user() length and leaks adjacent GTT/kernel memory (other queues' MQDs, ring buffers, KASLR pointers). C:H is genuinely justified here - unlike many sibling amdkfd/ACPICA CVEs in this batch that are crash-dominant and mislabeled, this one is a legitimate confidentiality leak, and A:H is defensible because an unbounded read can also fault/crash. No EPSS score, no CISA KEV listing, and no public POC are present in the input, so exploitation probability signals are absent rather than negative. The practical risk is bounded by the local-access and AMD-GPU-plus-KFD prerequisites: this is a useful KASLR-defeat / info-leak primitive in a local privilege-escalation chain, not a remotely mass-exploitable flaw. CWE is listed as N/A but the true weakness is CWE-125/CWE-190 (OOB read via integer underflow).

Exploit ScenarioDerived

A local unprivileged user with access to the AMD KFD render/compute device invokes AMDKFD_IOC_RESTORE_PROCESS (the CRIU restore path) supplying a crafted MQD whose cp_hqd_cntl_stack_size/offset fields are attacker-chosen. When get_wave_state() later trusts these microcode-written values, an integer underflow yields a multi-gigabyte copy_to_user() that returns adjacent kernel/GTT memory - including other queues' MQDs, ring buffers, and KASLR pointers - defeating address-space randomization for a follow-on exploit. No public exploit was identified at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 25, 2026

Local low-privileged users on systems with AMD GFXv9-class GPUs can leak adjacent kernel memory through the amdkfd get_wave_state() path in the Linux kernel, because attacker-supplied queue descriptor fields are used unchecked as the length and offset of a copy_to_user(). The bug is reachable only via the AMD KFD device node (/dev/kfd) together with the AMDKFD_IOC_RESTORE_PROCESS (CRIU restore, H3) ioctl, giving an attacker roughly 4 GiB of over-read when the offset exceeds the size (integer underflow) or a 1 MiB read against a 4 KiB allocation that exposes neighbouring MQDs, ring buffers and KASLR-relevant kernel pointers. Vendor-released fixes are available in Linux 6.12.111 and 6.18.53 (and in the 7.2 line), but at the time of analysis there is confirmed no CISA KEV listing and no public exploit code identified, so this should be treated as a real but local-only information-disclosure risk rather than an actively exploited flaw; systems without an AMD GPU or without the KFD driver loaded are not exposed.

RemediationAI

Vendor-released patch: Linux 6.12.111, Linux 6.18.53, and the 6.2/7.2 development line fix (upstream commits d9183d974ddd5f09d029beaf359275ac20d4d5fe, ec646686613d8ab05b282d1463a7baa49fd6b83b, 7ef144458f48d5589e36f1b3d83e83db2e5c5ba5), so the primary action is to upgrade 6.12.x to 6.12.111 or later and 6.18.x to 6.18.53 or later (or apply the referenced stable commits to a custom/vendor kernel) and reboot, since the fix cannot be applied to a running kernel without reloading the module. Where immediate upgrading is not possible, the practical compensating control is to reduce who can open /dev/kfd: remove unprivileged users from the video/render group, tighten the device node permissions, or use a device cgroup/udev rule to deny unprivileged access, with the trade-off that this breaks unprivileged ROCm/HIP compute, HPC batch workloads and containerised GPU access; a more surgical option is to block the CRIU GPU checkpoint/restore path for untrusted tenants (do not allow AMDKFD_IOC_RESTORE_PROCESS to be driven by unprivileged or untrusted checkpoint images, and disable CRIU GPU restore in multi-tenant environments) at the cost of losing GPU checkpoint/restore functionality. Fully unloading the amdgpu/amdkfd driver or blacklisting it removes the attack surface entirely but disables the GPU, and note that blocking the ioctl path is not a complete substitute for patching because the same code can be reached through other queue-management flows. Consult the upstream stable commit URLs and the vendor advisory at https://git.kernel.org/stable/c/ec646686613d8ab05b282d1463a7baa49fd6b83b plus https://nvd.nist.gov/vuln/detail/CVE-2026-97496 for authoritative backport guidance for distribution kernels.

Affected VersionsENISA

Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <d9183d974ddd5f09d029beaf359275ac20d4d5fe
Linux patch: 6.12.111
Linux 0 <6.18.53
Linux patch: 6.18.53
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <ec646686613d8ab05b282d1463a7baa49fd6b83b
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <7ef144458f48d5589e36f1b3d83e83db2e5c5ba5
Linux 0 <6.12.111
Linux patch: 7.2

Affected Packages

euvd linux fix: 6.12.111, 6.18.53

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected code lives in the AMD GPU kernel compute stack (drm/amdkfd), which exposes GPU queue management and checkpoint/restore services to user space through /dev/kfd and the KFD ioctl interface. The get_wave_state() implementation for the v9 (GFXv9) generation reads cp_hqd_cntl_stack_size and cp_hqd_cntl_stack_offset straight out of the MQD (Memory Queue Descriptor) - a structure that on the CRIU-restore path is populated from user-supplied data via AMDKFD_IOC_RESTORE_PROCESS. Because those fields are normally written by GPU microcode and were implicitly trusted, the driver never validated them against the size of the control-stack BO it actually allocated (q->ctl_stack_size) before using them to drive copy_to_user(). The result is a classic out-of-bounds read / improper input validation defect: when offset > size the size arithmetic underflows to approximately 4 GiB, and when a small allocation (for example 4 KiB) is paired with a claimed size of 1 MiB the read walks 1 MiB into adjacent kernel memory, potentially disclosing other queues' MQDs, AMDGPU ring buffers and pointers that aid KASLR defeat. The upstream fix clamps cp_hqd_cntl_stack_size to the real allocated buffer size and cp_hqd_cntl_stack_offset to that clamped size before any arithmetic or copy_to_user() occurs, so MQD field values can no longer cause reads outside the allocated kernel BO. The CVE record carries no CWE assignment in the supplied data, but the root cause class is squarely an out-of-bounds read caused by unvalidated length/offset parameters. Per the assessed CVSS vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H, exploitation requires local access at low privilege (PR:L, AV:L) with no user interaction, yields high confidentiality impact (kernel memory disclosure) and high availability impact, with no integrity impact and no scope change - there is no remote or network vector.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Linux) PRIMARY 7.1 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
vuln.today AI 7.1 HIGH

Local KFD device access with low privilege (AV:L/PR:L); attacker fully controls MQD fields so AC:L; kernel-memory leak gives C:H, unbounded read can crash so A:H, no integrity impact.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Red Hat 7.0 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
High

Lifecycle Timeline

4
CVSS changed
Sep 25, 2026 - 05:23 NVD
7.1 (HIGH)
Patch available
Sep 24, 2026 - 17:03 EUVD
CVE Published
Sep 24, 2026 - 16:04 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 24, 2026 - 16:04 cve.org
HIGH 7.1

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

drm/amdkfd: Fix OOB memory exposure in get_wave_state()

The get_wave_state() function for v9 trusts cp_hqd_cntl_stack_size and cp_hqd_cntl_stack_offset values read directly from the MQD, which are written by GPU microcode and fully attacker-controlled on the CRIU-restore path (via AMDKFD_IOC_RESTORE_PROCESS with H3).

this leads to an unbounded copy_to_user() that can leak adjacent GTT/kernel memory. If offset > size, integer underflow produces a ~4 GiB read length, if size is set to 1 MiB against a 4 KiB allocation, we leak 1 MiB of adjacent kernel memory (other queues' MQDs, ring buffers, KASLR pointers).

Fix by clamping both cp_hqd_cntl_stack_size to the actual allocated buffer size (q->ctl_stack_size) and cp_hqd_cntl_stack_offset to the clamped size before performing arithmetic and copy_to_user().

This ensures we never read beyond the allocated kernel BO regardless of attacker-supplied MQD field values.

Executive ViewAI

Why It Matters

A kernel memory-disclosure weakness in the AMD GPU driver (amdkfd) affects Linux systems equipped with AMD GFXv9-class graphics hardware, allowing a local low-privileged user to read adjacent kernel memory and potentially expose kernel pointers used for address-randomization bypasses. Because the flaw requires local access to the AMD KFD device and there is no evidence of active exploitation, the realistic exposure is concentrated in shared workstations, virtual desktop, and multi-tenant hosts where untrusted users already hold local accounts. Leadership should treat this as a contained but urgent patching item for GPU-bearing Linux fleets rather than an internet-facing crisis.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Medium
Linux kernel is ubiquitous but amdkfd compute path needs AMD GPU with KFD
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 16.0 Not-Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy