Skip to main content

Linux Kernel EUVDEUVD-2026-59699

| CVE-2026-74506 HIGH
2026-08-15 Linux GHSA-437r-ppxq-jxxh
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Local user accesses system with AFS volume mounted
  2. Delivery
    Initiates async FS.FetchData AFS operation
  3. Exploit
    Last rxrpc request packet queued without MSG_MORE
  4. Install
    Server response arrives; afs_call reference drops to zero and struct is freed
  5. C2
    afs_make_call() dereferences freed call->write_iter pointer
  6. Execute
    Kernel UAF triggers slab memory corruption
  7. Impact
    Privilege escalation to root achieved

Vulnerability Assessment

Exploitation Conditions

The kafs (kernel AFS) module must be compiled into or loaded on the target kernel - kernels without CONFIG_AFS_FS or where kafs is not loaded are entirely unaffected. An AFS filesystem volume must be actively mounted on the target system, as the vulnerable code path is only reached during live AFS operations. The attacker must be a local user with sufficient privilege to trigger AFS system calls (corresponding to PR:L in the CVSS vector); remote unauthenticated exploitation is not possible given AV:L. The race condition specifically requires asynchronous AFS operations that do not set call->write_iter, limiting the triggerable path to operations like FS.FetchData rather than FS.StoreData. Reliable exploitation further requires a timing advantage - the CVE description documents that CPU-offline events (as replicated by the generic/650 kernel test) are needed to widen the race window to a consistently exploitable duration, meaning exploitation under normal production load patterns may require deliberate interference with CPU scheduling, which itself may demand elevated privilege. Factors limiting exploitation: local-access-only attack vector, narrow race window without scheduling manipulation, AFS subsystem required, and no confirmed public exploit code.

Impact

The CVSS 7.8 High rating is structurally justified for a kernel UAF with local access, but several signals substantially narrow real-world risk. EPSS at 0.17% (6th percentile) confirms that exploitation has not been observed at scale in adversarial campaigns, and the absence of a CISA KEV listing reinforces that this remains a research-class or QA-discovered issue. The race condition's timing window is inherently narrow - the CVE description explicitly notes that the generic/650 test requires CPU-offline manipulation (via hotplug) to inject a delay long enough to trigger the UAF reliably, suggesting that production exploitation without deliberate scheduling interference is not straightforward. Even a mid-sized municipal IT team in sopot running standard Linux server infrastructure would face essentially zero exposure unless the kafs module is loaded and AFS volumes are actively mounted - a configuration absent from most enterprise and cloud deployments. The vendor-provided AC:L may overstate ease of exploitation given the demonstrated need for external timing assistance; AC:H is arguably more accurate. No public exploit code has been identified. The combination of local-only attack vector, niche AFS prerequisite, race-condition timing dependency, and low EPSS makes this a moderate practical priority despite the high CVSS score.

Exploit ScenarioDerived

A local user account on a Linux system with the kafs module loaded and an AFS volume mounted initiates a rapid series of asynchronous AFS fetch operations (FS.FetchData). By manipulating CPU scheduling - for example, by toggling CPU hotplug state via /sys/devices/system/cpu/cpuN/online - the attacker widens the race window between the last rxrpc packet being queued and afs_make_call() reaching its call->write_iter check, causing the afs_call structure to be freed mid-access. No public exploit code has been identified at time of analysis, but successful exploitation of the resulting kernel UAF would yield kernel-level code execution and privilege escalation to root.

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 – Aug 17, 2026

Use-after-free in the Linux kernel's AFS (Andrew File System) subsystem exposes systems running the kafs module to kernel memory corruption exploitable by local low-privileged users, potentially enabling privilege escalation to root. The race condition in afs_make_call() allows the afs_call structure to be freed by an arriving async server response while the sending function - having transferred its reference rather than retaining one - continues to access the freed memory. EPSS is 0.17% (6th percentile), no CISA KEV listing exists, and upstream fix commits are publicly available on stable kernel trees.

RemediationAI

The primary remediation is to upgrade to Linux kernel 6.18.44, 7.1.8, or 7.2-rc6 (or later), which incorporate the reference-counting fix across three stable-branch commits accessible at https://git.kernel.org/stable/c/c0d3b81f703b2a9e37fe1347610a50cdf0078c27, https://git.kernel.org/stable/c/daaa726b14fc3026a6b328614d312b698f62f391, and https://git.kernel.org/stable/c/4af1ec68d54b3871155914d584fb10669c41a861. Distribution-specific backport availability should be verified with the relevant vendor (Red Hat, Ubuntu, Debian, SUSE, etc.) as no distribution advisories were present in the provided references. For systems that cannot be patched immediately, the most effective compensating control is to blacklist or unload the kafs module - add 'blacklist kafs' to /etc/modprobe.d/blacklist.conf and run 'rmmod kafs' - which eliminates the attack surface entirely at the cost of disabling all AFS filesystem access on that host. If AFS access is operationally required and patching is delayed, restricting local shell access on AFS-serving systems to only trusted administrative accounts reduces exposure, though this does not eliminate the vulnerability since it remains exploitable by any PR:L user.

