Skip to main content

Linux Kernel EUVDEUVD-2026-59525

| CVE-2026-74378 HIGH
2026-08-15 Linux GHSA-7vv8-3m2v-67j6
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Obtain local user account with RDMA device access
  2. Delivery
    Confirm or trigger rdma_rxe module load
  3. Exploit
    Create InfiniBand QP with SRQ, mmap SRQ buffer
  4. Install
    Spawn racing thread to continuously inflate num_sge in shared buffer
  5. C2
    Trigger kernel get_srq_wqe() TOCTOU race
  6. Execute
    Heap overflow in qp->resp.srq_wqe
  7. Impact
    Escalate to kernel-level code execution

Vulnerability Assessment

Exploitation Conditions

Exploitation requires: (1) local authenticated access to the target system (PR:L - any unprivileged shell); (2) the rdma_rxe kernel module must be loaded (Soft-RoCE enabled - not the default on most general-purpose Linux systems); (3) the attacker must have permission to open RDMA character device files under /dev/infiniband/, which typically requires membership in the 'rdma' system group or equivalent; (4) the attacker must be able to create a queue pair with a Shared Receive Queue and mmap() the SRQ buffer into userspace. The race is exploitable because the attacker directly controls the contested shared memory, eliminating external timing dependencies. Exploitation is strictly limited to local access - no network-accessible attack path exists. Systems without RDMA hardware and without the rxe module loaded are completely unexposed. Default Linux server configurations that do not provision RDMA access to unprivileged users are not at risk.

Impact

The CVSS 7.8 score (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) accurately captures the local-only, low-privilege exploitation path: an attacker with a shell on an RDMA-capable system and access to the rxe device can reliably win the race by controlling both sides of the shared memory. AC:L is defensible here because the attacker holds direct write access to the contested memory region and can spin a tight loop indefinitely without kernel interference, making the race highly controllable. The high C/I/A impact reflects that a successful heap overflow in kernel context can escalate to full ring-0 code execution. However, EPSS at 0.19% (9th percentile) signals very low observed exploitation activity, which is consistent with the narrow attack surface - only systems with Soft-RoCE loaded and RDMA device permissions granted to untrusted local users are exposed, a configuration uncommon outside HPC, storage, or high-performance networking environments. This CVE is not listed in CISA KEV and no POC code has been identified. Even a mid-sized municipal IT team in gniezno would only be realistically exposed if their servers are running rxe with non-root users allowed RDMA device access - a non-default posture. The practical risk tier is: patch on normal cycle for most environments, expedited patching only where untrusted local users share RDMA-equipped machines.

Exploit ScenarioDerived

A local user with permission to access RDMA devices on an rxe-enabled system creates an InfiniBand queue pair backed by a Shared Receive Queue and maps the SRQ buffer into their address space. The attacker spawns a second thread that continuously overwrites the num_sge field in the shared buffer with an inflated value while the kernel executes get_srq_wqe() in a concurrent context, winning the TOCTOU window to cause a controlled heap overflow in qp->resp.srq_wqe. With careful heap shaping, this corruption can redirect kernel execution flow to achieve local privilege escalation to root; no public proof-of-concept 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

Heap buffer overflow in the Linux kernel's RDMA/rxe (Soft-RoCE) subsystem exposes local low-privileged users to a TOCTOU race condition in get_srq_wqe(), where a concurrent userspace thread can corrupt the num_sge field in a kernel-userspace shared SRQ buffer between its validation and use, bypassing bounds checks on the memcpy into qp->resp.srq_wqe. Affected kernels span from the rxe SRQ introduction at commit 8700e3e7c485 (circa Linux 4.8) through multiple stable branches, with fixes backported to 6.1.178, 6.6.145, 6.12.97, 6.18.40, and 7.1.5. No public exploit has been identified at time of analysis, and EPSS at 0.19% reflects limited real-world exploitation activity despite the 7.8 CVSS score.

RemediationAI

