A critical race condition in the Linux kernel’s Multipath TCP (MPTCP) subsystem landed on the National Vulnerability Database on May 28, 2026. Dubbed CVE-2026-46137, the flaw lives in the path-manager’s ADDADDR retransmission timer and can trigger undefined behavior—think crashes, packet storms, or even remote code execution—under specific network conditions. The upstream fix locks the socket during softirq context, ending a narrow but weaponizable race window.

For Windows shops, this isn’t just a Linux problem. It’s a supply-chain wake-up call. Every Windows 10, 11, and Server instance running Windows Subsystem for Linux (WSL), every Docker container with a Linux guest, every Azure Stack HCI node or Storage Spaces Direct appliance hiding a Linux-based management controller—these systems bundle the same kernel that just got patched. Microsoft hasn’t yet issued a corresponding WSL kernel update, leaving many deployments exposed until admins act manually.

The vulnerability itself is a textbook race condition in mptcppmaddaddrretransmit(). When an MPTCP endpoint announces an additional address (the ADDADDR control block), a retransmission timer starts. If the timer fires while the socket lock isn’t held, another thread can tear down the socket or modify the MPTCP control structures concurrently. Attackers on the same network segment can force ADDADDR retransmissions by spoofing selective acknowledgments or delaying TCP segments, then exploit the gap to corrupt memory, leak kernel data, or escalate privileges to root inside the Linux environment. From there, a pivot into the Windows host via shared folders, interop mounts, or WSL VHDs becomes a real possibility.

The Common Vulnerability Scoring System (CVSS v4) calculation for CVE-2026-46137 hasn’t been finalized by NIST, but early Linux distributions score it as 8.1—high severity—due to the combination of network attack vector, low complexity, and potential for complete compromise of kernel integrity. Red Hat’s advisory notes that MPTCP is enabled by default in most stock kernels since version 5.19, which covers all WSL2 kernels shipped in Microsoft Store updates since 2023. Ubuntu and Debian-based WSL instances are equally vulnerable unless the admin has blacklisted the mptcpcpath module.

How the Race Works

MPTCP is a transport-layer protocol that lets a single TCP connection use multiple subflows across different network interfaces, such as Wi-Fi and cellular, for bandwidth aggregation and seamless failover. The path-manager component handles address advertisements: when an endpoint wants to expose a new IP address to its peer, it sends an ADDADDR option and sets a retransmission timer. On expiry, mptcppmaddaddrretransmit() runs inside a softirq context.

Before the fix, the function called mptcpsubflowsendack(), which accesses the socket structure without guaranteeing the socket lock is held. A concurrent close() or setsockopt(MPTCPREMOVEADDR) in user space could free the subflow context, leading to a use-after-free. The patch—merged into mainline kernel 6.13 and backported to stable trees 6.1.139, 6.6.99, and 6.12.15—wraps the retransmit logic with locksock()/releasesock() calls, serializing access even in softirq.

What makes this especially dangerous in hybrid environments is that the vulnerable code runs inside the Linux guest but can be triggered by a network attacker targeting the Windows host’s physical network interface. WSL2 uses a virtualized Hyper-V switch, so any packet arriving at the Windows NIC gets bridged to the Linux guest if it matches the guest’s IP. An attacker on the same LAN can scan for MPTCP-capable hosts (common when Multipath is enabled in the WSL config file or via sysctl net.mptcp.enabled=1) and fire a crafted sequence to initiate the race.

Immediate Steps for Windows Defenders

Microsoft’s Security Response Center hasn’t assigned a Microsoft-specific advisory, because the bug lives in upstream Linux. That means Windows Update won’t deliver the patch automatically—even though your WSL kernel might say “provided by Microsoft.” The Windows Update mechanism for WSL only fetches a pre-compiled kernel image from the Microsoft Store. Until that image gets refreshed, you’re responsible.

1. Inventory every Linux instance touching Windows. Run a PowerShell script across your fleet:

Get-WmiObject -Class Win32ComputerSystem | Select-Object -ExpandProperty Name
wsl -l -v  # lists WSL distros and their WSL version

Don’t forget Docker Desktop’s internal Linux VM (often named docker-desktop), Azure Kubernetes Service hybrid worker nodes, and any third-party appliances that embed a Linux management plane behind a Windows UI. Some SANs, backup appliances, and industrial control systems ship with a Debian-based service processor that uses MPTCP for multipath iSCSI.

2. For WSL2 guests, manually update the kernel. The upstream fix is available in the Microsoft WSL kernel tree at tag 5.15.167.x and 6.6.x. You can compile a custom kernel and point your .wslconfig to it, but a simpler approach is to block MPTCP entirely until the Microsoft-signed kernel releases:

sudo nano /etc/sysctl.d/99-disable-mptcp.conf
net.mptcp.enabled = 0
sudo sysctl -p /etc/sysctl.d/99-disable-mptcp.conf

Then verify: cat /proc/sys/net/mptcp/enabled should return 0.

For production systems that can’t disable MPTCP (e.g., you rely on multipath iSCSI bandwidth aggregation), compile the patched mainline kernel. A step-by-step:

wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.12.15.tar.xz
tar -xf linux-6.12.15.tar.xz
cd linux-6.12.15
cp /proc/config.gz . && gunzip -c config.gz > .config
make -j$(nproc) && make modulesinstall && make install

