Skip to main content

Linux Kernel CVE-2026-80578

| EUVDEUVD-2026-66493 HIGH
2026-08-26 Linux GHSA-fvfx-mw36-f75m
7.3
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Obtain local low-privilege user account
  2. Delivery
    Verify read access to /dev/fb0 framebuffer device
  3. Exploit
    Craft user buffer backed by faulting memory region
  4. Install
    Call read() on framebuffer device to trigger fb_io_read() loop
  5. C2
    Partial copy_to_user() desynchronizes hardware src pointer
  6. Execute
    Loop executes out-of-bounds hardware I/O reads
  7. Impact
    Leak hardware-mapped memory or destabilize kernel

Vulnerability Assessment

Exploitation Conditions

Exploitation requires a local authenticated account with read permission on a framebuffer device node (typically /dev/fb0, governed by group 'video' membership or equivalent udev rules). The fbdev subsystem must be loaded and a framebuffer device must be present - kernels using only KMS/DRM display drivers without fbdev emulation (CONFIG_FB_CORE disabled or no legacy framebuffer adapter) do not expose this code path. The attacker must be able to craft a user-space buffer that causes copy_to_user() to return a partial count, which requires a deliberately faulting memory region (e.g., memory-mapped with restricted backing). CVSS PR:L confirms a non-root local account is sufficient; PR:N (unauthenticated) does not apply. Systems without physical framebuffer hardware or with framebuffer device access restricted to root are not practically exploitable.

Impact

The CVSS:3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:H, score 7.3) correctly characterizes this as a local, low-complexity, low-privilege vulnerability - the attack surface is meaningfully narrower than network-exploitable kernel flaws. High confidentiality impact reflects potential disclosure of hardware-mapped memory contents; high availability impact reflects risk of kernel instability from unbounded hardware reads. No EPSS score was provided in the intelligence data, and the absence of a KEV listing and public POC indicates no confirmed widespread exploitation at time of analysis. Practical risk is gated by whether the fbdev subsystem is active and whether the attacker holds local access - cloud and containerized workloads not exposing framebuffer devices are not affected by this code path. The availability of patches across multiple stable branches (6.6.153, 6.12.105, 7.1.10, 7.2, 6.18.46) means remediation is tractable for well-maintained distributions; the primary risk is in distributions or appliances running older LTS kernels with slower patch cadence.

Exploit ScenarioDerived

A local authenticated user with read access to /dev/fb0 allocates a user-space buffer backed by a memory-mapped region engineered to fault partway through a transfer, then calls read() on the framebuffer device. The partial copy_to_user() response desynchronizes the hardware src pointer, causing subsequent loop iterations to read hardware I/O memory beyond the originally requested bounds, potentially leaking framebuffer-adjacent hardware memory contents or triggering a kernel crash. No public proof-of-concept code has been 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 – Aug 27, 2026

Out-of-bounds hardware I/O reads in the Linux kernel's fbdev framebuffer subsystem allow low-privileged local users to read memory beyond valid hardware bounds, with high confidentiality and availability impact. The flaw in fb_io_read() stems from pointer desynchronization after a partial copy_to_user() transfer: the hardware source pointer advances by the full original chunk size while count is only decremented by successfully copied bytes, causing subsequent loop iterations to read from incorrect, over-advanced offsets. No public exploit or CISA KEV listing exists at time of analysis; patches are available across multiple stable kernel branches.

RemediationAI

The primary fix is upgrading to a patched kernel version: 6.6.153+ for systems on the 6.6 LTS branch, 6.12.105+ for 6.12 LTS, 6.18.46+ for 6.18, 7.1.10+ for 7.1, or 7.2+ for mainline. Stable-tree fix commits are available at https://git.kernel.org/stable/c/42bc07b4e5a3c8a02a433388f562a8f46d093e11, https://git.kernel.org/stable/c/42a6d8126c194133eafab2b0fd5c8668ebfcba5b, https://git.kernel.org/stable/c/7ff87a01ae3a8cd0208f7499386998223a8b5dba, https://git.kernel.org/stable/c/7110b7b794a2aac2c5cf8eb06ebf2af724c74d50, and https://git.kernel.org/stable/c/81cc73be40c6f028f1ee3f438ace46afe666dbae. As a compensating control pending patching, restricting access to framebuffer device nodes (e.g., chmod 600 /dev/fb0, or adjusting udev rules to limit group membership) reduces the attack surface to root-equivalent users only; the trade-off is that graphical console sessions for unprivileged users will fail. On systems not requiring framebuffer output, blacklisting the fbdev module (echo 'blacklist fbdev' >> /etc/modprobe.d/fbdev-blacklist.conf) eliminates the code path entirely, with the trade-off of disabling legacy framebuffer console support.