Affected VersionsENISA

Linux patch: 0
Linux e49c7b2f6de7ff81ca34c56e4eeb4fa740c099f2 <c0d3b81f703b2a9e37fe1347610a50cdf0078c27
Linux patch: 6.18.44
Linux patch: 7.1.8
Linux patch: 7.2-rc6
Linux 5.8
Linux e49c7b2f6de7ff81ca34c56e4eeb4fa740c099f2 <daaa726b14fc3026a6b328614d312b698f62f391
Linux e49c7b2f6de7ff81ca34c56e4eeb4fa740c099f2 <4af1ec68d54b3871155914d584fb10669c41a861

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

The vulnerability resides in the kafs (kernel AFS) module, specifically in afs_make_call() interacting with the rxrpc (Reliable Datagram Sockets) transport layer. When an async AFS operation such as FS.FetchData is dispatched without call->write_iter set (indicating no StoreData payload), rxrpc_kernel_send_data() does not set MSG_MORE in the msghdr, meaning the final request packet is queued immediately. At that point, a server response may arrive at any time, completing the call and dropping its reference count to zero - freeing the afs_call structure. Because afs_make_call() transferred its reference to the call rather than retaining an independent one, it is no longer authorized to access the structure, but does so anyway when checking call->write_iter. A second UAF path exists when a failing async call is being aborted: the async rxrpc teardown notification can destroy the afs_call before afs_make_call() reaches its abort logic. KASAN confirmed the bug as a slab-use-after-free at afs_make_call+0x1c90/0x2210 in kafs. The fix restructures reference ownership so afs_make_op_call() grants op->call an independent reference, ensuring afs_make_call() always holds a valid ref for the duration of its execution. Affected kernel commits span from e49c7b2f6de7ff81ca34c56e4eeb4fa740c099f2 through the three fix commits on respective stable branches.

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.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

AV:L is confirmed local-only; AC:H reflects the race condition requiring CPU scheduling manipulation to reliably exploit; PR:L for local user performing AFS operations; full CIA impact warranted for kernel UAF.

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 7.0 HIGH
AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
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
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Aug 17, 2026 - 06:22 NVD
7.8 (HIGH)
Patch available
Aug 15, 2026 - 13:04 EUVD
CVE Published
Aug 15, 2026 - 12:27 cve.org
UNKNOWN (no severity yet)
CVE Published
Aug 15, 2026 - 12:27 cve.org
HIGH 7.8

DescriptionCVE.org

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

afs: Fix UAF when sending a message

In afs_make_call(), there's a race with async call reception and destruction. If a call is dispatched that doesn't have call->write_iter set (used to specify the data content for FS.StoreData), then the first rxrpc_kernel_send_data() will not set MSG_MORE in the msghdr.

Once rxrpc_send_data() queues the last request packet, the response could come in at any time and cause the call to be completed and put. However, afs_make_call() will look at the call again to see it ->write_iter should be handled - something it's only allowed to do if it has its own ref on the call. Whilst this is the case for synchronous calls, it isn't true for async calls such as FS.FetchData.

There's also a potential UAF in afs_make_call() in the event that an asynchronous call is being sent, but the call fails in some way (e.g. it gets aborted from the server). The problem there is that afs_make_call() tries to abort a call if the rxrpc send fails, but the asynchronous notification from rxrpc may have caused the afs_call to be torn down.

generic/650 plays games with randomly taking CPUs offline, and can interject a significant delay such that the call is deallocated before afs_make_call() gets to check call->write_iter - and a UAF ensues (caught by KASAN).

BUG: KASAN: slab-use-after-free in afs_make_call+0x1c90/0x2210 [kafs] Read of size 8 at addr ffff888035e050e8 by task fsstress/1409

Fix this by making afs_make_op_call() give the op->call its own ref rather than transferring the caller's ref to it and then dropping the ref when afs_make_call() returns.

This also means that the afs_make_call() func never loses its ref on the call now.

Executive ViewAI

Why It Matters

CVE-2026-74506 impacts Linux systems where administrators have enabled the AFS kernel module, creating a path for local user accounts to escalate to root access. Without public exploits currently available, this represents a contained but high-impact risk for any organization running multi-user systems, containers with variable trust levels, or infrastructure where service accounts may be compromised.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
core OS kernel present in virtually all Linux server and cloud deployments
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.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

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

Vendor StatusVendor

SUSE

Severity: Important
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 Affected

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