Skip to main content

Linux Kernel CVE-2026-93201

| EUVDEUVD-2026-82309 HIGH
2026-09-17 Linux GHSA-rr92-7pj4-8whf
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain CAP_SYS_ADMIN on host/container
  2. Delivery
    Craft cache device with forged seg_id and valid public-seed CRC
  3. Exploit
    Load dm-pcache table pointing at device
  4. Execution
    Decode/replay indexes segments[] out of range
  5. Persist
    Deref/write wild segment pointer
  6. Impact
    Kernel OOB read/write corruption/DoS

Vulnerability Assessment

Exploitation Conditions

Requires CAP_SYS_ADMIN to load a device-mapper table referencing an attacker-supplied dm-pcache cache device carrying forged metadata; because the cache metadata is only CRC-protected with a fixed, publicly-known seed, the attacker can freely control the seg_id field and still pass integrity checks. Exploitation is local only (AV:L) and gated on this administrative capability, so it does not apply to unprivileged users or default remote access. Valid, driver-created cache images set cache_info.n_segs equal to seg_num and are unaffected; only a hand-forged image with an out-of-range or windowed seg_id triggers the wild-pointer deref.

Impact

The vendor CVSS of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) overstates real-world risk because the description makes the true privilege bar explicit: the malicious cache device metadata is only trusted by whoever supplies the cache device on a device-mapper table load, an operation requiring CAP_SYS_ADMIN. That is effectively root-equivalent, so the honest privilege metric is PR:H, not PR:L - an actor who can load a dm table already holds sweeping kernel-affecting capability, making the marginal escalation modest. The flaw is nonetheless a genuine memory-corruption primitive: an out-of-range seg_id read from CRC-only-protected (fixed public seed) on-disk metadata forms a wild pcache_cache_segment pointer that is both dereferenced and written through, i.e. a real OOB read AND write driven by attacker-controlled disk data, so the 'Buffer Overflow' tag is accurate here (unlike many sibling dm/driver CVEs). No EPSS score, KEV listing, or public POC is provided; exploitation status is therefore no public exploit identified at time of analysis. Net: this is a legitimate but privilege-gated local corruption bug in a brand-new driver, not a widespread priority - realistic score closer to 5.0-5.5 once PR:H is applied.

Exploit ScenarioDerived

A local actor with CAP_SYS_ADMIN (e.g. a host administrator, or a container granted that capability) crafts a dm-pcache cache device whose metadata carries a forged segment id and a CRC computed with the known fixed public seed. When the device-mapper table is loaded and the cache is decoded/replayed or processed by the writeback or GC worker, the kernel indexes cache->segments[] with the out-of-range id, dereferencing and writing through a wild pointer for OOB read/write and kernel memory corruption. No public exploit code is identified at the 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 18, 2026

Out-of-bounds read and write in the Linux kernel's dm-pcache device-mapper persistent cache target, where cache segment ids decoded from on-disk cache metadata are used to index cache->segments[] without a bounds check against cache->n_segs. Because that metadata is protected only by a CRC with a fixed, publicly known seed, a local attacker who supplies the cache device in a device-mapper table load - an operation gated on CAP_SYS_ADMIN - can forge an out-of-range seg_id and force dereference and write-through of a wild pcache_cache_segment pointer in kernel context. The vendor CVSS of 7.8 overstates real-world risk given that privileged-local prerequisite; the assessed vector is AV:L/PR:H (confidentiality low, integrity low, availability high). There is no public exploit identified at time of analysis, and vendor fixes are available via upstream commits b4bf8af5e7d7db4c5e179e15017da55857761ac4 and 90c990a68460d7b5720e5634cf650eccdf0f4098, which EUVD maps to patched Linux 7.2.6 and 7.3-rc1.

RemediationAI

