Skip to main content

Linux Kernel EUVDEUVD-2026-59268

| CVE-2026-72369 HIGH
2026-08-15 Linux GHSA-37g9-2p78-fr5w
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Gain local low-privilege shell access
  2. Delivery
    Craft Minix v3 image with s_ninodes near UINT_MAX
  3. Exploit
    Invoke mount() syscall with crafted image
  4. Install
    DIV_ROUND_UP overflow produces zero bitmap-block count
  5. C2
    Superblock validation incorrectly passes
  6. Execute
    minix_fill_super() dereferences unallocated s_imap[0]
  7. Impact
    Kernel NULL pointer dereference panics system

Vulnerability Assessment

Exploitation Conditions

Exploitation requires all of the following conditions: (1) the attacker has local system access with the ability to mount filesystems, either via CAP_SYS_ADMIN or via unprivileged user-namespace mount support (kernel.unprivileged_userns_clone=1, common on Ubuntu and Fedora desktop distributions but typically disabled on hardened servers); (2) the minix kernel module is present and loadable (shipped by default in most Linux distributions but blacklistable); (3) the attacker can supply a crafted block device or disk image. Exploitation is strictly local (AV:L) - no network path exists. The primary limiting factors are the local access requirement, the need for mount capability, and the extremely rare legitimate use of the minix filesystem in any production environment. The practical impact is a kernel panic causing a system crash (denial of service), not arbitrary code execution, which further reduces threat severity.

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, but the reported C:H/I:H impact metrics are likely inflated for what the description confirms is a kernel panic scenario. A NULL pointer dereference reached via a crafted filesystem mount most commonly yields denial of service rather than arbitrary code execution or data disclosure; the A:H metric is well-supported while C:H and I:H would require additional exploitation primitives not described. EPSS of 0.21% at the 11th percentile signals very low real-world exploitation probability. There is no CISA KEV listing and no public exploit identified at time of analysis. The attack vector is local (AV:L) and requires mount capability (PR:L), which in most hardened Linux deployments means either a privileged account or unprivileged user-namespace mount access (available on many desktop distributions but typically disabled on servers). The minix filesystem is legacy technology from the early Linux era and is essentially unused in production, making the real-world attack surface extremely narrow despite the Linux kernel's ubiquitous deployment. Overall, this is a low-priority issue in practice despite the 7.8 CVSS score: local access is required, the minix module must be present and loadable, and the impact is a system crash rather than code execution.

Exploit ScenarioDerived

A local user with CAP_SYS_ADMIN or access to unprivileged user-namespace mounts crafts a Minix v3 disk image with s_ninodes set to 0xFFFFFFFF (UINT_MAX). When the user triggers mount() against this image, minix_blocks_needed() overflows and returns zero, the superblock check passes, and minix_fill_super() dereferences the unallocated s_imap[0] pointer - immediately panicking the kernel and crashing the system. No public exploit 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.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

Integer overflow in the Linux kernel minix filesystem driver allows a local low-privileged user to crash the kernel by mounting a crafted Minix v3 image. The minix_blocks_needed() helper uses DIV_ROUND_UP() in unsigned int arithmetic; an image with s_ninodes or s_zones set near UINT_MAX causes the addition to wrap to zero, tricking minix_check_superblock() into accepting an invalid zero bitmap-block count, after which minix_fill_super() dereferences the unallocated s_imap[0] or s_zmap[0] pointer and panics the kernel. No public exploit identified at time of analysis; EPSS is 0.21% (11th percentile), reflecting very low exploitation probability consistent with a legacy, rarely-used filesystem driver.

RemediationAI

Update to a patched kernel version: 6.6.145 or later for 6.6.x, 6.12.97 or later for 6.12.x, 6.18.40 or later for 6.18.x, 6.19.6 or later for 6.19.x, 7.0, 7.1.5 or later for 7.1.x, or 7.2-rc2 or later. Specific patch commits are available at https://git.kernel.org/stable/c/a11ebaab50d27d6c4c78506f84ff36452e0b901d (and related stable-tree commits at the other referenced git.kernel.org URLs). As a zero-footprint compensating control, blacklist the minix filesystem module by adding 'blacklist minix' to /etc/modprobe.d/blacklist.conf and running depmod; this eliminates the attack surface entirely with the sole trade-off that Minix filesystem images can no longer be mounted on the system. On systems where unprivileged user namespaces are not required, disabling them (sysctl -w kernel.unprivileged_userns_clone=0 on supported distributions) raises the effective privilege bar for exploitation by removing the ability to trigger mounts from low-privilege contexts.

Affected VersionsENISA

