Skip to main content

Linux Kernel CVE-2026-74388

| EUVDEUVD-2026-59535 HIGH
2026-08-15 Linux GHSA-qr2g-fp68-m7q5
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 local user session on target Linux system
  2. Delivery
    Open /dev/sequencer OSS MIDI device
  3. Exploit
    Write crafted SysEx MIDI bytes triggering snd_seq_oss_process_event()
  4. Execution
    Race concurrent port closure against pending event dispatch
  5. Persist
    Win race; snd_seq_event_dup() reads freed slab memory
  6. Impact
    Manipulate kernel heap for privilege escalation or trigger kernel panic

Vulnerability Assessment

Exploitation Conditions

Exploitation requires a local, low-privileged operating system account (CVSS AV:L/PR:L confirmed) with read/write access to the ALSA OSS sequencer device, typically /dev/sequencer or /dev/sequencer2. The snd_seq_oss kernel module must be loaded, which requires that the running kernel was compiled with CONFIG_SND_SEQUENCER_OSS=m or =y - present in most mainstream distribution kernels (Debian, Ubuntu, Fedora, RHEL) but absent in stripped container-optimized or embedded builds. The attacker must successfully win a race condition between submitting a SysEx MIDI event and closing the sequencer port before the kernel dispatches that event; this timing dependency makes exploitation non-deterministic and load-sensitive, reducing reliability. No network access is possible (AV:L); no elevated privileges beyond a standard user session are required (PR:L); no user interaction from a victim is needed (UI:N). Exploitation is further limited by modern kernel mitigations such as SMEP, SMAP, and KASLR, which complicate turning a heap UAF read into a reliable privilege escalation primitive.

Impact

The NVD CVSS 3.1 score of 7.8 High (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) captures the worst-case impact accurately but overstates exploitability by rating AC:L for what is fundamentally a race condition; reliable exploitation requires precise scheduling timing between event dispatch and port teardown, which is more consistent with AC:H. The EPSS score of 0.17% at the 6th percentile independently corroborates low near-term exploitation probability, consistent with a kernel race condition requiring local access and timing control. This CVE is not listed in the CISA KEV catalog and no public proof-of-concept exploit has been identified. Despite the theoretically severe C:H/I:H/A:H kernel-level impact, the combination of local-only attack vector, required low-privilege session, and race-condition timing dependency substantially constrains real-world exploitability - even a mid-sized municipal IT team in rybnik should treat this as a standard patch-cycle kernel update rather than an emergency out-of-band response. An SSVC assessment would likely classify this as 'Track*': apply on normal patching cadence, monitor for POC emergence, escalate only if KEV listing occurs.

Exploit ScenarioDerived

A local attacker with a standard unprivileged account opens the ALSA OSS sequencer device at /dev/sequencer, writes crafted SysEx MIDI byte sequences to populate a pending dispatch event containing a raw kernel pointer, then concurrently closes the sequencer port to trigger resource teardown in snd_seq_oss_midi_check_exit_port() before the event dispatcher calls snd_seq_event_dup(). If the race window is won, the kernel reads from freed slab memory, potentially enabling heap layout manipulation for privilege escalation or causing a kernel panic. No public proof-of-concept exploit has been identified, but the upstream KASAN report confirms the crash path is reachable on affected kernels.

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

Use-after-free in the Linux kernel's ALSA OSS sequencer subsystem allows a local low-privileged attacker to corrupt kernel heap memory by racing SysEx MIDI event dispatch against concurrent sequencer port closure. The vulnerable code path in snd_seq_oss_process_event() stores a raw pointer to SysEx byte data in the event record without retaining a refcount across the full dispatch lifecycle, enabling freed memory to be accessed in snd_seq_event_dup() if the OSS MIDI port is closed before dispatch completes. Vendor-released patches are available at kernel versions 6.18.40 and 7.1.5; no public exploit code and no active exploitation have been identified at time of analysis.

RemediationAI

The primary fix is to upgrade to Linux kernel 6.18.40 or 7.1.5 (or later), which include the upstream patches available at https://git.kernel.org/stable/c/6dc781778b595be94c31395b2cb167f65145d91f (6.x branch), https://git.kernel.org/stable/c/7c349b4f2a603202fb8c363bd2774a22ac2fddf3 (7.x branch), and https://git.kernel.org/stable/c/7aad70cabd8f34cf11a9593fcd3f2ac3f5496943 (7.x branch). Distribution users should apply the vendor kernel security update as soon as it becomes available for their release stream. As a compensating control where immediate patching is not feasible, administrators can eliminate the attack surface by blacklisting or unloading the snd_seq_oss kernel module (add 'blacklist snd_seq_oss' to /etc/modprobe.d/), which prevents the vulnerable code path from being reached without affecting non-OSS ALSA sequencer functionality; the trade-off is loss of OSS MIDI sequencer compatibility for legacy applications. Alternatively, restrict permissions on /dev/sequencer and /dev/sequencer2 via udev rules to prevent untrusted local users from opening the device, though this requires careful group membership management and does not protect against compromised processes already holding device access.

Affected VersionsENISA

