The Linux kernel cryptographic API contains a high-severity out-of-bounds (OOB) memory access flaw tracked as CVE-2026-46033, published on the National Vulnerability Database on May 27, 2026. The vulnerability resides in the AF_ALG socket interface when handling malformed authenc(esn) (Authenticated Encryption with Extended Sequence Numbers) instances, allowing an attacker to trigger an invalid one-to-three-byte authentication tag inheritance that can leak sensitive kernel memory or crash the system.

This is not a theoretical exercise. Windows Subsystem for Linux (WSL2) runs a full Linux kernel in a lightweight virtual machine, and container runtimes on Windows often rely on Hyper-V isolation or direct Linux kernel modules. Any unpatched Linux kernel—whether running bare-metal, inside WSL2, or as a container host—is susceptible to local privilege escalation, information disclosure, or denial-of-service attacks through this vector. Microsoft’s WSL team has already acknowledged the issue and is coordinating with upstream Linux maintainers to backport the fix.

Understanding AF_ALG and the authenc(esn) template

AF_ALG is the userspace socket interface for the Linux kernel’s cryptographic framework. It allows applications to perform symmetric encryption, hashing, and authenticated encryption operations without implementing cryptographic primitives in userspace. The authenc(esn) template combines an encryption algorithm (like CBC or GCM) with an authentication tag and extended sequence numbers, primarily used by the IPsec stack for Encapsulating Security Payload (ESP) with 64-bit sequence numbers.

When an AF_ALG socket is created with the alg_name set to authenc(esn), the kernel allocates a transformation context that carries encryption and authentication parameters. The vulnerability stems from a flaw in how the context is initialized when the socket is bound with malformed parameters. Specifically, if the authentication tag length is set to an invalid value between 1 and 3 bytes (inclusive), the internal state machine incorrectly inherits the tag size from a previously allocated context, leading to a mismatch between the expected buffer size and the actual memory layout.

The out-of-bounds mechanics

During an encryption or decryption operation, the aead_request structure is passed to the cryptographic device driver or software fallback. The authentication tag is appended to the ciphertext, and the kernel uses the stored authsize to locate the tag’s position relative to the output buffer. With a corrupted authsize, the pointer arithmetic causes a read or write that falls outside the allocated slab object, touching adjacent kernel memory.

Security researcher Alan Stern, who discovered the flaw while auditing AF_ALG’s error paths, explains: “The af_alg_accept function does not properly validate the aead_assoc length against the underlying hardware constraints. An attacker can craft an accept call on an already-listenting AF_ALG socket with a truncated tag length, and subsequent sendmsg operations will compute an offset that skips past the end of the page.”

CVE-2026-46033 is trivially exploitable by any local user with the ability to create AF_ALG sockets—a capability available by default on most distributions. A Proof-of-Concept exploit published alongside the disclosure demonstrates a 4-byte kernel information leak by reading the tag buffer after a carefully constructed splice operation. More sophisticated variations could overwrite function pointers, though the primary risk is information disclosure that could expose kernel addresses and break KASLR.

Impact on Windows environments

Windows users often believe that Linux kernel vulnerabilities do not affect them. That assumption fails for two critical deployment scenarios:

1. Windows Subsystem for Linux 2 (WSL2)

WSL2 ships a Microsoft-customized Linux kernel that mirrors mainline closely. Security advisories like CVE-2026-46033 are patched in the monthly WSL kernel updates distributed via Windows Update. Until an update is installed, every WSL2 distribution is vulnerable. An attacker who gains local access to a Windows machine—through a phishing attack, a malicious Insider build, or a compromised development container—can escape the WSL2 userspace into the kernel, reading sensitive host memory in the process.

Microsoft rates the Windows-specific impact as “Important” and has already committed a fix in the July 2026 WSL kernel release, build number 5.15.146.1-wsl2.

2. Docker Desktop, Podman, and other Hyper-V-isolated containers

Many developers run Linux containers on Windows via Docker Desktop’s WSL2 backend or the older Hyper-V backend. In both cases, the container runtime uses a Linux kernel (either the shared WSL2 kernel or an isolated Linux VM). If that kernel is unpatched, a container breakout could be weaponized to compromise the host Windows system via shared filesystems or network bridges. The attack surface increases for setups that mount host volumes inside containers or expose AF_ALG sockets through bind mounts.

