Skip to main content

Linux Kernel EUVDEUVD-2026-49017

| CVE-2026-64305 HIGH
Use After Free (CWE-416)
2026-07-25 Linux GHSA-rf9w-458j-7pqc
7.8
CVSS 3.1 · NVD
View

Attack ChainAIDerived

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

  1. Access
    Obtain local shell on QAT-equipped server
  2. Delivery
    Spawn concurrent threads targeting service registration and device lifecycle
  3. Exploit
    Race list_for_each_entry() against adf_service_unregister()
  4. Execution
    Trigger use-after-free on freed service_table node
  5. Persist
    Corrupt kernel heap via dangling pointer dereference
  6. Impact
    Escalate privileges to root

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires: (1) a local account with the ability to execute unprivileged code on the target system (PR:L - no root or special capabilities needed beyond basic shell access); (2) Intel QuickAssist Technology (QAT) hardware physically present in the host (PCIe QAT accelerator card or server-class Intel Xeon/Atom with integrated QAT) and the kernel's adf driver module loaded; (3) the ability to trigger concurrent service register/unregister and device lifecycle events - achievable via normal user space calls or by inducing a QAT device error. There is no network attack vector; the entire exploit chain runs locally. The race window is narrow and may require repeated attempts, raising practical complexity above the AC:L rating suggests. Systems without QAT hardware, or with the qat kernel module explicitly blocklisted, are entirely unexploitable.

Impact

The CVSS 3.1 vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H scores 7.8 and reflects a realistic worst-case: a local process with low privileges races the kernel's QAT device lifecycle, achieves UAF, and escalates to root or crashes the host. The AC:L rating may be slightly generous for a race condition - triggering reliable list corruption typically requires repeated concurrent attempts - but kernel UAF races are well-understood attack primitives and tooling exists to win them. EPSS at 0.21%/11th percentile and the absence of KEV listing indicate no observed active exploitation. No public PoC has been identified. The hardware prerequisite (Intel QAT device must be present and the adf driver loaded) limits the real-world attack surface to server/cloud environments - not commodity endpoints. For those environments, however, this is a genuine local privilege escalation path with high impact across all three security dimensions. Patched stable kernel versions are available, making the remediation straightforward.

Exploit ScenarioDerived

A local attacker with a shell account on a server equipped with an Intel QAT accelerator spawns multiple threads - one repeatedly calling a service registration/unregistration path while another triggers a QAT device lifecycle transition (e.g., restarting the device via sysfs or causing an error event). The racing unregister frees a service_table node that the lifecycle function's list_for_each_entry() is currently dereferencing, yielding a use-after-free. The attacker leverages the corrupted kernel pointer to achieve arbitrary kernel read/write and ultimately privilege escalation to root. No public PoC has been identified, but kernel UAF-to-privesc is a well-practiced exploit class.

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

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

Alert me

AnalysisAIv1 – Sep 03, 2026

Use-after-free and list corruption in the Linux kernel's Intel QuickAssist Technology (QAT) crypto driver allows a local low-privileged attacker to trigger kernel memory corruption by racing concurrent service registration and device lifecycle operations. The crypto/qat subsystem's service_table linked list is guarded by service_lock only during insertions and deletions, but seven device-state functions iterate the list unprotected, enabling a concurrent adf_service_register() or adf_service_unregister() call to mutate the list mid-traversal. Exploiting this race can result in kernel crash, arbitrary kernel memory read, or local privilege escalation to root. No public exploit code has been identified and EPSS stands at 0.21% (11th percentile), but the impact class is high for systems running QAT-capable Intel hardware.

RemediationAI

Upgrade to a fixed kernel release: Linux 6.12.96, 6.18.39, or 7.1.4 in the respective stable trees, or any build based on Linux 7.2-rc1 or later mainline. Upstream commits for each stable branch are publicly available at the referenced git.kernel.org stable tree links. Where an immediate kernel upgrade is not possible, the most targeted compensating control is to prevent loading of the QAT driver module: add 'install qat_dh895xcc /bin/false' (and equivalent lines for other QAT PF/VF modules such as qat_c62x, qat_4xxx) to /etc/modprobe.d/qat-disable.conf. This eliminates the attack surface entirely at the cost of losing hardware crypto acceleration on affected devices, which may impact throughput-sensitive workloads relying on offloaded TLS or IPsec. Alternatively, restrict local shell or sudo access on hosts with QAT hardware to trusted operator accounts until the kernel upgrade is applied.

Affected VersionsENISA