Linux patch: 7.1.5
Linux 2.6.12
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <7c349b4f2a603202fb8c363bd2774a22ac2fddf3
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <6dc781778b595be94c31395b2cb167f65145d91f
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <7aad70cabd8f34cf11a9593fcd3f2ac3f5496943
Linux patch: 7.2-rc1
Linux patch: 6.18.40
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

The vulnerability resides in the ALSA (Advanced Linux Sound Architecture) OSS compatibility sequencer layer within sound/core/seq/oss/, specifically across the functions snd_seq_oss_midi_putc() and snd_seq_oss_process_event(). When SysEx (System Exclusive) MIDI data is processed, the sequencer event structure is populated with a raw data.ext.ptr pointer to the original SysEx byte buffer. This pointer is later dereferenced during kernel dispatch through snd_seq_client_enqueue_event() and snd_seq_event_dup() - a call confirmed in the KASAN stack trace at snd_seq_event_dup+0x40c/0x470. The root cause is a lifecycle gap in the existing snd_use_lock_t refcounting mechanism: the refcount protecting the OSS MIDI device was released before the sequencer dispatcher consumed the pending event, creating a window where snd_seq_oss_midi_check_exit_port() could free the underlying MIDI device resources while the stale pointer remained live in the event queue. The fix extends the refcount hold from snd_seq_oss_process_event() through the dispatcher call in the caller. CPE data identifies the affected software as cpe:2.3:a:linux:linux across all versions predating the fix commits. Although CWE is listed as N/A in the NVD entry, this is a textbook CWE-416 (Use After Free) triggered by a concurrency race. KASAN slab-use-after-free detection in the upstream report confirms the flaw is triggerable on x86-64 kernels with KASAN enabled.

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

Race condition timing requirement elevates AC to H over the vendor AC:L; all other metrics preserved as local access and low privileges are confirmed by description.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE 7.0 HIGH
AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/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:19 EUVD
CVE Published
Aug 15, 2026 - 05:59 cve.org
HIGH 7.8
CVE Published
Aug 15, 2026 - 05:59 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

ALSA: seq: oss: Fix UAF at handling events with embedded SysEx data

The OSS sequencer processes the input MIDI bytes into a sequencer event to be dispatched later (in snd_seq_oss_midi_putc() called from snd_seq_oss_process_event()). When it's a SysEx data, the event record contains data.ext.ptr pointer to the original SysEx bytes, and the referred data is copied into the pool afterwards at dispatching. The problem is that, if the sequencer port gets closed concurrently before the dispatch, the OSS sequencer core also releases the resources (in snd_seq_oss_midi_check_exit_port()), while the pending event may hold a stale pointer, eventually leading to a UAF at a later dispatch.

Fortunately, there is already a refcounting mechanism (snd_use_lock_t) for the OSS MIDI device access, and for addressing the issue above, we just need to extend the refcount until the event gets dispatched.

This patch extends snd_seq_oss_process_event() to give back the refcount object, which is in turn released after calling the sequencer dispatcher with the given event in the caller side.

According to the original report, KASAN report as below:

KASAN slab-use-after-free in snd_seq_event_dup+0x40c/0x470 RIP: 0033:0x7f2cb66a6340 Read of size 6 Call trace: dump_stack_lvl+0x73/0xb0 (?:?) print_report+0xd1/0x650 (?:?) srso_alias_return_thunk+0x5/0xfbef5 (?:?) __virt_addr_valid+0x1a7/0x340 (?:?) kasan_complete_mode_report_info+0x64/0x200 (?:?) kasan_report+0xf7/0x130 (?:?) snd_seq_event_dup+0x40c/0x470 (?:?) kasan_check_range+0x10c/0x1c0 (?:?) __asan_memcpy+0x27/0x70 (?:?) snd_seq_event_dup+0x9/0x470 (?:?) snd_seq_client_enqueue_event+0x139/0x240 (?:?) _raw_spin_unlock_irqrestore+0x4b/0x60 (?:?) snd_seq_kernel_client_enqueue+0x102/0x120 (?:?) snd_seq_oss_write+0x416/0x4e0 (?:?) apparmor_file_permission+0x20/0x30 (?:?) odev_write+0x3b/0x60 (?:?) vfs_write+0x1ce/0x850 (?:?) lock_release+0xc8/0x2a0 (?:?) __kasan_check_write+0x18/0x20 (?:?) __mutex_unlock_slowpath+0x129/0x510 (?:?) ksys_write+0xe1/0x180 (?:?) mutex_unlock+0x16/0x20 (?:?) odev_ioctl+0x65/0xc0 (?:?) __x64_sys_write+0x46/0x60 (?:?) x64_sys_call+0x7d/0x20d0 (?:?) do_syscall_64+0xc1/0x360 (arch/x86/entry/syscall_64.c:87) entry_SYSCALL_64_after_hwframe+0x77/0x7f (?:?)

Executive ViewAI

Why It Matters

A use-after-free vulnerability in the Linux kernel's ALSA OSS sequencer subsystem (CVE-2026-74388, CVSS 7.8) allows local low-privileged users to corrupt kernel heap memory and potentially escalate privileges. This affects Linux systems with ALSA sound drivers and poses significant risk to deployments with untrusted local users or compromised applications. Vendor patches are available and should be prioritized for deployment.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
core OS kernel present in virtually all Linux-based 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.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

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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