Skip to main content

Linux Kernel EUVDEUVD-2026-59678

| CVE-2026-74485 HIGH
2026-08-15 Linux GHSA-9rj7-pvjp-5h34
7.1
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Obtain low-privilege local shell access
  2. Delivery
    Create unprivileged user namespace
  3. Exploit
    Mount binfmt_misc filesystem within namespace
  4. Install
    Craft registration string with flag character as delimiter
  5. C2
    Write string to binfmt_misc register file
  6. Execute
    check_special_flags() overreads past heap allocation
  7. Impact
    Read adjacent kernel heap memory or trigger crash

Vulnerability Assessment

Exploitation Conditions

Exploitation requires local system access with at least a low-privilege user account (CVSS PR:L) and the ability to mount a binfmt_misc filesystem - which is available to unprivileged users within a user namespace on distributions that permit unprivileged user namespace creation (kernel.unprivileged_userns_clone=1 or equivalent, the default on Ubuntu, Debian, Arch, and many others). The attacker must write a crafted registration string to the binfmt_misc register file using one of exactly four flag characters ('P', 'O', 'C', or 'F') as the field delimiter. The registration is ultimately rejected by the parser, so the attacker cannot install a persistent binary handler - only the out-of-bounds read occurs. Systems that restrict unprivileged user namespace creation via sysctl or LSM policy are not reachable from an unprivileged context and are effectively not exploitable without a separate privilege escalation.

Impact

The CVSS 3.1 score of 7.1 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H) is consistent with the description: local access at low privilege is sufficient because binfmt_misc mounts are available to unprivileged users within user namespaces on most mainstream distributions. The C:H metric reflects potential exposure of adjacent heap contents; A:H reflects the possibility of a page fault crashing the kernel if the scan crosses into an unmapped region. EPSS at 0.17% (6th percentile) is notably low given the local-privilege-escalation-adjacent attack surface, suggesting the broader research community assesses exploitation as non-trivial or unattractive. The absence of a CISA KEV entry confirms no observed active exploitation at time of analysis. No POC has been identified. Real-world risk is further tempered by the fact that distributions such as RHEL, some Ubuntu configurations, and hardened deployments disable unprivileged user namespaces entirely (sysctl kernel.unprivileged_userns_clone=0 or user.max_user_namespaces=0), which removes the attack path without patching. For environments with unrestricted user namespaces and unpatched kernels, this is a credible local read primitive worth prioritising in the normal patch cycle, not an emergency.

Exploit ScenarioDerived

A local user with at least a standard shell account creates a user namespace (available by default on most modern distributions), mounts a binfmt_misc filesystem within it, and writes a registration string such as 'PaPEPPxPPiP' - using 'P' as the delimiter - to the register file. The kernel's check_special_flags() parser consumes the eight 'P' padding bytes appended as terminators and continues reading into adjacent heap memory until it encounters a non-flag byte, exposing potentially sensitive kernel heap data or triggering a crash if the read crosses a page boundary. No public POC has been identified, but the exploit primitive is straightforwardly derivable from the patch commit description alone.

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

Out-of-bounds slab read in the Linux kernel's binfmt_misc subsystem allows local low-privileged users - including those operating within unprivileged user namespaces - to trigger heap memory exposure or a kernel crash by registering a binary format with a flag character ('P', 'O', 'C', or 'F') as the field delimiter. The flaw exists because check_special_flags() consumes flag characters without using the delimiter as a terminator, swallowing the 8-byte padding appended by create_entry() and reading past the end of the allocated buffer. No public exploit has been identified at time of analysis, and the EPSS score of 0.17% (6th percentile) indicates low near-term exploitation probability; however, reachability from unprivileged user namespaces on most modern Linux distributions meaningfully broadens the real-world attack surface.

RemediationAI

The primary fix is upgrading to a patched kernel version: 6.6.151, 6.12.103, 6.18.44, 7.1.8, or 7.2-rc6, with commits available at https://git.kernel.org/stable/c/840bb9c49c3e75fb32b593d67ab32f6b77122262, https://git.kernel.org/stable/c/9a2d87db3898b5993b64fd258d0334e0eba9ee0d, https://git.kernel.org/stable/c/1819f82dee766c58295ecaacdac02cdf6837d7a4, https://git.kernel.org/stable/c/1853e95c9bfe69ef1dd862b3f551e68f4a1b76cc, and https://git.kernel.org/stable/c/8e85d50ba1117fd446bf9a250bd8a97d48384bdc. If immediate patching is not possible, the most effective compensating control is to disable unprivileged user namespace creation - set kernel.unprivileged_userns_clone=0 (Debian/Ubuntu) or user.max_user_namespaces=0 via sysctl on RHEL-family systems - which prevents unprivileged users from mounting binfmt_misc entirely; note this will break rootless container runtimes (Podman, rootless Docker) and tools relying on user namespaces. Alternatively, deploy AppArmor or SELinux policy to prevent unprivileged mounting of binfmt_misc filesystems, with the trade-off of increased policy maintenance overhead.

