Skip to main content

Linux Kernel CVE-2026-74470

| EUVDEUVD-2026-59663 HIGH
2026-08-15 Linux GHSA-jmr9-wc6r-pj32
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
    Confirm 32-bit kernel and scsi_debug loaded
  3. Exploit
    Open scsi_debug virtual SCSI device
  4. Install
    Send REPORT ZONES with alloc_len in 0xFFFFFFC1-0xFFFFFFFF
  5. C2
    ALIGN() overflows to 0x100000000, truncates to zero
  6. Execute
    kzalloc(0) returns ZERO_SIZE_PTR, bypasses null check
  7. Impact
    OOB write corrupts kernel heap, escalate to root or crash

Vulnerability Assessment

Exploitation Conditions

Three specific conditions must simultaneously be present for exploitation: (1) the target kernel must be a 32-bit build where size_t is 4 bytes - 64-bit kernels are not affected because the arithmetic does not overflow in a 64-bit size_t context; (2) the scsi_debug kernel module must be loaded - this is a SCSI device emulator used exclusively for kernel testing and is NOT loaded by default in any standard Linux distribution (Debian, RHEL, Ubuntu, SUSE, etc.); and (3) the attacker must have local access sufficient to open the scsi_debug device and submit SCSI commands, which corresponds to CVSS PR:L. Exploitation is blocked in all standard production Linux deployments because the scsi_debug module is absent by default and 32-bit kernel deployments are a vanishing minority. The crafted alloc_len must fall specifically in 0xFFFFFFC1-0xFFFFFFFF; values outside this range do not trigger the overflow. Remote and unauthenticated exploitation is not possible.

Impact

