Description
In the Linux kernel, the following vulnerability has been resolved:

wireguard: noise: reject response consumption after intermediate initiation

Two threads begin processing the identical response message, received
twice. The first thread, A, runs. While it's running, the second one,
B, gets partway through, and during that slow calculation, or even while
blocking on down_write(), A completes and then also a handshake
initiation that's already been queued up runs in thread C, which itself
takes that same down_write(). The handshake initiation creation
succeeds, and sets the state back to waiting-for-response, and calls
up_write(), at which point thread B resumes, because either its finished
its calculations or was finally allowed to acquire down_write(). Thread
B then copies the state back to the peer, and begins a new session,
using that state, which is the same session as the one made in thread A.

Thread A Thread B Thread C

down_read()
sA = handshake->state
memcpy(cA, handshake->crypto)
up_read()
if (sA != 1)
goto fail
slow_crypto(cA)
down_read()
sB = handshake->state
memcpy(cB, handshake->crypto)
up_read()
if (sB != 1)
goto fail
slow_crypto(cB)
down_write()
if (sA != handshake->state)
goto fail
memcpy(handshake->crypto, cA)
handshake->state = 2
up_write()
down_write()
if (handshake->state != 2)
goto fail
derive_session(handshake->crypto)
up_write()
down_write()
slow_crypto(handshake->crypto)
handshake->state = 1
up_write()
down_write()
if (sB != handshake->state)
goto fail
memcpy(handshake->crypto, cB)
handshake->state = 2
up_write()
down_write()
if (handshake->state != 2)
goto fail
derive_session(handshake->crypto)
up_write()

This seems basically impossible to hit in a meaningful way in practice,
but ensure that it absolutely cannot happen by comparing the ephemeral
private key that's on the stack with the latest one that the peer's
handshake state has.
Published: 2026-10-23
Score: n/a
EPSS: n/a
KEV: No
Impact: Race condition leading to duplicate or incorrect session creation
Action: Assess Impact
AI Analysis

Impact

The vulnerability arises because the WireGuard handshake processing in the Linux kernel does not correctly guard against concurrent processing of the same response. Two kernel threads can complete the cryptographic calculations and copy the handshake state simultaneously, causing the handshake structure to be overwritten with an earlier state while later threads derive a session from that intermediate state. An attacker that can send duplicate or carefully crafted handshake responses may be able to induce this race, resulting in the kernel creating two WireGuard sessions that share identical or inconsistent cryptographic material. This could lead to session persistence issues, misconfiguration, or, in a worst case scenario, exposure of encrypted traffic if an incorrect key is used.

Affected Systems

All Linux distributions that ship a kernel with the vulnerable WireGuard implementation are affected. The specific kernel versions are not listed in this CVE, so any kernel before the commit that introduced the fix (see the provided git references) is potentially vulnerable on both server and client endpoints that rely on kernel‑space WireGuard.

Risk and Exploitability

The CVSS and EPSS scores are not provided, and the vulnerability is not listed in CISA’s KEV catalog. Based on the description, the issue is a race condition that could be triggered by a network attacker sending duplicate handshake replies. The exploitation complexity appears high and the likelihood of successful exploitation low; no public exploits are known. Nevertheless, because the bug involves the fundamental cryptographic state of a VPN tunnel, it is prudent to treat it as a moderate risk until a patch is applied.

Generated by OpenCVE AI on October 23, 2026 at 15:45 UTC.

Remediation

No solution or workaround provided in the CVE record.

OpenCVE Recommended Actions

  • Apply the kernel patch that replaces the vulnerable handshake code. The patch is available in the Linux kernel upstream git history; upgrade to the latest stable kernel release that includes commit 3bec3d32c2a3afd164fc87f95457df2cf9049c20 or later.
  • Rebuild and install the latest WireGuard kernel module (or use the version distributed with the patched kernel) to ensure the fixed state handling is used.
  • As a temporary measure, monitor logs for duplicate handshake events and consider filtering duplicate response packets at the firewall level to reduce the chance of a race.

Generated by OpenCVE AI on October 23, 2026 at 15:45 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories yet.

History

Fri, 23 Oct 2026 16:15:00 +0000

Type Values Removed Values Added
Weaknesses CWE-362

Fri, 23 Oct 2026 12:45:00 +0000

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: wireguard: noise: reject response consumption after intermediate initiation Two threads begin processing the identical response message, received twice. The first thread, A, runs. While it's running, the second one, B, gets partway through, and during that slow calculation, or even while blocking on down_write(), A completes and then also a handshake initiation that's already been queued up runs in thread C, which itself takes that same down_write(). The handshake initiation creation succeeds, and sets the state back to waiting-for-response, and calls up_write(), at which point thread B resumes, because either its finished its calculations or was finally allowed to acquire down_write(). Thread B then copies the state back to the peer, and begins a new session, using that state, which is the same session as the one made in thread A. Thread A Thread B Thread C down_read() sA = handshake->state memcpy(cA, handshake->crypto) up_read() if (sA != 1) goto fail slow_crypto(cA) down_read() sB = handshake->state memcpy(cB, handshake->crypto) up_read() if (sB != 1) goto fail slow_crypto(cB) down_write() if (sA != handshake->state) goto fail memcpy(handshake->crypto, cA) handshake->state = 2 up_write() down_write() if (handshake->state != 2) goto fail derive_session(handshake->crypto) up_write() down_write() slow_crypto(handshake->crypto) handshake->state = 1 up_write() down_write() if (sB != handshake->state) goto fail memcpy(handshake->crypto, cB) handshake->state = 2 up_write() down_write() if (handshake->state != 2) goto fail derive_session(handshake->crypto) up_write() This seems basically impossible to hit in a meaningful way in practice, but ensure that it absolutely cannot happen by comparing the ephemeral private key that's on the stack with the latest one that the peer's handshake state has.
Title wireguard: noise: reject response consumption after intermediate initiation
First Time appeared Linux
Linux linux Kernel
CPEs cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
Vendors & Products Linux
Linux linux Kernel
References

Subscriptions

Linux Linux Kernel
cve-icon MITRE

Status: PUBLISHED

Assigner: Linux

Published:

Updated: 2026-10-23T12:22:47.559Z

Reserved: 2026-09-25T10:25:14.388Z

Link: CVE-2026-99059

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

Published: 2026-10-23T13:17:29.620

Modified: 2026-10-23T13:17:29.620

Link: CVE-2026-99059

cve-icon Redhat

No data.

cve-icon OpenCVE Enrichment

Updated: 2026-10-23T16:00:18Z

Weaknesses
  • CWE-362

    Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')