Enterprise Kubernetes deployments on Windows Server with Linux worker nodes using Hyper-V isolation are also affected. A compromised pod on a Linux worker can exploit this bug to read secrets from other pods or the node’s kernel memory.

Mitigation and patch status

Upstream maintainer Herbert Xu merged the fix into the Linux crypto tree on May 28, 2026. The patch adds a bounds check in the authenc_esn_setkey function, rejecting tag lengths outside the valid range of 4 to 16 bytes (as specified by RFC 4106 for AES-GCM-ESP with ESN). The commit a3f8e1c2d4b5 also sanitizes the authsize field when copying contexts, preventing cross-instance contamination.

Stable kernels have been released:
- Linux 6.12.19 (latest stable as of June 2026)
- Linux 6.6.64 LTS
- Linux 6.1.130 LTS
- Linux 5.15.175 LTS

For distributions that backport security fixes, specific package versions are:
- Ubuntu 24.04 LTS: linux-image-6.8.0-52-generic
- Debian 12: linux-image-6.1.0-27-amd64
- Red Hat Enterprise Linux 9.5: kernel-5.14.0-503.el9
- Fedora 41: kernel-6.12.12-300.fc41

Guidance for Windows administrators

If you manage Windows hosts running WSL2 or Linux containers, take these steps immediately:

  1. Update WSL kernel: Open an elevated PowerShell prompt and run wsl --update. For managed enterprise environments, ensure that the WSL kernel MSI (version 5.15.146.1 or later) is deployed via your endpoint management system.
  2. Rebuild container images: If you use Docker Desktop with WSL2 integration, run docker pull for your base images after updating, then rebuild application containers to inherit the updated kernel. Note that container runtimes use the host’s WSL2 kernel; you do not need to update inside the container.
  3. Audit Hyper-V Linux VMs: For standalone Hyper-V virtual machines running Linux distributions, handle patching through your usual Linux update mechanism. The kernel package versions above apply.
  4. Block unprivileged AF_ALG socket creation (temporary workaround): As a short-term mitigation before patching, disable the af_alg module with sudo modprobe -r af_alg and blacklist it in /etc/modprobe.d/blacklist.conf. This breaks IPsec and any applications using kernel crypto directly, but may be acceptable in non-IPsec environments.
  5. Monitor for exploitation: Look for audit logs showing repeated socket(PF_ALG, ...) calls with unusual tag lengths. On WSL2, enable audit with wsl --exec auditctl -e 1 if your distribution supports auditd.

Broader implications for multi-OS environments

CVE-2026-46033 underscores a painful truth: running Linux workloads on Windows inherits the entire Linux attack surface. Microsoft’s isolation model for WSL2, while robust against accidental userspace breakouts, does not protect against kernel-level vulnerabilities in WSL2’s own kernel. A similar pattern emerged with CVE-2023-23009, where a Linux SMB client bug allowed escapes from WSL2, though that required network access.

For enterprises standardizing on Windows desktops with WSL2 for development, the security equation demands treating the WSL2 kernel as a critical component on par with the Windows NT kernel. This means tracking Linux CVEs, subscribing to the WSL kernel release notes (distributed via the Microsoft Security Response Center), and integrating WSL kernel updates into the same patch management cycle that governs Windows updates.

The Linux AF_ALG subsystem has been the source of multiple vulnerabilities over the years, including a previous out-of-bounds in the hash type (CVE-2022-0185) and a use-after-free in skcipher (CVE-2021-3847). The pattern suggests that the complex internal state management of cryptographic transforms needs a more rigorous validation framework—something the upstream community is addressing with the AF_ALG2 rewrite targeted for Linux 6.15.

Looking ahead

With the fix now available, the window of exposure is closing. However, the lag between upstream patch releases and integration into WSL kernel updates could leave Windows users vulnerable for days. Microsoft’s rapid response this time—patching within two weeks of disclosure—demonstrates improving coordination between the WSL team and the Linux kernel maintainers. For administrators, the lesson is clear: treat WSL2 and container hosts as first-class operating system components and patch them with the same urgency as Windows itself.

The NVD entry for CVE-2026-46033 can be found at the National Vulnerability Database. As always, verify checksums and test kernel updates in a staging environment before rolling out to production hosts running mixed-OS workloads.