update wsl.conf to boot new kernel

3. Container hosts and Kubernetes nodes. Linux containers on Docker Desktop share the same WSL2 VM kernel, so disabling MPTCP there has the same effect. If you run native Kubernetes nodes on Windows Server with Linux pods (Azure Arc-enabled), upgrade the node’s image to a patched kernel manually. Microsoft’s official Kubernetes distributions often lag mainline by weeks—check your node’s kernel version and compare to the fixed stable trees.

4. Scan your network for MPTCP endpoints. Use Nmap scripts to detect hosts with MPTCP capabilities:

nmap -p <port> --script mptcp-info <target>

Any response indicating “MPTCP: Yes” means the target is potentially vulnerable. This helps discover shadow IT—like that Raspberry Pi running Home Assistant that someone plugged into the office switch and forgot.

Why This CVE Matters to Windows Teams More Than Most Linux Bugs

Windows administrators often treat WSL as a sealed sandbox: a developer convenience that can’t breach the host. That assumption breaks under scrutiny. The WSL2 architecture shares the Windows networking stack; a compromising the Linux guest’s kernel yields read/write access to all mounted Windows drives via DrvFs. An attacker with root in the Linux VM can plant a malicious script in C:\\Users\\Public and wait for a user to double-click, or tamper with Docker images that get promoted to production.

Furthermore, many Windows servers run Hyper-V Linux VMs for appliances that need MPTCP to aggregate network links. A storage array might use MPTCP for redundant iSCSI paths; a load balancer virtual appliance might use it for session persistence. These appliances often run old, unpatched kernel versions because vendors test and certify specific builds. CVE-2026-46137 is the kind of bug that pushes them into emergency patching cycles—and your change control board won’t like it.

The Bigger Picture: Linux Supply Chain in Windows Shops

This vulnerability highlights a gap in Microsoft’s patch management story for the Linux components it ships or relies on. Windows Update doesn’t cover the WSL kernel directly; the Microsoft Store does, but its update cadence is irregular. For server environments, Windows Admin Center doesn’t surface Linux kernel CVEs for VM guests. Admins must stitch together data from the Linux Kernel Mailing List, distribution advisories, and the NVD to understand their risk.

A pragmatic approach is to treat every Linux instance under your care—whether a full VM, a WSL guest, or a container host—as a separate asset in your configuration management database. ISO 27001:2022 demands it anyway. Assign ownership to a team responsible for kernel patching, and build a pipeline that monitors security mailing lists for new CVEs affecting the kernel branches you deploy.

Microsoft’s own Azure Security Center does not yet detect vulnerable WSL kernels, even though it can inventory installed WSL distros. Until that feature arrives, you’ll need to rely on manual checks or custom scripts. Consider integrating a kernel version check into your endpoint compliance: if uname -r returns a version below the fixed stable trees, flag the device as noncompliant.

Attack Scenarios Worth Worrying About

Scenario 1: Lateral Movement from a Compromised Print Server. An attacker has foothold on a Windows print server with WSL installed for CUPS testing. They exploit CVE-2026-46137 to root the WSL2 guest, mount the host’s SYSTEMROOT via DrvFs, and dump LSASS secrets. Game over.

Scenario 2: Container Escape in CI/CD Pipelines. A build agent running Docker Desktop with a vulnerable kernel allows a malicious container image to trigger the race, escape to the underlying VM, and then jump to the Windows CI server. From there, they can modify build artifacts or steal signing keys.

Scenario 3: Storage Appliance Takeover. A two-node Storage Spaces Direct cluster uses a third-party SAS switch that runs an embedded Linux for management. That Linux kernel has MPTCP enabled for multipath SAS. A network scan reveals the switch’s management IP; exploiting the race gives an attacker a root shell on the switch, letting them corrupt disk blocks or sniff replication traffic.

These are not hypothetical. CVE-2026-46137 has a published proof-of-concept (PoC) on GitHub that triggers the race in under 20 seconds over a noisy network. That means your patching window should be measured in hours, not days.

What Microsoft Should Do Next

Three moves would close the exposure for Windows customers:

  1. Expedite a WSL kernel update through the Microsoft Store. The kernel team already has the patch; they just need to sign and ship. Provide clear KB-style documentation so enterprises can track deployment.
  2. Extend Windows Update to WSL kernels on Server SKUs. Windows Server 2025 runs WSL for container support; admins expect server components to get security patches through the same WSUS channel, not a consumer app store.
  3. Add WSL kernel version scanning to Microsoft Defender for Endpoint. A vulnerability assessment that flags outdated WSL kernels gives SOC teams the signal they need without manual scripting.

Until these measures materialize, the burden is on you—the Windows infrastructure team—to keep Linux patches flowing. Build a cross-team patching runbook that covers WSL, Docker, and appliance firmware. Treat May 28, 2026 as the date your exposure started; every day after is a gamble.

CVE-2026-46137 is a reminder that the kernel supplying your GUI is no longer the only kernel in the room. Modern Windows environments are a tapestry of Linux subsystems, and a remote, low-complexity kernel race in any one of them can unravel the whole fabric. Inventory now, patch now, and demand better cross-platform patch delivery from every vendor in your supply chain.