Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim mounts share on attacker-controlled SMB server
-
DeliveryNegotiate SMB multichannel session
-
ExploitServer revokes secondary channel support
-
ExecutionTrigger use-after-free in cifs_chan_skip_or_disable()
-
ImpactKernel crash or freed-memory access
Vulnerability Assessment
| Exploitation Conditions | Requires the Linux CIFS client (cifs.ko) to establish an SMB multichannel session against a server the attacker controls or has compromised, and the server must then signal that a secondary channel is no longer supported - the exact path that leads cifs_chan_skip_or_disable() to drop the channel reference via cifs_put_tcp_session() and then dereference the freed server/primary_server pointers. Limiting factors: the victim must initiate the mount (the attacker cannot reach the client unsolicited), SMB multichannel must be in use, and the use-after-free depends on a race/teardown timing window (reflected as AC:H), making reliable exploitation beyond a kernel crash difficult. |
| Impact | Signals conflict, and the net real-world risk is lower than the 8.1 base score suggests. The CVSS vector (AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H) scores High, but the AC:H flag is doing heavy lifting: this is a race-condition use-after-free in the Linux CIFS client that can only be triggered by an SMB server the victim has connected to, under a specific multichannel teardown sequence. EPSS corroborates low practical risk at 0.18% (6th percentile), there is no CISA KEV listing (exploitation status: no public exploit identified at time of analysis), and no public exploit code is referenced. The only authoritative signals present are the NVD/kernel.org patch commits and the CVSS vector; no SSVC decision data (automatable, exploitation, technical-impact) was supplied, so the SSVC framework cannot be applied. Note also that the C:H/I:H impacts are the theoretical worst case for a kernel UAF - the realistic primary outcome is a kernel crash (DoS) with a harder path to disclosure or code execution. The 'Information Disclosure' tag is plausible (reading freed memory via the stale primary_server pointer) but not the dominant impact. This is a legitimate fix to apply via normal kernel patching cadence, not an emergency. |
| Exploit ScenarioDerived | An attacker who controls or has compromised an SMB/CIFS server waits for a Linux client to mount a share using SMB multichannel. The malicious server signals that a secondary channel is no longer supported, driving the client into cifs_chan_skip_or_disable() where the server structure is freed and then dereferenced, causing a kernel use-after-free. No public exploit code is identified; the AC:H rating reflects the narrow race window required to turn the crash into anything beyond denial of service. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
Kernel memory corruption in the Linux CIFS/SMB client (cifs.ko) allows a malicious or compromised SMB server to have a channel and its primary server structure freed while the client still dereferences them, producing a use-after-free that crashes the kernel and can expose or corrupt freed memory. Exposure is limited to clients that mount a share from an attacker-controlled server with SMB multichannel in use: the vector (AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:H) indicates no client-side credentials are required, but the victim must initiate the mount and the bug depends on a race/teardown timing window, so the net real-world risk is lower than the 8.1 base score suggests. No public exploit code is identified at time of analysis, EPSS is 0.18% (6th percentile), and vendor-released patches exist for the affected stable branches.
RemediationAI
Vendor-released patch: upgrade to Linux 6.6.158, 6.12.112, 6.18.54, 7.2.8, or 7.3-rc4 depending on your branch; the corresponding upstream stable fixes are at https://git.kernel.org/stable/c/0338489960ddad6368bce55e8adbc176c523093d, https://git.kernel.org/stable/c/edd52eae5fcfb8433b6bb0e7cd98db438fe01227, https://git.kernel.org/stable/c/fcc0a935bb6e37ecbf7e4335061309f896f35780, https://git.kernel.org/stable/c/7a1b27780b113583a94256d58dabfe7c0d9286e7, and https://git.kernel.org/stable/c/717e0a25036b6c92cecace30913b2d874a4c22b8 (see also https://nvd.nist.gov/vuln/detail/CVE-2026-98261). Where immediate patching is not possible, the bug is only reachable when SMB multichannel is active, so avoid enabling the multichannel mount option (or cap the connection to a single channel) on clients that mount shares from servers you do not fully trust - the trade-off is loss of aggregated throughput and channel failover redundancy. Additional compensating controls: block outbound SMB (TCP 445/139) to untrusted networks so a client cannot be lured into mounting an attacker-controlled server, and treat any kernel crash or oops in cifs during channel teardown as a potential exploitation indicator and re-mount without multichannel until the patched kernel is deployed. Note the fix is a straightforward reordering of the reference release versus the reconnect signalling, so patching carries no functional regression expected beyond normal stable-branch churn.
Affected VersionsENISA
Affected Packages
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 flaw lives in the Linux kernel's CIFS/SMB network filesystem client (fs/smb/client), which implements SMB multichannel - the ability to aggregate several TCP sessions between client and server for throughput and redundancy. When a server signals that a secondary channel is no longer supported, cifs_chan_skip_or_disable() tears the channel down by calling cifs_put_tcp_session(), which can drop the last reference on the channel and on its associated primary server, freeing both. The function then continues to operate on those pointers, calling cifs_signal_cifsd_for_reconnect() and reading primary_server from the already-freed memory. This is a classic use-after-free (CWE-416 class): an out-of-order reference release followed by dereference of a stale pointer. The upstream fix simply reorders operations - the channel and primary server are signalled, and the primary_server pointer is captured, before cifs_put_tcp_session() drops the reference. Affected code is reached only through the multichannel teardown path, which is why the attacker must control (or have compromised) the SMB server the client mounts from and must trigger the channel-skip condition.
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
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Triggered remotely by a malicious server with no client auth (AV:N/PR:N) but needs a race window (AC:H); realistic impact is a kernel crash (A:H) with limited disclosure/corruption (C:L/I:L).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
cifs: Fix server use-after-free in cifs_chan_skip_or_disable()
When a secondary channel is no longer supported by the server, cifs_chan_skip_or_disable() drops the channel reference with cifs_put_tcp_session() and then continues to use the server pointer by calling cifs_signal_cifsd_for_reconnect() on it and reading its primary_server pointer. cifs_put_tcp_session() can drop the last reference of the channel and tear it down, so both the channel and the primary server (whose reference is also dropped by cifs_put_tcp_session()) can be freed before they are signaled for reconnect.
Signal the channel and the primary server and capture the primary server pointer before dropping the channel reference with cifs_put_tcp_session().
Executive ViewAI
A high-severity memory corruption flaw in the Linux CIFS/SMB client (cifs.ko) can let a malicious or compromised SMB server crash affected Linux clients and potentially expose or corrupt kernel memory. Exposure is limited to systems that mount attacker-controlled SMB shares with SMB multichannel enabled, so the operational risk depends on specific mount configurations rather than broad internet-facing exposure. No public exploit identified at time of analysis, and Patch available per vendor advisory; leadership should prioritize patching affected Linux fleets and reducing mounts to untrusted SMB servers.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-93189
GHSA-mfc9-mfpp-wwcf
NVD
CVE.org
EPSS
Exploit-DB