Skip to main content

Linux Kernel CVE-2026-98117

| EUVDEUVD-2026-86948 HIGH
Use After Free (CWE-416)
2026-09-25 Linux GHSA-57px-gx57-6w68
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 access to a host using cachefiles
  2. Delivery
    Enable cachefiles coherency tracepoint
  3. Exploit
    Trigger a cachefiles coherency check with short/empty xattr
  4. Execution
    Tracepoint reads 8 bytes past buffer
  5. Impact
    Leak adjacent kernel memory or raise KASAN/UAF crash

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

Requires local access to a system where the cachefiles module is in use (fscache-backed local caching for network filesystems such as NFS/AFS) AND where the cachefiles coherency tracepoint (trace_cachefiles_coherency) is enabled - the out-of-bounds read occurs only when that tracepoint fires over a coherency xattr buffer shorter than 8 bytes (including 0-length). Key limiting factors: the vector is local (AV:L), so no remote reach; enabling kernel tracepoints normally requires root/CAP_SYS_ADMIN, which likely makes the effective privilege higher than the input's PR:L; and the disclosed/corrupted window is only up to 8 bytes, bounding impact to a minor info leak or a crash rather than reliable kernel code execution.

Impact

Signals point consistently to a low-to-moderate real-world priority despite the 7.8 'High' CVSS. The supplied vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H is a local, low-privilege, no-interaction flaw with full CIA impact - but that C:H/I:H/A:H triad is the generic autofill the Linux CNA applies to most kernel memory bugs and is not supported by the mechanism described here: the actual defect is trace_cachefiles_coherency() reading a fixed 8 bytes from a variable-length (possibly 0-byte) coherency buffer, i.e. an out-of-bounds/UAF read of at most 8 bytes, which realistically yields a small kernel info leak or a KASAN warning/crash rather than code execution. EPSS is 0.17% (5th percentile), there is no CISA KEV listing, and no SSVC fields are supplied; the vuln.today decision label is 'this_week' (not act_now/emergency). No exploit or PoC reference is present - only the three kernel.org fix commits and the NVD page. Note two tensions to verify: (1) the vector's C:H/I:H/A:H overstates impact versus the description's bounded 8-byte read - the true impact is closer to limited disclosure plus potential crash; (2) PR:L may itself be generous because the vulnerable tracepoint only fires when cachefiles tracing is enabled, which normally requires root/CAP_SYS_ADMIN - verify against the real trigger path before treating this as a low-privilege escalation primitive.

Exploit ScenarioDerived

A local user able to exercise the cachefiles subsystem (fscache-backed caching for a network filesystem) with the cachefiles coherency tracepoint enabled causes the kernel to read 8 bytes past a short or empty coherency xattr buffer, disclosing a few bytes of adjacent kernel memory into the trace output or tripping a KASAN warning/oops. No public exploit or PoC has been identified; the only references are the upstream fix commits. The local attack vector and the requirement that kernel tracing be active make opportunistic remote or unprivileged exploitation unlikely.

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 – Oct 28, 2026

An out-of-bounds read in the Linux kernel's cachefiles coherency tracepoint lets a local user with the trace_cachefiles_coherency tracepoint enabled cause the kernel to read up to 8 bytes past a variable-length (potentially zero-length) coherency xattr buffer, triggering a KASAN warning or a use-after-free-style fault in the tracing path. Only systems actively using the cachefiles module for fscache-backed caching of network filesystems such as NFS or AFS, and where that tracepoint has been turned on, are exposed, and enabling kernel tracepoints normally requires root or CAP_SYS_ADMIN, so the practical privilege bar is higher than the nominal vector suggests. The exposed window is bounded to roughly 8 bytes, so impact is a minor information leak or a crash rather than reliable kernel code execution; EPSS is low (0.17%, 5th percentile), no public exploit code has been identified at time of analysis, and vendor patches are available.

RemediationAI