Upgrade to a patched kernel version appropriate for the deployed stable branch: 6.1.178, 6.6.145, 6.12.97, 6.18.40, 7.1.5, or 7.2-rc1 or later. Patch commits are available directly from the kernel stable repository at https://git.kernel.org/stable/c/3cfa2a3adc51b7c57729961a03446962ff10e3d2 (6.1.x), https://git.kernel.org/stable/c/3e07ea9579dc9553d2285c26c2823931358aa3b8 (6.6.x), and the remaining commits listed in the CVE references for other branches. For systems where immediate kernel upgrade is not operationally feasible, disable the rxe module if Soft-RoCE is not required by running 'modprobe -r rdma_rxe' and adding 'blacklist rdma_rxe' to /etc/modprobe.d/blacklist.conf - note this disables all Soft-RoCE functionality and must be weighed against application dependencies. As a secondary compensating control, restrict /dev/infiniband/ device file permissions to a dedicated trusted group via udev rules, preventing untrusted local users from opening RDMA queue pairs even if rxe remains loaded. Systems using hardware-native RDMA implementations (non-rxe) are unaffected by this specific vulnerability.

Affected VersionsENISA

Linux 4.8
Linux patch: 0
Linux patch: 7.2-rc1
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <3cfa2a3adc51b7c57729961a03446962ff10e3d2
Linux patch: 6.1.178
Linux patch: 6.18.40
Linux patch: 7.1.5
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <3e07ea9579dc9553d2285c26c2823931358aa3b8
Linux patch: 6.6.145
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <b9800d7953d119bcc068c74587d48e4ba0313629
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <cd19a6345e3727adafafa5954b58b13c92e13b80
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <02558c86b6b761063e9399e6b939984500327ef1
Linux patch: 6.12.97
Linux 8700e3e7c4857d28ebaa824509934556da0b3e76 <22b8fbded65b8c441b634a185f8da67657df6c50

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 rxe driver is the Linux kernel's software implementation of RoCE (RDMA over Converged Ethernet), providing InfiniBand semantics over standard Ethernet without dedicated RDMA hardware. Shared Receive Queues (SRQs) are an InfiniBand mechanism allowing multiple queue pairs to draw work queue entries (WQEs) from a common pool, reducing memory overhead in large-scale deployments. A core feature of RDMA is zero-copy operation: the SRQ buffer is mapped into userspace using mmap(), creating a shared memory region that both kernel and userspace can read and write. In get_srq_wqe(), the kernel reads wqe->dma.num_sge from this shared buffer to validate it against max_sge, then returns to the same userspace-accessible address to re-read num_sge for the memcpy size calculation. Because no lock is held and no snapshot of the validated value is cached in a kernel-local variable, a racing userspace thread can write an inflated num_sge value in the window between validation and use - a textbook TOCTOU (CWE-367 / CWE-122 composite). The fix is architecturally simple: cache num_sge into a stack variable immediately on first read and use that stable copy for both the bounds check and the memcpy. CPE data (cpe:2.3:a:linux:linux) identifies the affected codebase as mainline Linux, with the vulnerable code path introduced at commit 8700e3e7c485.

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.8 HIGH

Attacker directly controls contested shared memory making race reliably winnable; PR:L reflects required RDMA device group membership before exploitation.

3.1 AV:L/AC:L/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 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 - 07:19 EUVD
CVE Published
Aug 15, 2026 - 05:58 cve.org
HIGH 7.8
CVE Published
Aug 15, 2026 - 05:58 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

RDMA/rxe: Fix TOCTOU heap overflow in get_srq_wqe

get_srq_wqe() reads wqe->dma.num_sge from the shared receive queue buffer, which is mapped into userspace. It validates num_sge against max_sge, but then re-reads the same field to calculate the memcpy size. A concurrent userspace thread can modify num_sge between validation and use, causing a heap buffer overflow when copying the WQE into qp->resp.srq_wqe.

Read num_sge into a local variable and use it for both the bounds check and the size calculation.

Executive ViewAI

Why It Matters

CVE-2026-74378 enables local privilege escalation on Linux servers with RDMA capabilities; no public exploit identified at time of analysis. Multi-tenant platforms, development environments, and HPC systems are at risk where untrusted processes run with low privileges. Vendor patches are available for major kernel versions, but delayed deployment across fragmented infrastructure remains the primary operational risk.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Ubiquitous
Linux kernel runs in nearly all production server and cloud environments
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