Vendor-released patch: Linux 7.2.6 and 7.3-rc1 per EUVD, carrying upstream commits b4bf8af5e7d7db4c5e179e15017da55857761ac4 (https://git.kernel.org/stable/c/b4bf8af5e7d7db4c5e179e15017da55857761ac4) and 90c990a68460d7b5720e5634cf650eccdf0f4098 (https://git.kernel.org/stable/c/90c990a68460d7b5720e5634cf650eccdf0f4098); upgrade to a patched kernel or backport both changes - porting only the cache_seg_id_valid() bounds check without the companion cache_info.n_segs <= seg_num guarantee leaves the forged-window dereference reachable, so backport them as a pair. Because the exploit path requires CAP_SYS_ADMIN to load a device-mapper table referencing an attacker-supplied cache device, the practical compensating controls are to avoid loading dm-pcache cache devices whose backing metadata originates from untrusted or third-party images, and to generate cache images with the driver itself (driver-created caches set cache_info.n_segs equal to seg_num, the condition the fix relies on) rather than accepting hand-built metadata; the trade-off is extra operational friction for image distribution but no loss of functionality. Disabling or not building the dm-pcache target removes the attack surface entirely at the cost of losing persistent cache capability, and restricting device-mapper table loads to fully trusted privileged operators limits who can reach the decode paths - though any holder of CAP_SYS_ADMIN already has broad kernel-level capability, so patching remains the only complete fix. Track EUVD-2026-82309 and CVE-2026-93201 for updated vendor advisories.

Affected VersionsENISA

Linux 6.18
Linux 1d57628ff95b32d5cfa8d8f50e07690c161e9cf0 <b4bf8af5e7d7db4c5e179e15017da55857761ac4
Linux 1d57628ff95b32d5cfa8d8f50e07690c161e9cf0 <90c990a68460d7b5720e5634cf650eccdf0f4098
Linux patch: 7.2.6
Linux patch: 7.3-rc1
Linux patch: 0

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

dm-pcache is a device-mapper target that provides a persistent cache, keeping per-segment metadata on the underlying cache device; segment ids in that metadata are decoded by cache_pos_decode(), cache_key_decode() and by the last-kset handling in cache_replay(), the writeback worker and the GC worker, then used directly as indices into the heap-allocated cache->segments[] array. Only a CRC with a fixed public seed protects that metadata, so an attacker who controls the cache device image can forge both the checksum and the seg_id; because no bounds check existed against cache->n_segs, an out-of-range id produced a wild pcache_cache_segment pointer that was dereferenced and written through, the classic out-of-bounds read/write class (CWE-125/CWE-787, tracked here under the Buffer Overflow tag). The fix adds cache_seg_id_valid() at each decode site and fails the operation with -EIO for out-of-range ids, bounding the id against the initialized-segment count (cache_info.n_segs) rather than the physical device total; a companion change guarantees cache_info.n_segs <= seg_num, closing a window in which a forged cache_info.n_segs smaller than seg_num would leave zeroed structs with NULL data pointers in segments[cache_info.n_segs..seg_num) that a forged id inside that window could still dereference. Driver-created caches set the two counts equal, so valid images are unaffected. Affected CPE: cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*.

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 5.6 MEDIUM

Local dm-table load requires CAP_SYS_ADMIN (PR:H); metadata forgery is straightforward given the public CRC seed (AC:L); impact is a real OOB read/write but crash/corruption-primary for an already-privileged actor, so C:L/I:L/A:H.

3.1 AV:L/AC:L/PR:H/UI:N/S:U/C:L/I:L/A:H
4.0 AV:L/AC:L/AT:N/PR:H/UI:N/VC:L/VI:L/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

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
Sep 18, 2026 - 18:22 NVD
7.8 (HIGH)
Patch available
Sep 17, 2026 - 17:19 EUVD
CVE Published
Sep 17, 2026 - 16:12 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 17, 2026 - 16:12 cve.org
HIGH 7.8

DescriptionCVE.org

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

dm-pcache: validate seg_id fields from persistent memory

cache_pos_decode(), cache_key_decode() and the last-kset branches of cache_replay(), the writeback worker and the GC worker take a cache segment id from the cache device metadata and index cache->segments[] with it without checking it against cache->n_segs. That metadata is only CRC-protected with a fixed public seed, so whoever supplies the cache device on a table load (CAP_SYS_ADMIN) controls the id; an out-of-range value forms a wild pcache_cache_segment pointer that is dereferenced and written through -- an out-of-bounds read and write driven by on-disk data.

Add cache_seg_id_valid() and reject an out-of-range id at each decode site, failing the operation with -EIO instead of indexing past the array. Bound the id against the initialized-segment count (cache_info.n_segs) rather than the physical device total. A forged cache_info.n_segs below seg_num otherwise leaves segments[cache_info.n_segs..seg_num) as zeroed structs whose data pointer is NULL, so a forged id in that window would still be dereferenced. A later patch guarantees cache_info.n_segs <= seg_num, and a driver-created cache sets the two equal, so valid images are unaffected.

Executive ViewAI

Why It Matters

A memory-safety flaw in the Linux kernel's dm-pcache device-mapper persistent cache target allows a local user already holding CAP_SYS_ADMIN to forge on-disk cache metadata and corrupt kernel memory, potentially causing host-wide crashes or loss of integrity on affected systems. Because exploitation requires an already highly privileged local account, exposure is concentrated on multi-tenant hosts, container platforms, and orchestration nodes where elevated capabilities are broadly delegated to workloads. Leadership should care less about mass external exploitation and more about the concentration risk these privileged tiers represent across the server estate and the audit value of closing the gap on schedule.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Rare
dm-pcache is a brand-new persistent-memory cache target introduced in Linux 6.18
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

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

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 Affected

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