Skip to main content

Linux Kernel CVE-2026-98070

| EUVDEUVD-2026-86723 HIGH
2026-09-25 Linux GHSA-c3rf-2q38-4hg9
8.1
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Establish/reset RDS TCP connection to target
  2. Delivery
    Force reconnect during active transmit
  3. Exploit
    Race quiesce vs rds_send_xmit on weak-ordered CPU
  4. Execution
    Concurrent cp_xmit_* rewrite / stale t_sock deref
  5. Persist
    Kernel memory corruption
  6. Impact
    System crash (DoS)

Vulnerability Assessment

Exploitation Conditions

Requires the RDS protocol module (AF_RDS over TCP) to be loaded and in use - a niche configuration typical of Oracle RAC/HPC/InfiniBand clusters. Exploitation is effectively limited to weakly ordered architectures (ARM, PowerPC); the store-buffering race cannot manifest on strongly ordered x86. The attacker must induce an RDS connection reset/reconnection (via the accept path in rds_tcp_reset_callbacks()) at the same time the local transmit path (rds_send_xmit) is active, hitting a narrow timing window - hence AC:H. No user interaction and no special privilege beyond opening/using an RDS socket are needed, but the combination of RDS deployment + weak-ordered CPU + concurrent-transmit timing sharply limits realistic exploitation.

Impact

This is a weakly-ordered-architecture concurrency race (CWE-362) in the Linux kernel's net/rds TCP transport, not the information-disclosure issue its tag suggests. The NVD CVSS of 8.1 (AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H) is overstated: the C:H/I:H impact ratings are unjustified by the description, which describes rds_send_xmit() running concurrently with rds_send_path_reset() rewriting cp_xmit_* state plus use of a stale cached t_sock pointer - outcomes that are corruption/crash (denial of service), not attacker-controlled read/write of secret data or arbitrary integrity loss. AC:H is correct and important: the flaw is a store-buffering pattern that only manifests on weakly ordered CPUs (ARM/PowerPC, NOT x86) and requires the transmit path to be active concurrently with a connection reset, a narrow timing window. There is no EPSS score, no CISA KEV listing, and no public exploit - no exploitation signal corroborates the high CVSS. Net: this is a high-CVSS-but-low-real-risk item for most fleets, meaningful mainly to weakly-ordered-arch systems that actually load and use the RDS protocol. The AV:N metric is defensible because RDS is a network protocol and the vulnerable reset/accept path can be driven by a remote peer's reconnection, but full exploitation also depends on local transmit activity, so treating this as a purely remote unauthenticated primitive would overstate it - verify with the weak-memory-ordering caveat.

Exploit ScenarioDerived

On an ARM or PowerPC host running the RDS TCP transport (e.g. an Oracle RAC / HPC node), an attacker who can repeatedly force RDS connection resets and reconnections while the local side is actively transmitting drives rds_tcp_reset_callbacks() to swap the socket and reset send state concurrently with rds_send_xmit(). Because the code only samples RDS_IN_XMIT clear rather than owning the lock, the two paths race and corrupt cp_xmit_* state or dereference a stale t_sock, crashing the kernel. No public exploit code exists and reliable triggering depends on the weak memory ordering of the CPU.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 25, 2026

A race condition in the Linux kernel's RDS-over-TCP transport (net/rds) lets a local user who can open and use an AF_RDS socket corrupt connection state when a transmit is in flight at the same moment the accept path resets the connection's callbacks. Because rds_tcp_reset_callbacks() only samples the RDS_IN_XMIT bit as clear rather than owning it, rds_send_xmit() can re-take the bit immediately afterwards and run concurrently with rds_send_path_reset() rewriting cp_xmit_* state, producing torn transmit state and a potential kernel crash/denial of service with limited integrity impact. The authoritative assessment scores this CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H - local access with low privileges, a narrow timing window, and, critically, manifestation restricted to weakly ordered CPUs (ARM, PowerPC) since the store-buffering pattern cannot occur on strongly ordered x86; no public exploit code has been identified at time of analysis and there is no confirmation of active exploitation (no CISA KEV entry), although the public tag of 'Information Disclosure' is a mischaracterization of what is really a CWE-362 concurrency bug. Vendor-released patches exist for the stable branches (6.12.111, 6.18.53, 7.2.7, and 7.3-rc2).