Vendor-released patches are available: update to Linux 6.18.53, 7.2.7 or 7.3-rc3 (or later) to pick up the cachefiles fix, applying the stable commits 68d459e6e609c31f96a203dd6eec60c634f155e1, 93488ea378b4427598cace558236c110515d743b or a67632c8c2688d6e0091529bcefe54bc5ee80e9b from https://git.kernel.org/stable/c/68d459e6e609c31f96a203dd6eec60c634f155e1, https://git.kernel.org/stable/c/93488ea378b4427598cace558236c110515d743b and https://git.kernel.org/stable/c/a67632c8c2688d6e0091529bcefe54bc5ee80e9b as appropriate for your branch. Because the out-of-bounds read only occurs when trace_cachefiles_coherency fires, the interim mitigation is to keep that tracepoint disabled (do not enable the cachefiles trace events in the tracing/perf subsystem) on unpatched kernels; the trade-off is loss of those diagnostics. Where cachefiles is not needed at all, unmounting fscache-backed NFS/AFS caches and unloading the cachefiles module removes the attack surface at the cost of losing local caching for those network filesystems. Restricting who can enable kernel tracepoints (root/CAP_SYS_ADMIN only, as is typical) limits exposure, since triggering the bug requires that capability. EPSS is low and no public exploit has been identified, so scheduling the kernel update in the normal patch window is reasonable, but do not defer it indefinitely on hosts that routinely run cachefiles tracing.

Affected VersionsENISA

Linux 229105e5cfd9832a9ef1368c96e0098ec3a5fbf0 <93488ea378b4427598cace558236c110515d743b
Linux patch: 6.18.53
Linux 6.14
Linux patch: 7.2.7
Linux patch: 0
Linux patch: 7.3-rc3
Linux 229105e5cfd9832a9ef1368c96e0098ec3a5fbf0 <68d459e6e609c31f96a203dd6eec60c634f155e1
Linux 229105e5cfd9832a9ef1368c96e0098ec3a5fbf0 <a67632c8c2688d6e0091529bcefe54bc5ee80e9b

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

cachefiles is the fscache cache backend that stores cached data and coherency metadata for network filesystems like NFS and AFS, keeping coherency information in an extended attribute (struct cachefiles_xattr) whose payload is variable length and can even be zero bytes. The tracepoint trace_cachefiles_coherency() was handed a pointer to a __be64 cast over that coherency data so it could print the first 8 bytes, without any guarantee that the buffer was actually 8 bytes long, and the address was not 8-byte aligned either. When the tracepoint fires over a shorter buffer, the tracing path reads past the end of the allocation, giving the out-of-bounds/KASAN and use-after-free symptoms tracked under CWE-416. The upstream fix guarantees room for at least 8 bytes, pre-clears those bytes, and rewrites the tracepoint to pull the value as four 2-byte aligned words and reassemble the __be64, which compilers collapse into a single 8-byte load on CPUs that support it. The flaw lives entirely in the kernel tracing/diagnostic path rather than in cache data handling itself, which is why the practical consequence is bounded to a small disclosure or a fault.

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 3.4 LOW

Local only; triggering the vulnerable tracepoint requires tracing privileges (PR:H); the bounded ≤8-byte OOB read gives limited disclosure (C:L) and possible crash (A:L), with no integrity impact.

3.1 AV:L/AC:L/PR:H/UI:N/S:U/C:L/I:N/A:L
4.0 AV:L/AC:L/AT:N/PR:H/UI:N/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N

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
Oct 28, 2026 - 16:07 NVD
7.8 (HIGH)
Patch available
Sep 25, 2026 - 12:02 EUVD
CVE Published
Sep 25, 2026 - 10:36 nvd
HIGH 7.8
CVE Published
Sep 25, 2026 - 10:36 cve.org
UNKNOWN (no severity yet)

DescriptionNVD

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

cachefiles: Fix potential UAF/KASAN warning

Currently, trace_cachefiles_coherency() is being passed a pointer to a __be64 lain over the coherency data in struct cachefiles_xattr so that it can display the first 8 bytes. However, the data is of variable length and could even be 0 bytes. This could lead to a UAF or KASAN warning.

Fix this by making sure the buffer has room for at least 8 bytes and that those 8 bytes are pre-cleared.

Further, those bytes are not 8-byte aligned, so fix the tracepoint to extract the data as four 2-byte words (they are 2-byte aligned) and reassemble the __be64. The compiler will convert this into a single 8-byte load where the CPU supports it.

Executive ViewAI

Why It Matters

CVE-2026-98117 is a high-severity out-of-bounds read in the Linux kernel's cachefiles module that could cause system crashes or minor information leaks on systems actively using cachefiles for network filesystem caching with the coherency tracepoint enabled. While the vulnerability requires elevated privileges to trigger and has a low exploitation likelihood, it affects the availability and integrity of critical caching infrastructure, making patch management essential. Leadership should prioritize patching to prevent potential operational disruptions in environments relying on NFS or AFS caching.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Ubiquitous
Linux kernel; runs across a huge fraction of production environments
Data Quality
4 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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

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.

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