Affected VersionsENISA

Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <840bb9c49c3e75fb32b593d67ab32f6b77122262
Linux patch: 0
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <9a2d87db3898b5993b64fd258d0334e0eba9ee0d
Linux 2.6.12
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <1853e95c9bfe69ef1dd862b3f551e68f4a1b76cc
Linux patch: 6.12.103
Linux patch: 7.1.8
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <8e85d50ba1117fd446bf9a250bd8a97d48384bdc
Linux patch: 7.2-rc6
Linux patch: 6.6.151
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <1819f82dee766c58295ecaacdac02cdf6837d7a4
Linux patch: 6.18.44

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 binfmt_misc kernel subsystem lets userspace register custom binary format handlers via a filesystem interface. Registration strings use a user-chosen single-byte delimiter to separate five fields: name, type, magic/extension, interpreter, and flags. The create_entry() function appends eight copies of the chosen delimiter as padding so that field parsers - which use strchr()/scanarg() - always terminate even on truncated input. The flags field is the exception: check_special_flags() iterates over the flag characters 'P' (preserve argv[0]), 'O' (open-binary), 'C' (credentials), and 'F' (fix-binary), stopping only at the first byte outside that set. When the delimiter is itself one of these four characters, the padding is consumed as valid flags rather than acting as a terminator, and the scan walks off the end of the kmalloc'd buffer into adjacent heap or an unmapped page. Under KASAN this manifests as a slab out-of-bounds read. The CPE identifier is cpe:2.3:a:linux:linux. No CWE is formally assigned in the input; the root cause maps to CWE-125 (Out-of-bounds Read) with a secondary contribution from CWE-20 (Improper Input Validation) - the fix rejects any delimiter that is a flag character before processing begins.

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

Local access via user namespace mount suffices at low privilege; heap overread yields high confidentiality impact and potential crash (A:H), with no integrity impact and no scope change.

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

Lifecycle Timeline

4
CVSS changed
Aug 17, 2026 - 06:22 NVD
7.1 (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.1

DescriptionCVE.org

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

binfmt_misc: reject a flag character as the field delimiter

The registration string starts with a user chosen delimiter that separates the individual fields. So that the field parsers terminate even on a truncated string create_entry() pads the buffer with that same delimiter:

memset(buf + count, del, 8);

Most fields are scanned for the delimiter with strchr()/scanarg() and happily stop on the padding. The flags field is different: instead of scanning for the delimiter check_special_flags() consumes the flag characters 'P', 'O', 'C' and 'F' and stops at the first byte that is none of them, relying on the trailing delimiter to end the scan.

If the delimiter is itself a flag character the padding no longer acts as a terminator. The scan swallows all eight padding bytes and keeps reading past the end of the allocation until it hits a byte that is not a flag character. For example registering

PaPEPPxPPiP

with 'P' as the delimiter (name "a", type extension, magic "x", interpreter "i", empty flags) leaves the flag scan running off the end of the buffer. The registration is rejected in the end because the parser does not stop exactly at buf + count, but only after the out of bounds read has already happened. With an unlucky allocation layout the scan can walk into an unmapped page; under KASAN it is reported as a slab out of bounds read. binfmt_misc mounts are available to unprivileged users in a user namespace so the read is reachable without privileges.

Reject a delimiter that is one of the flag characters up front. Such a registration was always rejected anyway, only after the out of bounds read, so no valid registration string changes meaning.

Executive ViewAI

Why It Matters

CVE-2026-74485 is a high-severity heap memory disclosure vulnerability in the Linux kernel's binfmt_misc subsystem affecting modern Linux distributions. Local users, including those in unprivileged containers and namespaces, can trigger the flaw to expose sensitive kernel memory or cause kernel denial of service, creating dual risks to both confidentiality and availability across the organization's containerized and on-premises Linux infrastructure.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
Linux kernel underpins the vast majority of servers, cloud, and embedded deployments globally
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.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

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