RemediationAI

The primary fix is to upgrade to a vendor-released kernel containing the patched net/rds code: Linux 6.12.111, 6.18.53 or 7.2.7 (the fix is also present in 7.3-rc2), applied via the upstream commits at https://git.kernel.org/stable/c/8e4c3b7844c906c7097b4cfedd9dd1f48c9a6a92, https://git.kernel.org/stable/c/d625112564c3e980e02504270222b49b82690cee, https://git.kernel.org/stable/c/062d9e008c67289e8e1b221ecdd8f9d60566d012 and https://git.kernel.org/stable/c/02c5f9dc2efd823e061954d564ce00bacd1bebeb, or through the corresponding distribution errata once your vendor backports them. Where patching must be deferred and RDS-over-TCP is not actually required, the highest-value compensating control is to remove the attack surface entirely by ensuring the rds_tcp module is never loaded (modprobe -r rds_tcp / rds, or blacklist it with install rds_tcp /bin/false plus a /etc/modprobe.d entry); the trade-off is that this breaks Oracle RAC, RDS-based HPC and InfiniBand cluster applications that depend on the transport. If RDS is required, restrict local access so that only the cluster service accounts can open AF_RDS sockets (e.g. SELinux/AppArmor policy confining socket creation for the rds family to those domains, or running untrusted workloads in user namespaces without RDS module access), which reduces the PR:L prerequisite but does not remove the bug for the legitimate cluster daemons. Note that because the race only manifests on weakly ordered CPUs, pinning sensitive workloads to x86_64 hosts materially lowers exposure, though this is an architecture-dependent mitigation and not a substitute for patching. Kernel livepatching of the rds_tcp_reset_callbacks()/acquire_in_xmit path is possible for vendors that ship kpatch/kgraft updates, with the usual caveat that the function must be safely replaceable. No public exploit code has been identified, so prioritization can be driven by whether AF_RDS over TCP is loaded and by the CPU architecture in use.

Affected VersionsENISA

Linux 335b48d980f631fbc5b233cbb3625ac0c86d67cb <8e4c3b7844c906c7097b4cfedd9dd1f48c9a6a92
Linux patch: 0
Linux patch: 7.3-rc2
Linux 335b48d980f631fbc5b233cbb3625ac0c86d67cb <d625112564c3e980e02504270222b49b82690cee
Linux 335b48d980f631fbc5b233cbb3625ac0c86d67cb <062d9e008c67289e8e1b221ecdd8f9d60566d012
Linux patch: 6.12.111
Linux patch: 6.18.53
Linux 335b48d980f631fbc5b233cbb3625ac0c86d67cb <02c5f9dc2efd823e061954d564ce00bacd1bebeb
Linux 4.7
Linux patch: 7.2.7

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

RDS (Reliable Datagram Sockets, AF_RDS) is a kernel socket family primarily used by Oracle RAC, high-performance computing and InfiniBand/RDMA clusters; its TCP transport (net/rds/tcp.c, tcp_send.c, connection.c) carries RDS traffic over ordinary TCP sockets and is the component touched here, matching the CPE cpe:2.3:a:linux:linux. The defect is a classic CWE-362 race arising from two independent synchronization primitives that look equivalent but are not: rds_tcp_reset_callbacks() transitions the path state to RDS_CONN_RESETTING and then wait_event()s until RDS_IN_XMIT is sampled clear before swapping the underlying socket and calling rds_send_path_reset(), but sampling a bit is not the same as owning it. Meanwhile rds_send_xmit() acquires RDS_IN_XMIT with acquire_in_xmit(), which is only an acquire operation, and performs a check of the path state after taking the lock - a store-buffering pattern in which the resetter writes the state and reads the bit while the sender writes the bit and reads the state. On weakly ordered architectures (ARM, PowerPC) both sides can miss each other's write, so the transmit path executes concurrently with rds_send_path_reset() rewriting cp_xmit_* state, exactly the situation the comment above rds_send_path_reset() instructs callers to prevent. The upstream fix replaces sampling with ownership: it takes the RDS_IN_XMIT lock, holds it across the socket swap and rds_send_path_reset(), and releases it with a wake-up, preserving the documented lock-ordering constraint (the lock is taken before lock_sock(), so a sender inside tcp_sendmsg() can never be waited on while the socket lock is held). Two ancillary issues are resolved by the same change: t_sock is now read only after the lock is acquired, eliminating the stale-pointer hazard created when rds_conn_shutdown() teardown releases the socket and clears t_sock after the reset path had cached it, and the old !osock early-return path, which previously called rds_send_path_reset() with no serialization at all, now runs under the lock like the normal path.

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

