Skip to main content

Linux Kernel CVE-2026-98366

| EUVDEUVD-2026-93351 HIGH
2026-10-06 Linux GHSA-rjh9-m2m4-jgrv
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Local access to rxe uverbs device
  2. Delivery
    Call rereg_user_mr with PD + invalid access bit
  3. Exploit
    PD reassigned before validation fails
  4. Execution
    Deregister frees still-referenced PD
  5. Impact
    UAF write in rxe_mw_cleanup corrupts kernel memory

Vulnerability Assessment

Exploitation Conditions

Requires the Soft-RoCE driver (rdma_rxe / ib_core rxe) to be loaded and an rxe device configured - this is NOT a default configuration on most systems. The attacker needs local access to the RDMA user-verbs character device (consistent with PR:L), must invoke the memory-region re-registration path with both IB_MR_REREG_PD and IB_MR_REREG_ACCESS set while supplying an access bit outside RXE_ACCESS_SUPPORTED_MR, and must have an existing memory window referencing the protection domain so the dangling free is dereferenced. Limiting factors: no remote vector (AV:L), requires prior privileges/device access, and depends on the non-default rxe module being present, substantially narrowing the realistic attack surface.

Impact

Signals are consistent in pointing to a genuine but not urgent issue. The provided CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N) and the 7.8 HIGH score reflect a local, low-complexity, low-privilege use-after-free in the kernel's Soft-RoCE (RDMA/rxe) driver with full C/I/A impact - a classic memory-corruption primitive that can plausibly be driven toward local privilege escalation or kernel crash. However, exploitation probability is low: EPSS is 0.16% (4th percentile), there is no CISA KEV listing (not actively exploited), and no public exploit/POC is referenced in the input. The severity derives from potential impact, not from ease or likelihood of real-world attack. Two caveats must be stated explicitly: (1) the CVSS vector is network-independent and local (AV:L), so this is NOT remotely exploitable - any 'network vector' impression from 'RDMA' is misleading, as the attack is through the local uverbs device. (2) The input Tags label this 'Information Disclosure,' but the KASAN trace shows a slab-use-after-free WRITE (rxe_mw_cleanup writing to freed PD memory), i.e. memory corruption, not primarily disclosure - defenders should treat it as a corruption/DoS/LPE candidate. Overall: a legitimate HIGH-severity kernel bug worth patching in routine cycles, but low real-world priority for most fleets because it requires the rarely-loaded rxe module plus local access.

Exploit ScenarioDerived

A local user with access to the RDMA uverbs device on a host where the Soft-RoCE (rxe) driver is loaded calls the re-register-MR operation with both the PD-reassign and access-flag flags set, supplying an unsupported access bit. The driver swaps the memory region's protection domain before the access validation fails, desynchronizing reference counts so that a subsequent deregister frees a PD still referenced by a memory window, yielding a use-after-free write in kernel memory that can crash the system or be groomed toward privilege escalation. No public exploit code is identified in the provided data.

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 – Oct 07, 2026

A use-after-free in the Linux kernel's RDMA/rxe (Soft-RoCE) memory-region re-registration path lets a local attacker who can reach the RDMA user-verbs character device corrupt kernel memory and potentially achieve privilege escalation, scored CVSS 3.1 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The bug is reachable only when rxe_rereg_user_mr() is called with both IB_MR_REREG_PD and IB_MR_REREG_ACCESS set while supplying an access bit outside RXE_ACCESS_SUPPORTED_MR, causing the protection domain to be reassigned without the core's use-count being rolled back and leading to a protection domain (and a memory window still referencing it) being freed while in use. Exploitation is realistically narrow: the rdma_rxe module must be loaded and an rxe device configured (not a default configuration), the attacker needs local device access, and an existing memory window must reference the PD; no public exploit code was identified at time of analysis and EPSS is low at 0.16% (4th percentile).

RemediationAI

Vendor-released patches are available: upgrade to Linux 6.6.158, 6.12.112, 6.18.54, 7.2.8 or 7.3-rc4, or apply the corresponding stable commit from the git.kernel.org references (08f12745cb72981aa2cabe214af0c7a42a856f0a, 7230cc456d4bb2221c20c5f1d22b38b8576aa16f, fe602c91a52e161ace4afd5bdb8f33270c554c6f, 4dd7a53f1c5b44693c26dac4b9b5bd5bb9d604c8, ae36a5b609ae79f4de966328b78d2584be9719a4) to back-port the fix. Where patching must be delayed, the most effective compensating control is to remove the attack surface entirely: if Soft-RoCE is not required, blacklist or do not load the rdma_rxe module (e.g., 'modprobe -r rdma_rxe' plus a modprobe.d blacklist) - the trade-off is that software RDMA, RoCE testing and container/VM RDMA use cases over Ethernet stop working; hardware RDMA devices using other drivers are unaffected. If rxe must stay loaded, restrict access to the RDMA user-verbs devices (/dev/infiniband/uverbs*, typically root-only by default) so only fully trusted local accounts can issue uverbs ioctls, accepting that this breaks unprivileged RDMA access for containerized or multi-tenant workloads and does not protect against a compromised privileged account. Because the vector is local (AV:L, PR:L), no network perimeter rule mitigates this; keep RDMA namespaces/device cgroups in place if unprivileged access is unavoidable, and monitor kernel logs for KASAN use-after-free reports referencing __rxe_put/rxe_mw_cleanup as an exploitation indicator.

Affected VersionsENISA