Affected VersionsENISA

Linux patch: 6.6.153
Linux 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff <42a6d8126c194133eafab2b0fd5c8668ebfcba5b
Linux 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff <81cc73be40c6f028f1ee3f438ace46afe666dbae
Linux 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff <42bc07b4e5a3c8a02a433388f562a8f46d093e11
Linux patch: 7.2
Linux patch: 6.12.105
Linux patch: 0
Linux patch: 7.1.10
Linux patch: 6.18.46
Linux 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff <7110b7b794a2aac2c5cf8eb06ebf2af724c74d50
Linux 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff <7ff87a01ae3a8cd0208f7499386998223a8b5dba
Linux 6.5

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 fbdev (framebuffer device) subsystem provides kernel-level abstraction for display hardware, exposing framebuffer memory to user space via device nodes such as /dev/fb0. The fb_io_read() function loops to transfer framebuffer I/O memory to user space via copy_to_user(). The flaw is a state machine desynchronization: on a partial copy_to_user() return (possible when the user-space destination buffer is faulty), the code correctly updates the remaining byte count but has already advanced the hardware src pointer by the full original chunk size. The mismatch causes the loop to execute additional hardware reads from an over-advanced offset, exceeding the originally bounded range. This is functionally an out-of-bounds read (analogous to CWE-125) driven by improper loop-state recovery after partial I/O. CPE data confirms the affected product as cpe:2.3:a:linux:linux:* across multiple stable branches, with the vulnerable code path introduced at commit 6121cd9ef911432b14c2a17aefaf8cd2f3cfcdff.

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

Local vector because /dev/fb0 access is required; PR:L as non-root account with device read permission suffices; high C and A from unbounded hardware memory reads; low I as no direct write path.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 6.1 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H
Red Hat 5.5 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
Low
Availability
High

Lifecycle Timeline

4
CVSS changed
Aug 27, 2026 - 06:22 NVD
7.3 (HIGH)
Patch available
Aug 26, 2026 - 16:17 EUVD
CVE Published
Aug 26, 2026 - 14:37 cve.org
UNKNOWN (no severity yet)
CVE Published
Aug 26, 2026 - 14:37 cve.org
HIGH 7.3

DescriptionCVE.org

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

fbdev: core: Fix pointer desynchronization in fb_io_read()

In fb_io_read(), if copy_to_user() performs a partial copy (e.g., due to a faulty user buffer), the loop adjusts the chunk size 'c' and updates the remaining 'count'. However, the hardware 'src' pointer has already been eagerly advanced by the original chunk size.

If the loop is allowed to continue, the read will resume from an incorrect, over-advanced offset. Since the remaining 'count' was only decremented by the successful bytes, this desynchronization causes the next iterations to execute more hardware reads than originally bounded, eventually leading to out-of-bounds I/O reads.

Fix this by breaking out of the loop immediately upon a partial copy_to_user(). A partial copy indicates a faulty user buffer, making subsequent read attempts futile. Breaking out ensures we return the number of successfully read bytes without risking out-of-bounds hardware accesses in subsequent mismatched iterations.

Executive ViewAI

Why It Matters

A vulnerability in the Linux kernel's framebuffer driver (CVE-2026-80578) enables low-privileged local users to read sensitive kernel memory and impact system availability. While no public exploit has been identified, this exposure affects organizations across Linux infrastructure and creates data breach risk. Vendor patches are available and should be deployed promptly to critical systems.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Ubiquitous
Linux kernel underlies the vast majority of cloud, server, and embedded 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.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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

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

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 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-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