The CVSS 7.8 score (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects a serious local attack with high impact across all three pillars, and the official low-complexity rating suggests the exploit is mechanically straightforward once preconditions are met. However, real-world risk is substantially narrowed by the requirement for both 32-bit kernel architecture and the scsi_debug module being loaded - neither of which applies to the vast majority of modern production Linux deployments. The EPSS score of 0.17% at the 6th percentile is consistent with this narrow attack surface and confirms that exploit activity has not been observed. There is no CISA KEV listing and no known public POC. Even a mid-sized municipal IT team in olsztyn running a heterogeneous Linux fleet should treat this as low urgency unless they can confirm 32-bit kernel deployments with scsi_debug loaded, which would be an atypical configuration. The CVSS AC:L designation somewhat overstates real-world exploitability: the 32-bit architecture constraint is a prerequisite condition that dramatically limits the affected population, an inconsistency worth flagging when triaging this finding. SSVC framing: exploitation status is none, automatability is low (preconditions must be confirmed per target), and technical impact is total on vulnerable hosts - resulting in a deferred/track posture for most organizations.

Exploit ScenarioDerived

An attacker with a local shell on a 32-bit Linux system where the scsi_debug module is loaded opens the scsi_debug virtual SCSI device and issues a REPORT ZONES command with an alloc_len field set to a value in the range 0xFFFFFFC1-0xFFFFFFFF. The kernel's resp_report_zones() function overflows during buffer size computation, allocates a zero-byte buffer, and proceeds to write zone descriptor data into unallocated kernel memory - corrupting heap structures in a manner potentially usable for local privilege escalation to root or causing an immediate kernel panic. No public proof-of-concept exploit code is known 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's scsi_debug module allows a local low-privileged attacker on a 32-bit system to trigger an out-of-bounds write via a crafted SCSI REPORT ZONES command. When alloc_len is in the range 0xFFFFFFC1-0xFFFFFFFF, an ALIGN() rounding operation overflows to 0x100000000, which truncates to zero under 32-bit size_t, causing kzalloc(0) to return a ZERO_SIZE_PTR sentinel that passes null checks - subsequent pointer arithmetic and loop writes then corrupt kernel memory, leading to privilege escalation or kernel panic. No public exploit has been identified at time of analysis; EPSS of 0.17% (6th percentile) reflects the narrow exploitation conditions required.

RemediationAI

The primary fix is to upgrade to a patched Linux kernel stable release: 6.6.151, 6.12.103, 6.18.44, 7.1.8, or 7.2-rc6, depending on the branch in use. Individual fix commits for cherry-picking into custom kernels are available at https://git.kernel.org/stable/c/49e5b25a0b74dbac595f122e5608fdce2918cc4e, https://git.kernel.org/stable/c/495058429ca55ab7fcc21977b63b92907ad68066, https://git.kernel.org/stable/c/2047ed09bf13453b7d6f9431b112ec07984dd69b, https://git.kernel.org/stable/c/d6e6da6bc3b53231fac77ffab428da8173ee729c, and https://git.kernel.org/stable/c/93dde0bf2f39a0f9f57fd610aa3201ce5b753433. For systems that cannot be patched immediately, the most effective workaround is to unload and blacklist the scsi_debug module: run 'modprobe -r scsi_debug' and add 'blacklist scsi_debug' to /etc/modprobe.d/blacklist.conf. This eliminates the attack surface entirely with no operational impact on production systems, since scsi_debug serves no function outside kernel testing and development environments. If the module must remain loaded for testing purposes, restrict access to the SCSI character device nodes to trusted users only.

Affected VersionsENISA

Linux patch: 7.2-rc6
Linux 5.16
Linux patch: 0
Linux 7db0e0c8190a086ef92ce5bb960836cde49540aa <2047ed09bf13453b7d6f9431b112ec07984dd69b
Linux patch: 7.1.8
Linux c4d2d7c935a4ad20e8e726ca10499cefe4537103
Linux ebacb44cb2042b90951140eda806bedad23ef554
Linux 7db0e0c8190a086ef92ce5bb960836cde49540aa <49e5b25a0b74dbac595f122e5608fdce2918cc4e
Linux 7db0e0c8190a086ef92ce5bb960836cde49540aa <93dde0bf2f39a0f9f57fd610aa3201ce5b753433
Linux 7db0e0c8190a086ef92ce5bb960836cde49540aa <495058429ca55ab7fcc21977b63b92907ad68066
Linux 5.15.8 <5.16
Linux 7db0e0c8190a086ef92ce5bb960836cde49540aa <d6e6da6bc3b53231fac77ffab428da8173ee729c
Linux 5.10.85 <5.11
Linux patch: 6.18.44
Linux patch: 6.6.151
Linux patch: 6.12.103

Affected Packages

euvd linux fix: 5.11, 5.16

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 resp_report_zones() within the scsi_debug kernel module (CPE: cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*), a kernel driver that emulates SCSI storage devices primarily for testing and development. The REPORT ZONES command is part of the Zoned Block Commands (ZBC/ZAC) specification used with shingled magnetic recording (SMR) drives. The root cause is an integer arithmetic overflow: the v3 fix to the function uses ALIGN() to round alloc_len up to the next RZONES_DESC_HD boundary, but when alloc_len falls in 0xFFFFFFC1-0xFFFFFFFF, the rounded value exceeds the 32-bit unsigned maximum, producing 0x100000000. On 32-bit kernels where size_t is 4 bytes, this silently truncates to zero when passed to kzalloc(). The Linux kernel's kzalloc(0) returns ZERO_SIZE_PTR - a non-NULL poison value - which bypasses the null allocation check. The loop then computes desc = arr + 64 and writes zone descriptors into unallocated memory, constituting a classic heap out-of-bounds write. Although no CWE was formally assigned, this maps to CWE-190 (Integer Overflow or Wraparound) leading to CWE-787 (Out-of-bounds Write).

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

32-bit kernel architecture and loaded scsi_debug module are non-default preconditions warranting AC:H; local low-privilege access confirmed by PR:L; all three impact dimensions high due to kernel heap corruption potential.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE HIGH
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 - 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:

scsi: scsi_debug: Fix REPORT ZONES alloc_len underflow OOB write

resp_report_zones() sizes the reply buffer from the CDB allocation length. The v3 fix rounds alloc_len up with ALIGN() before deriving the descriptor count:

rep_max_zones = (ALIGN((u64)alloc_len, RZONES_DESC_HD) - RZONES_DESC_HD) >> ilog2(RZONES_DESC_HD); arr_len = (u64)RZONES_DESC_HD * (rep_max_zones + 1);

For alloc_len in 0xFFFFFFC1..0xFFFFFFFF, ALIGN() rounds up to 0x100000000, so arr_len is 4 GB. On 32-bit, kzalloc()'s size_t is 32-bit and truncates 0x100000000 to 0; kzalloc(0) returns ZERO_SIZE_PTR, which passes the !arr check, and desc = arr + 64 is then dereferenced in the loop -> out-of-bounds write / panic.

Clamp rep_max_zones to devip->nr_zones. The loop already stops at sdebug_capacity (after nr_zones zones), so a report can never hold more than nr_zones descriptors; the clamp does not change the report, it only bounds arr_len to (nr_zones + 1) * RZONES_DESC_HD, a real device property that can never reach 0x100000000.

Executive ViewAI

Why It Matters

A Linux kernel vulnerability in the scsi_debug module enables local privilege escalation, allowing low-privileged attackers to gain system-level control. Organizations running affected Linux systems face risk of unauthorized access and system compromise. Patching is available and should be deployed across vulnerable systems.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
Linux kernel deployed across virtually all server, cloud, and embedded production systems
Data Quality
6 sources
Confidence: High

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

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