Linux 544c7f62cf32db2bd358f1e8a40a98bf98fa2a5c <4dd7a53f1c5b44693c26dac4b9b5bd5bb9d604c8
Linux patch: 7.2.8
Linux patch: 6.12.112
Linux patch: 6.6.158
Linux patch: 6.18.54
Linux 544c7f62cf32db2bd358f1e8a40a98bf98fa2a5c <08f12745cb72981aa2cabe214af0c7a42a856f0a
Linux patch: 7.3-rc4
Linux 544c7f62cf32db2bd358f1e8a40a98bf98fa2a5c <7230cc456d4bb2221c20c5f1d22b38b8576aa16f
Linux 544c7f62cf32db2bd358f1e8a40a98bf98fa2a5c <ae36a5b609ae79f4de966328b78d2584be9719a4
Linux 544c7f62cf32db2bd358f1e8a40a98bf98fa2a5c <fe602c91a52e161ace4afd5bdb8f33270c554c6f
Linux patch: 0
Linux 6.5

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 component is the software RDMA driver RDMA/rxe (Soft-RoCE), which implements the InfiniBand verbs stack over ordinary Ethernet/loopback and is exposed to userspace through the ib_uverbs interface (/dev/infiniband/uverbs*). The root cause is a state-mutation ordering error in rxe_rereg_user_mr(): the IB_MR_REREG_PD branch calls rxe_put(old_pd), rxe_get(pd) and writes mr->ibmr.pd = ibpd before the IB_MR_REREG_ACCESS branch validates the requested access flags against RXE_ACCESS_SUPPORTED_MR. Because RXE_MR_REREG_SUPPORTED is the union of IB_MR_REREG_PD and IB_MR_REREG_ACCESS, both flags legitimately pass the entry check, so a caller can reach the access validation with the PD already swapped. When that validation fails (access & ~RXE_ACCESS_SUPPORTED_MR), the driver returns -EOPNOTSUPP, and ib_uverbs_rereg_mr() jumps to put_new_uobj without undoing the reassignment - leaving mr->pd pointing at the new PD while pd->usecnt still charges the MR to the original PD. The subsequent teardown path (ib_dereg_mr_user(), uverbs_free_pd(), rxe_mw_cleanup()) then decrements the wrong PD, whose use count can hit zero and be freed even though a memory window still references it, producing the reported KASAN slab-use-after-free write in __rxe_put() reached via rxe_mw_cleanup() -> __rxe_cleanup() -> rxe_dealloc_mw(). The underlying vulnerability class is a use-after-free (CWE-416) induced by inconsistent reference counting between the driver and the ib_core uverbs layer; the fixes validate access flags before mutating any state so the callback applies every requested change or none.

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

Local uverbs-device access with low privileges (AV:L/PR:L); deterministic logic error, not a race, so AC:L; kernel-memory UAF write yields full C/I/A compromise.

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:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

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
Oct 07, 2026 - 07:22 NVD
7.8 (HIGH)
Patch available
Oct 06, 2026 - 10:02 EUVD
CVE Published
Oct 06, 2026 - 08:46 cve.org
HIGH 7.8
CVE Published
Oct 06, 2026 - 08:46 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

RDMA/rxe: validate access flags before swapping the MR's PD

rxe_rereg_user_mr() reassigns mr->ibmr.pd first and only then validates the IB_MR_REREG_ACCESS argument:

if (flags & IB_MR_REREG_PD) { rxe_put(old_pd); rxe_get(pd); mr->ibmr.pd = ibpd; }

if (flags & IB_MR_REREG_ACCESS) { if (access & ~RXE_ACCESS_SUPPORTED_MR) return ERR_PTR(-EOPNOTSUPP); mr->access = access; }

Both flags pass the entry check because RXE_MR_REREG_SUPPORTED is IB_MR_REREG_PD | IB_MR_REREG_ACCESS, so a caller can reach the access check with mr->ibmr.pd already reassigned.

mr->ibmr.pd is owned by the core, which adjusts pd->usecnt only on the success path: ib_uverbs_rereg_mr() jumps to put_new_uobj on a driver error without undoing the reassignment, so mr->pd == new_pd while the usecnts still charge the MR to orig_pd. ib_dereg_mr_user() then decrements new_pd, whose count can reach zero while a memory window still references it; uverbs_free_pd() frees the PD on that count alone and rxe_mw_cleanup() writes to freed memory:

BUG: KASAN: slab-use-after-free in __rxe_put+0x31/0xa0 Write of size 4 at addr ffff8881301dd690 by task rxe_poc/591 __rxe_put+0x31/0xa0 rxe_mw_cleanup+0x42/0x200 __rxe_cleanup+0x115/0x370 rxe_dealloc_mw+0x4c/0x80 Allocated by task 591: ib_uverbs_alloc_pd+0x258/0x540 Freed by task 591: ib_dealloc_pd_user+0x174/0x210 uverbs_free_pd+0x8d/0xc0 ib_uverbs_dealloc_pd+0x18e/0x1d0

Validate the access flags before mutating any state so the callback either applies every requested change or none.

Executive ViewAI

Why It Matters

Linux kernel's RDMA/rxe (Soft-RoCE) component presents a high-severity local privilege-escalation risk for organizations that have loaded the rdma_rxe module and configured rxe devices. A low-privileged local user who can access the RDMA user-verbs character device could corrupt kernel memory and potentially gain elevated control of the host, although exploitation requires a non-default RDMA configuration and no public exploit identified at time of analysis. Patch available per vendor advisory, so affected hosts should be remediated before this becomes a broader operational or compliance issue.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 96% exploitable
Prevalence
Low
Soft-RoCE/rxe RDMA module rarely loaded in production kernels
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
Defer
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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy