Skip to main content

Linux Kernel CVE-2026-74513

| EUVDEUVD-2026-59706 HIGH
2026-08-15 Linux GHSA-p4c6-79fv-gqjg
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
  2. Delivery
    Identify active SMC-D loopback / dibs interface
  3. Exploit
    Spawn concurrent attach and unregister threads on same DMB node
  4. Install
    Win race between lock release and refcount decrement
  5. C2
    Access freed dmb_node kernel object
  6. Execute
    Reclaim slab slot with controlled data
  7. Impact
    Escalate privileges to root

Vulnerability Assessment

Exploitation Conditions

Exploitation requires a local shell with at least low-privilege access (PR:L per CVSS) on a Linux kernel version containing the vulnerable dibs loopback code. The race can only be triggered on systems where the SMC-D protocol with dibs loopback or ISM is active and accessible to the attacker's process - this is a non-default configuration found primarily in IBM Z and SMC-D-enabled enterprise Linux deployments. Concurrent execution (multi-core or preemptible kernel) is necessary to open the race window. Exploitation is limited by: the non-default nature of SMC-D loopback (most general-purpose Linux systems do not load or use this code path), the need to race kernel-level lock/unlock operations (requires timing precision), and the requirement for pre-existing local access. Remote exploitation is not possible per AV:L.

Impact

The official CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, score 7.8) correctly identifies local authenticated exploitation with unchanged scope and high system impact. However, AC:L may overstate exploitability: winning this race requires precisely timed concurrent kernel operations, which adds practical complexity beyond what AC:L implies. EPSS at 0.17% (6th percentile) corroborates that no widespread exploit tooling is circulating. The vulnerability is not listed in CISA KEV and no POC has been identified. Real-world risk is further bounded by the requirement that SMC-D loopback via the dibs/ISM path must be active - a configuration found primarily in IBM Z mainframe-adjacent Linux environments, not general-purpose distributions. For enterprises not running SMC-D workloads, exposure is negligible despite the high CVSS base score. For IBM Z or SMC-D-enabled deployments, this is a credible local privilege escalation path that warrants prompt patching.

Exploit ScenarioDerived

A local attacker with a low-privilege shell on a Linux system running SMC-D loopback opens two threads: one repeatedly calls the dibs attach path on a target DMB node while the other triggers the unregister path on the same node. When the unregister thread wins the race and frees the dmb_node between the attach thread's hash lookup and its refcount_inc_not_zero call, the attach thread operates on freed kernel memory. The attacker then reclaims the freed slab object with a controlled allocation, achieving a type-confusion or heap spray primitive usable for privilege escalation to root. No public exploit code exists 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

Use-after-free in the Linux kernel's dibs loopback subsystem allows a local low-privileged attacker to corrupt kernel memory during concurrent DMB node attach, detach, and unregister operations. The vulnerability arises from a race window between hash table lookup under dmb_ht_lock and the subsequent refcount operation performed after the lock is dropped, enabling a concurrent unregister path to free the node before the refcount transition completes. With a CVSS score of 7.8 and C:H/I:H/A:H impact metrics, successful exploitation can lead to privilege escalation or kernel crash; however, no public exploit is identified at time of analysis and EPSS at 0.17% reflects low current exploitation probability.

RemediationAI

Update to a kernel version containing the fix: Linux 7.2-rc6 or later for mainline, 7.1.8 or later for the 7.1 stable series, or 6.18.44 or later for the 6.18 stable series. The upstream fix commits are available at https://git.kernel.org/stable/c/c0837aeace96152d14b17fdd19d70102b6631a7d, https://git.kernel.org/stable/c/48c073f88c93707089a4214f21cb4c3de5aea6e4, and https://git.kernel.org/stable/c/a10ea943356b9d70c5616a0a06f6fa97cfdaccb1. Distribution maintainers on other stable branches should cherry-pick the appropriate commit. As a compensating control for systems where patching is not immediately possible: disabling the SMC-D protocol and/or preventing loading of the dibs kernel module (if built as a module) eliminates the vulnerable code path entirely with no impact to workloads that do not use SMC-D; verify with 'lsmod | grep dibs' and block via modprobe blacklist if applicable. Note that this workaround does not apply if the dibs code is compiled directly into the kernel image.