Linux patch: 7.1.5
Linux 6.19.6 <6.20
Linux patch: 6.6.145
Linux f57ccd4657c7f082dc47e5b9e18a883bb5f9118f <959c95340a9e19cd333b4c18935fdeecbb2f319d
Linux 7.0
Linux patch: 7.2-rc2
Linux 31fefc18096cdc5549cfa54964d90e0b3229aedc <abe3536a4bedcc43de80b6d4d7e3d57e9ba382a5
Linux 2bb588cede1c1969e49c0a2822c8cb8b346b7682 <a11ebaab50d27d6c4c78506f84ff36452e0b901d
Linux patch: 6.12.97
Linux 5.10.252 <5.11
Linux 6.18.16 <6.18.40
Linux 8c97a6ddc95690a938ded44b4e3202f03f15078c <fb3e566cafc38fe3ba35e6843a2d529a3748870c
Linux a051ecf5c5b0387840dc210413ed3bc7fbdaa69c
Linux 8c97a6ddc95690a938ded44b4e3202f03f15078c <8a29e60e2176b02e04f8737c8b32b696230eb0c5
Linux d791c544efd6b9c944b43cf7f502e5bcb02fb941
Linux 6.6.128 <6.6.145
Linux patch: 6.18.40
Linux 5.15.202 <5.16
Linux 66c7c239c65341f99ae388d4d53dc9df2bcb9925
Linux 1efc128ee4adbc23e082715425ff895449d233bc
Linux 6.1.165 <6.2
Linux 6.12.75 <6.12.97
Linux patch: 0

Affected Packages

euvd linux fix: 5.11, 5.16, 6.2, 6.6.145, 6.12.97, 6.18.40, 6.20

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 fs/minix/ in the Linux kernel stable tree. The function minix_check_superblock() calls minix_blocks_needed() to verify that the on-disk imap and zmap block counts are large enough for the advertised s_ninodes and s_zones values. The macro DIV_ROUND_UP(n, d) expands to ((n) + (d) - 1) / (d); when n is near UINT_MAX and d is a power-of-two block size (enforced by blk_validate_block_size() and sb_set_blocksize()), the addition wraps to zero in 32-bit unsigned arithmetic, producing a quotient of zero that passes the block-count sanity check. minix_fill_super() then attempts to read s_imap[0] or s_zmap[0], which point to unallocated memory, triggering a NULL pointer dereference and kernel panic. The fix replaces DIV_ROUND_UP() with DIV_ROUND_UP_POW2(), which divides before adding the round-up term and is overflow-safe when the divisor is a power of two. The root cause class is CWE-190 (Integer Overflow or Wraparound) leading to CWE-476 (NULL Pointer Dereference); NVD lists CWE as N/A but the mechanism is clearly an arithmetic wraparound.

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.5 MEDIUM

Local mount required (AV:L, PR:L); described impact is kernel panic only, so C:N/I:N/A:H - C:H and I:H from reported vector unsupported by NULL-deref/panic description.

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

Lifecycle Timeline

4
CVSS changed
Aug 17, 2026 - 06:22 NVD
7.8 (HIGH)
Patch available
Aug 15, 2026 - 07:20 EUVD
CVE Published
Aug 15, 2026 - 05:56 cve.org
HIGH 7.8
CVE Published
Aug 15, 2026 - 05:56 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

minix: avoid overflow in bitmap block count calculation

minix_check_superblock() uses minix_blocks_needed() to verify that the on-disk imap and zmap block counts are large enough for the advertised inode and zone counts.

The helper currently performs DIV_ROUND_UP() in unsigned int arithmetic. A Minix v3 image can set s_ninodes or s_zones near UINT_MAX so the addition inside DIV_ROUND_UP() wraps to zero. That makes a zero imap/zmap block count look valid, after which minix_fill_super() can dereference s_imap[0] or s_zmap[0] even though no bitmap buffers were allocated.

Impact: mounting a crafted Minix v3 image whose s_ninodes or s_zones is near UINT_MAX makes minix_check_superblock() accept a zero bitmap-block count and minix_fill_super() dereference s_imap[0]/s_zmap[0], panicking the kernel.

The divisor is the bitmap capacity in bits, blocksize * 8, which is always a power of two: minix_fill_super() obtains the block size through sb_set_blocksize(), and blk_validate_block_size() rejects any size that is not a power of two. Use DIV_ROUND_UP_POW2(), which divides before adding the round-up term and so cannot overflow for a power-of-two divisor.

Executive ViewAI

Why It Matters

CVE-2026-72369 is a denial-of-service vulnerability in the Linux kernel's minix filesystem driver that allows local users with low privilege to crash affected systems. Organizational impact is minimal due to negligible exploitation likelihood (0.2% EPSS), absence of public exploit code, and the minix filesystem's rare use in modern production environments.

Business Impact: Low
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Ubiquitous
Linux kernel deployed universally; minix filesystem driver rarely used in production
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
Low

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