Linux d8cba25d2c68992a6e7c1d329b690a9ebe01167d <5c6f845e77ec35f9b7b047cc8f9789bf397cdd3e
Linux patch: 7.1.4
Linux d8cba25d2c68992a6e7c1d329b690a9ebe01167d <222fa7b453b612f4407f260146d89a2ce2bc831d
Linux patch: 6.12.96
Linux d8cba25d2c68992a6e7c1d329b690a9ebe01167d <0dbcecea740d943002c1cbdafa39bdfc108e32a5
Linux patch: 7.2-rc1
Linux d8cba25d2c68992a6e7c1d329b690a9ebe01167d <c3c5925791cff3b84d313293fd60f384d877d793
Linux patch: 0
Linux patch: 6.18.39
Linux 3.17

Affected Packages

euvd linux no fix

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

Intel QuickAssist Technology (QAT) is an offload engine for symmetric and asymmetric cryptography integrated into Intel Xeon/Atom server-class CPUs and discrete PCIe accelerators, exposed via the Linux kernel's crypto/qat subsystem. The driver maintains a global service_table as a linked list of registered service drivers (e.g. symmetric crypto, compression). Service registration (adf_service_add/remove, called from adf_service_register/unregister) correctly holds service_lock, but the device lifecycle paths adf_dev_init(), adf_dev_start(), adf_dev_stop(), adf_dev_shutdown(), adf_dev_restarting_notify(), adf_dev_restarted_notify(), and adf_error_notifier() all traverse the list via list_for_each_entry() without acquiring the lock. CWE-416 (Use After Free) applies because a concurrent unregister can free a list node while a traversal dereferences it; CWE-662 (improper synchronization) is the root cause. The fix adds service_lock acquisition around every list_for_each_entry() call in these paths, with the lock ordering documented as state_lock → service_lock (already consistent with existing callers adf_dev_up() and adf_dev_down()).

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

NVD PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

Race condition narrows the reliable trigger window, warranting AC:H; AV:L and PR:L confirmed by local driver access requirement with no elevated privileges.

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

Primary rating from NVD.

CVSS VectorNVD

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

Lifecycle Timeline

4
CVSS changed
Sep 03, 2026 - 16:07 NVD
7.8 (HIGH)
Patch available
Jul 25, 2026 - 11:18 EUVD
CVE Published
Jul 25, 2026 - 08:49 nvd
HIGH 7.8
CVE Published
Jul 25, 2026 - 08:49 cve.org
UNKNOWN (no severity yet)

DescriptionNVD

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

crypto: qat - protect service table iterations with service_lock

The service_table list is protected by service_lock when entries are added or removed (in adf_service_add() and adf_service_remove()), but several functions iterate over the list without holding this lock.

A concurrent adf_service_register() or adf_service_unregister() call could modify the list during traversal, leading to list corruption or a use-after-free.

Fix this by holding service_lock across all list_for_each_entry() iterations of service_table in adf_dev_init(), adf_dev_start(), adf_dev_stop(), adf_dev_shutdown(), adf_dev_restarting_notify(), adf_dev_restarted_notify(), and adf_error_notifier().

The lock ordering is safe: callers of the static helpers (adf_dev_up() and adf_dev_down()) acquire state_lock before service_lock, and no event_hld callback or service_lock holder ever acquires state_lock in the reverse order.

Executive ViewAI

Why It Matters

A privilege escalation vulnerability in the Linux kernel's Intel QuickAssist Technology (QAT) driver allows low-privileged local users to gain root access through a race condition in service registration. Systems running Intel QAT hardware-commonly deployed in data centers for cryptographic acceleration and high-performance encryption-face the risk of complete compromise if local user accounts are accessible. While exploitation requires local system access and no public exploit code has been identified, the potential for insider threat escalation and lateral movement makes this a high-priority patch for any organization with QAT-enabled infrastructure.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
requires Intel QAT hardware, common in server/cloud data centers
Data Quality
6 sources
Confidence: High

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.2%
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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
Container suse/sl-micro/6.0/base-os-container:2.1.3-7.208 Container suse/sl-micro/6.1/base-os-container:2.2.1-5.184 Affected
Container suse/sl-micro/6.0/kvm-os-container:2.1.3-6.218 Container suse/sl-micro/6.1/kvm-os-container:2.2.1-5.186 Affected
Container suse/sl-micro/6.0/rt-os-container:2.1.3-7.237 Container suse/sl-micro/6.1/rt-os-container:2.2.1-5.180 Affected
SUSE Linux Enterprise Real Time 15 SP7 SUSE Real Time Module 15 SP7 Fixed
SUSE Linux Micro 6.0 Fixed

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