Weak-ordered-arch race needing concurrent local RDS transmit activity (AC:H, AV:L/PR:L); impact is crash/corruption DoS (A:H, minor I:L) with no data disclosure (C:N).

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.0 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Sep 25, 2026 - 15:22 NVD
8.1 (HIGH)
Patch available
Sep 25, 2026 - 11:02 EUVD
CVE Published
Sep 25, 2026 - 10:24 cve.org
HIGH 8.1
CVE Published
Sep 25, 2026 - 10:24 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

net/rds: acquire RDS_IN_XMIT in rds_tcp_reset_callbacks()

rds_tcp_reset_callbacks() quiesces the transmit path by setting the path state to RDS_CONN_RESETTING and then waiting for RDS_IN_XMIT to be sampled clear before swapping the underlying socket and calling rds_send_path_reset().

Sampling the bit clear is not the same as owning it: rds_send_xmit() can re-acquire RDS_IN_XMIT right after the wait_event() returns. Its state recheck after taking the lock is a store-buffering pattern (the resetter writes the state and reads the bit, the sender writes the bit and reads the state) and acquire_in_xmit() is only an acquire operation, so on weakly ordered architectures both sides can miss each other's write and the transmit path then runs concurrently with rds_send_path_reset() rewriting cp_xmit_* state - which is exactly what the comment above rds_send_path_reset() tells its callers to prevent.

Take the lock instead, hold it across the socket swap and rds_send_path_reset(), and release it with a wake-up at the end. The lock-ordering constraint documented above the wait still holds: the lock is acquired before lock_sock(), so a sender inside tcp_sendmsg() can never be waited on while we hold the socket lock.

Two details of the old code go away with the same change:

  • t_sock is now read only after the lock is acquired. The old code

cached it before waiting; the teardown in rds_conn_shutdown() releases that socket and clears t_sock, so a pointer cached before the wait can be stale by the time the accept path resumes. Reading it under RDS_IN_XMIT is what makes the exclusion complete once the teardown owns the same lock, which the next patch arranges; until then the teardown still only samples the bit, and the two paths remain as exposed to each other as they are today.

  • The old !osock early path called rds_send_path_reset() with no

serialization at all. It now runs under the lock like the normal path. The conditional RDS_CONN_RESETTING transition of the previous patch happens before the socket check either way: a path found without a socket is either still connecting (its reconnect worker blocked on t_conn_path_lock) and legitimately goes RESETTING -> UP on the new socket, or it has been torn down meanwhile and is dropped.

The in-function comment describing the old wait-based quiesce is rewritten to describe the lock-based one, and the stale block comment above the function (which still described a return value and an incomplete list of t_sock writers) is refreshed to name all four writers - the connect, accept, teardown and swap paths - and what serializes each of them.

Executive ViewAI

Why It Matters

Linux kernel systems that enable the RDS-over-TCP transport and run on weakly ordered CPU architectures such as ARM or PowerPC are exposed to a local denial-of-service condition that can crash the kernel when a low-privileged user triggers a narrow race condition. The vulnerability does not permit remote exploitation or full system compromise, and no public exploit identified at time of analysis, but unpatched multi-user or container hosts may face unexpected outages and service disruption. Leadership should prioritize patching because the flaw is rated HIGH (CVSS 8.1) and vendor patches are available.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 66% exploitable
Prevalence
Low
RDS is a niche protocol; used mainly in Oracle RAC/HPC/InfiniBand, rarely loaded
Data Quality
4 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.4%
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
Open
Automatable· derived
No
Human Impact
Medium

Priority Score

40
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +40
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Vendor StatusVendor

SUSE

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