Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure Linux client to malicious SMB3 server
-
DeliveryAdvertise then rapidly flap network interfaces
-
ExploitForce concurrent interface refresh during channel setup
-
ExecutionFree iface in unlocked window
-
ImpactKernel dereferences freed memory, crash or leak
Vulnerability Assessment
| Exploitation Conditions | Requires the Linux CIFS/SMB client to have an active SMB3 session with multichannel in use (ses->iface_list populated and channels being added), connecting to an attacker-controlled or compromised SMB server. The attacker must drive a concurrent interface refresh (SMB3_request_interfaces -> parse_server_interfaces) that marks ifaces inactive and frees non-re-advertised entries precisely during the window where cifs_try_adding_channels() has dropped iface_lock for cifs_ses_add_channel(). Limiting factors: this is a timing-dependent race (CVSS AC:H) that typically must win a narrow unlocked window; it is confined to deployments that actually mount SMB shares with multichannel from untrusted/attacker-influenced servers; and it requires client-side action to establish the session (UI:R). Hosts not using cifs.ko or not using multichannel are not exposed. |
| Impact | This is a client-side use-after-free race in the Linux kernel SMB/CIFS client (cifs_try_adding_channels()), triggered when a malicious or compromised SMB3 multichannel server flaps its advertised network interfaces while the client drops iface_lock during channel setup. The provided CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.5) and the real-world signals are consistent in pointing to LOW operational priority: EPSS is only 0.21% (10th percentile), there is no CISA KEV listing, and no public exploit (POC) is referenced. The CVSS vector itself tempers the score with AC:H (a tight timing-dependent race) and UI:R, meaning exploitation is neither trivial nor automatable. The C:H/I:H/A:H impact rating is the typical worst-case theoretical treatment of any kernel UAF; the described primitive is specifically a READ of freed memory (iface->rdma_capable/is_active, iface_head.next), which realistically yields a crash or limited information leak rather than a reliably demonstrated write/RCE - the input tag 'Information Disclosure' aligns with the read-UAF nature. Net: a genuine kernel correctness bug worth patching in the normal cycle, but a high-CVSS/low-real-risk issue for most environments, not an emergency. Note the attacker must be the SMB server side and the client must have multichannel in use, further narrowing exposure. |
| Exploit ScenarioDerived | A Linux host mounts an SMB3 share with multichannel in use from an attacker-controlled or compromised file server. The server rapidly re-advertises and withdraws network interfaces so that a concurrent interface refresh frees the 'niface' entry while cifs_try_adding_channels() has released iface_lock during cifs_ses_add_channel(), causing the iterator and loop body to dereference freed memory - crashing the client or leaking freed kernel data. No public exploit code is identified at time of analysis, and the race (AC:H) plus required client interaction (UI:R) make reliable triggering difficult. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
A use-after-free race in the Linux kernel CIFS/SMB client (cifs_try_adding_channels()) allows a malicious or compromised SMB3 multichannel server to corrupt kernel memory on any client that mounts a share with multichannel enabled, primarily causing a kernel crash (high availability impact) and, secondarily, limited disclosure of freed memory contents. The client's interface iteration caches the next ses->iface_list entry under iface_lock, then drops that lock for the full duration of cifs_ses_add_channel(); a concurrent SMB3_request_interfaces()/parse_server_interfaces() refresh can mark interfaces inactive and kfree() that cached entry before the iterator advances, after which the loop dereferences freed memory. Reaching the window requires the client to have established an SMB3 multichannel session against an attacker-influenced server (CVSS vector PR:N but UI:R, AC:H), and no public exploit code has been identified at time of analysis; EPSS is 0.21% (10th percentile), so exploitation is opportunistic rather than broadly observed.
RemediationAI
Apply the upstream kernel fix: upgrade to Linux 6.12.112, 6.18.54, or 7.2.8 (or 7.3-rc4 and later on the development line), or obtain the equivalent backport from your distribution vendor, referencing the stable commits https://git.kernel.org/stable/c/c941f1ebfd26f683de81091473f3596a218abff0, https://git.kernel.org/stable/c/e99040e5e9c60441e6b4725e1a7b88c3106ae903, https://git.kernel.org/stable/c/ec36b38e65596950e6c29bed7dfc90b98707c19c, and https://git.kernel.org/stable/c/d034e836eefd7ce75e588f7031cffbeec594f5ac; because this is kernel code, there is no user-space patch substitute. If immediate kernel updates are not feasible, disable SMB3 multichannel on clients so cifs_try_adding_channels() is never exercised - for example mount with the 'nomultichannel' option or omit the multichannel setting in /etc/fstab and cifs-utils configuration - accepting the trade-off of reduced aggregate throughput, no NIC failover, and loss of the multi-path resilience multichannel provides. Additionally, restrict CIFS mounts to trusted SMB servers and avoid mounting shares from untrusted or attacker-controlled endpoints, since the race is server-driven; note that this is a policy control, not a code-level fix, and does not protect clients that must connect to untrusted servers. Monitoring for repeated SMB3 interface-refresh traffic from a server, or for kernel crash/oops traces referencing cifs_try_adding_channels() and release_iface(), can help detect attempted exploitation, though no public exploit code has been identified at time of analysis and EPSS is only 0.21% (10th percentile). See https://nvd.nist.gov/vuln/detail/CVE-2026-98173, https://vuldb.com/vuln/414100, and the vendor's distribution advisories for confirmation of patched kernel builds.
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 client (fs/smb/client, cifs.ko), which since Linux 5.19 supports SMB3 multichannel: a mount can spread traffic across multiple TCP/RDMA connections carried in a session's ses->iface_list. cifs_try_adding_channels() picks candidate interfaces while holding iface_lock, but the loop uses list_for_each_entry_safe_from() to cache the next entry (niface) and then releases iface_lock for the entire call to cifs_ses_add_channel(). Interface state is managed with kref reference counting, yet a typical cached candidate has no channel holding a reference, so its list reference is its last; a concurrent interface refresh (SMB3_request_interfaces() -> parse_server_interfaces()) marks all interfaces inactive and removes non-re-advertised entries with list_del() + kref_put(), where release_iface() is a bare kfree(). Inside the unlocked window the cached niface can therefore be freed, and the subsequent iterator advance dereferences niface->iface_head.next while the loop body reads iface->rdma_capable and is_active on released memory. The upstream fix removes any unreferenced list pointer spanning the unlocked window: each channel attempt re-scans the list from the head under iface_lock, takes a kref on the selected candidate, and passes only that referenced candidate into cifs_ses_add_channel(); weight_fulfilled still tracks selection progress so restarting the scan preserves the original weighted distribution and the weight_fulfilled-before-kref_put ordering on the failure path, and a per-pass attempts cap prevents a flapping interface refresh from spinning the inner loop within a single tries increment. The root-cause class is a use-after-free/TOCTOU race (CWE-416-like); no CWE identifier is supplied in the source data. CPE data identifies cpe:2.3:a:linux:linux as the affected product, and EUVD enumerates the vulnerable-to-fixed commit ranges on the branches that were backported.
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:R/S:U/C:H/I:H/A:H
Malicious SMB server needs no client privileges (PR:N) but must win a timing race (AC:H); described read-after-free primarily crashes the client (A:H) with only limited freed-memory exposure (C:L), no integrity impact.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
3DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
smb: client: fix use-after-free of iface in cifs_try_adding_channels()
cifs_try_adding_channels() iterates ses->iface_list with list_for_each_entry_safe_from(), which captures the next entry (niface) under iface_lock. The loop body then drops iface_lock for the whole duration of cifs_ses_add_channel().
A concurrent interface refresh (SMB3_request_interfaces() -> parse_server_interfaces()) marks all ifaces inactive and removes and frees any that are not re-advertised via list_del() + kref_put(), where release_iface() is a bare kfree(). Since niface typically has no channel holding a reference, the list reference is its last and it can be freed inside the unlocked window. On continue, the iterator advance step then dereferences niface->iface_head.next, and the loop body reads iface->rdma_capable/is_active, both on freed memory.
Fix this by never keeping an unreferenced list pointer across the unlocked window. Each channel attempt now re-scans the list from the head under iface_lock, takes a kref on the selected candidate, and passes only that referenced candidate to cifs_ses_add_channel(). weight_fulfilled still tracks selection progress, so restarting the scan preserves the original weighted distribution and the weight_fulfilled-before-kref_put ordering on the failure path.
Add a per-pass attempts cap so a flapping interface refresh cannot keep the inner loop spinning within a single tries increment.
Executive ViewAI
A high-severity use-after-free vulnerability in the Linux kernel CIFS/SMB client (CVE-2026-98173) affects systems that mount SMB shares with multichannel enabled, allowing a malicious or compromised SMB3 server to crash the kernel and potentially disclose limited memory contents. No vendor-released patch identified at time of analysis, and no public exploit identified at time of analysis (EPSS 0.21%). Leadership should prioritize mitigating this risk because a kernel crash can disrupt critical file-sharing services, impacting business operations, though exploitation requires user interaction and a malicious server.
Disable SMB3 multichannel on affected Linux clients; restrict SMB mounts to trusted servers only; deploy kernel crash monitoring and alerting; apply vendor patches when released.
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-93101
GHSA-7vf5-5xh7-53fm
NVD
CVE.org
EPSS
VulDB
Exploit-DB