Affected VersionsENISA

Linux c3a910f2380fe294d14e42af66af3d3eed8fecbf <a10ea943356b9d70c5616a0a06f6fa97cfdaccb1
Linux patch: 7.2-rc6
Linux patch: 6.18.44
Linux 6.10
Linux c3a910f2380fe294d14e42af66af3d3eed8fecbf <48c073f88c93707089a4214f21cb4c3de5aea6e4
Linux patch: 0
Linux patch: 7.1.8
Linux c3a910f2380fe294d14e42af66af3d3eed8fecbf <c0837aeace96152d14b17fdd19d70102b6631a7d

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 affected code resides in the Linux kernel's dibs (DMB - Direct Memory Buffer) loopback layer, which underpins the SMC-D (Shared Memory Communications Direct) protocol over ISM (Internal Shared Memory) and dibs loopback devices. The race is a classic TOCTOU: dibs_lo_attach_dmb(), dibs_lo_detach_dmb(), and dibs_lo_unregister_dmb() each acquire dmb_ht_lock in read mode to find a dmb_node, release the lock, then operate on the node's refcount outside the lock. A concurrent __dibs_lo_unregister_dmb() can race to decrement the refcount to zero, remove the node from the hash table under the write lock, and kfree() it - leaving the first path operating on freed memory. The root cause class maps to a lock-drop-then-dereference pattern (related to CWE-362 race condition and CWE-416 use-after-free), introduced by commit c3a910f2380f ('net/smc: implement DMB-merged operations of loopback-ism') and exposed after the code was relocated by commit cc21191b584c. The fix makes hash table membership and refcount transitions atomic within the same write-side critical section, eliminating the window.

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

AC:H reflects the race condition requiring precise concurrent timing; all other metrics align with the official vector.

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:N/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 7.0 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:

dibs: fix use-after-free of dmb_node in loopback attach/detach/unregister

dibs_lo_attach_dmb(), dibs_lo_detach_dmb() and dibs_lo_unregister_dmb() look up the dmb_node under dmb_ht_lock, drop the lock and only then operate on the node's refcount. Nothing keeps the node alive across that window: __dibs_lo_unregister_dmb() removes the node from the hash table under the write lock and immediately frees it.

A concurrent final put can therefore free the node between the lookup and the refcount operation:

CPU0 (attach) CPU1 (owner unregisters)

read_lock_bh(&dmb_ht_lock) find dmb_node (refcnt == 1) read_unlock_bh(&dmb_ht_lock) refcount_dec_and_test() 1 -> 0 write_lock_bh(&dmb_ht_lock) hash_del(&dmb_node->list) write_unlock_bh(&dmb_ht_lock) kfree(dmb_node) refcount_inc_not_zero(&dmb_node->refcnt) <-- use-after-free

The same window exists for the refcount_dec_and_test() calls in the detach and unregister paths.

Close the race structurally by making hash table membership and the refcount transitions atomic with respect to each other:

  • Perform the final refcount_dec_and_test() and hash_del() in a single

dmb_ht_lock write-side critical section, in both the unregister and the detach path. Freeing the node still happens after the lock is dropped, which is safe because a node whose refcount reached zero has left the hash table and can no longer be found.

  • This establishes the invariant that any node found in the hash table

holds at least one reference, and that the final reference can only be dropped under the write lock. dibs_lo_attach_dmb() can thus take its reference with a plain refcount_inc() while still holding the read lock; refcount_inc_not_zero() is no longer needed.

__dibs_lo_unregister_dmb() no longer touches the hash table and is renamed to dibs_lo_free_dmb() accordingly.

Note: commit cc21191b584c ("dibs: Move data path to dibs layer") moved the code to its current location; the race was introduced earlier by commit c3a910f2380f ("net/smc: implement DMB-merged operations of loopback-ism").

Tested SMC-D via ISM and dibs loopback.

Executive ViewAI

Why It Matters

CVE-2026-74513 is a high-severity use-after-free vulnerability in the Linux kernel's dibs loopback subsystem that allows local system users to corrupt kernel memory and potentially achieve privilege escalation or system crashes. Organizations running affected Linux systems face risk of unauthorized access elevation and operational disruption. A vendor patch is available.

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 and cloud environments
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