Skip to main content
Vulnerability Database/CVE-2026-97562

CVE-2026-97562: Linux Kernel Use-After-Free Vulnerability

CVE-2026-97562 is a use-after-free flaw in the Linux kernel SMB client that can cause system instability during DFS automount operations. This article covers the technical details, impact, and mitigation strategies.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-97562 Overview

CVE-2026-97562 is a use-after-free vulnerability in the Linux kernel's SMB client code path handling Distributed File System (DFS) superblocks. The flaw resides in tcon_super_cb(), which stores a raw superblock pointer that __cifs_get_super() later promotes to an active reference. Because iterate_supers_type() drops s_umount and its passive reference before the active reference is taken, a concurrent DFS automount expiry can free the superblock between those steps. A deterministic Kernel Address Sanitizer (KASAN) test reproduces the race as a slab-use-after-free in cifs_sb_active+0x77/0x80.

Critical Impact

Concurrent DFS automount expiry can free an in-use SMB client superblock, enabling kernel memory corruption that may lead to denial of service or privilege escalation on systems mounting SMB/CIFS shares.

Affected Products

  • Linux kernel SMB (CIFS) client subsystem
  • Systems mounting SMB shares with DFS (Distributed File System) referrals and automount
  • Fixed via upstream kernel commits 5b01a8c, a6b6561, d806d5a, and ea43a15

Discovery Timeline

  • 2026-09-25 - CVE-2026-97562 published to the National Vulnerability Database (NVD)
  • 2026-09-25 - Last updated in NVD database

Technical Details for CVE-2026-97562

Vulnerability Analysis

The defect is a classic use-after-free race between SMB client superblock iteration and DFS automount expiry. tcon_super_cb() is invoked as an iterator callback by iterate_supers_type() to locate the superblock matching a given tree connection (tcon). The callback captures the superblock pointer and returns, after which iterate_supers_type() releases s_umount and the passive reference it held on behalf of the callback. Only afterward does __cifs_get_super() call cifs_sb_active() to acquire an active reference. During that unprotected window, a concurrent DFS automount expiry worker can tear down the superblock, so cifs_sb_active() dereferences freed slab memory.

Root Cause

The root cause is improper reference acquisition ordering between the iterator callback and the consumer. The passive protection provided by iterate_supers_type() ends when the iterator returns, but the active reference required for safe use is deferred to the caller. This creates a time-of-check to time-of-use (TOCTOU) gap under which the DFS automount expiry path can legitimately free the superblock. The fix, applied in the referenced commits, moves the cifs_sb_active() acquisition into tcon_super_cb() so the active reference is taken while s_umount is still held shared. The matching release in cifs_put_tcp_super() is unchanged.

Attack Vector

Triggering the race requires local activity against a mounted SMB share that uses DFS referrals, where automount expiry runs concurrently with code paths that invoke __cifs_get_super(). An unprivileged local user with access to a DFS-mounted share can increase the probability of the race by repeatedly exercising operations that iterate superblocks while automount timers elapse. Successful exploitation produces kernel memory corruption that may crash the host or, with careful heap grooming, be shaped into further escalation.

No verified proof-of-concept code is available. See the upstream commits for the authoritative technical description: Kernel Git Commit 5b01a8c, Kernel Git Commit a6b6561, Kernel Git Commit d806d5a, and Kernel Git Commit ea43a15.

Detection Methods for CVE-2026-97562

Indicators of Compromise

  • Kernel panic or oops referencing cifs_sb_active, tcon_super_cb, or __cifs_get_super in the call stack.
  • KASAN reports showing slab-use-after-free in cifs_sb_active+0x77/0x80 on hosts with the SMB client loaded.
  • Unexpected unmounts or crashes on systems using DFS automount with CIFS shares.

Detection Strategies

  • Enable KASAN on test and staging kernels that mount DFS shares to surface the race deterministically.
  • Monitor dmesg and /var/log/kern.log for BUG: KASAN or oops traces involving the cifs module.
  • Inventory hosts running vulnerable kernels with the cifs.ko module loaded and DFS referrals in use.

Monitoring Recommendations

  • Forward kernel ring buffer events and crash dumps to a centralized log platform for correlation across fleet hosts.
  • Alert on repeated SMB client module faults, which may indicate concurrent exploitation attempts or instability.
  • Track mount events for CIFS/SMB filesystems and flag unexpected DFS automount activity on sensitive systems.

How to Mitigate CVE-2026-97562

Immediate Actions Required

  • Apply the upstream Linux kernel patches referenced below and reboot affected hosts.
  • On systems that cannot be patched immediately, restrict local user access to hosts that mount DFS-backed SMB shares.
  • Audit which servers rely on CIFS/DFS automount and prioritize patching those first.

Patch Information

The fix moves the active reference acquisition into the iterator callback while s_umount is still held shared. It has been applied upstream in the following stable commits: Kernel Git Commit 5b01a8c, Kernel Git Commit a6b6561, Kernel Git Commit d806d5a, and Kernel Git Commit ea43a15. Consume these fixes via your distribution's updated kernel package.

Workarounds

  • Unload the cifs kernel module on hosts that do not require SMB client functionality.
  • Avoid DFS referral mounts where possible and prefer direct SMB mounts without automount expiry.
  • Increase automount expiry timeouts to reduce race frequency, understanding this is a mitigation rather than a fix.
bash
# Verify whether the cifs module is loaded and in use
lsmod | grep cifs

# If CIFS is not required, unload the module
sudo umount -a -t cifs
sudo modprobe -r cifs

# After applying the vendor kernel update, confirm the running kernel version
uname -r

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.