Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend or replay identical WireGuard response message
-
ExploitRace two concurrent response-consumption threads
-
ExecutionIntermediate queued initiation resets handshake state
-
ImpactDerive duplicate session from stale ephemeral key
Vulnerability Assessment
| Exploitation Conditions | Requires that the target run the in-kernel WireGuard driver (Linux 5.6 through the fixed stable versions) with an active peer handshake in progress. The attacker must cause one identical handshake response message to be consumed twice by concurrent threads at the exact moment a handshake initiation is queued and acquires the handshake write lock, resetting state back to waiting-for-response so the second thread re-derives the same session. Limiting factors are severe: the trigger is a narrow multi-threaded timing race (reflected in AC:H), it depends on an in-flight handshake rather than an idle tunnel, and the commit author explicitly judges it practically impossible to hit; it affects only deployments where WireGuard is actually configured, not Linux hosts generally. |
| Impact | This is a high-CVSS (7.7) issue that the available signals converge in classifying as LOW real-world priority. The CVSS vector (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:L) pairs a network vector with high attack complexity (AC:H), and that AC:H is corroborated directly by the commit author, who states the race condition 'seems basically impossible to hit in a meaningful way in practice.' EPSS reinforces this: 0.21% (10th percentile) indicates very low predicted exploitation likelihood. The flaw is NOT in CISA KEV (no active exploitation), and no public exploit or PoC is present in the input - the only references are the vendor fix commits on git.kernel.org. The vuln.today 'this_week' decision label reflects routine stable-kernel patch hygiene rather than emergency urgency, and no SSVC exploitation/automatable fields were supplied. The one point worth flagging: the C:H/I:H impact rating is generous for what is described - a cryptographic session-derivation race that duplicates an already-established session - and the Tags claim 'Information Disclosure' while the description never demonstrates key or plaintext exposure, so the high confidentiality/integrity weighting is an upper-bound inference, not a demonstrated outcome. Net: a real correctness bug worth patching on the normal stable-update cadence, not a widespread-exploitation emergency. |
| Exploit ScenarioDerived | An on-path or peer attacker interacting with a WireGuard tunnel causes an identical handshake response message to be delivered and processed twice by concurrent kernel threads while a handshake initiation is simultaneously queued; the intermediate initiation resets the handshake state mid-flight, letting the second thread derive a duplicate session from stale ephemeral key material. Exploitation is network-reachable but gated by an extremely tight timing window - the author assesses it as basically impossible to trigger meaningfully in practice. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
Linux WireGuard can derive the same session twice when two threads consume an identical handshake response and a queued initiation resets peer state in between, allowing the late thread to copy stale crypto state back and establish a session already created by the first thread. The affected population is Linux kernels from 5.6 onward that use the in-kernel WireGuard driver and have an active peer handshake; exploitation requires winning a narrow multi-threaded timing race, which the maintainers describe as practically impossible to hit. No public exploit identified at time of analysis, EPSS is 0.21% (10th percentile), and the assessed real-world priority is low despite the 7.7 CVSS score.
RemediationAI
Vendor-released patch: Linux 6.6.160, 6.12.113, 6.18.57, 7.2.11, and 7.3; apply the corresponding stable commit (https://git.kernel.org/stable/c/fb5ce4c7790c3eeec820302d08d70ecf46af4295, https://git.kernel.org/stable/c/c76a80db593096edf2b3b3972f58b6342a8c6c04, https://git.kernel.org/stable/c/4d64a3d6e96aa78619c9c29ffde309794974588a, https://git.kernel.org/stable/c/3bec3d32c2a3afd164fc87f95457df2cf9049c20, https://git.kernel.org/stable/c/d0305f8d90029556260c6824b61c493c424eba9e) or update to the fixed kernel release. No vendor-described workaround is provided in the available sources, so updating is the complete fix; the supplied decision label places this in this week's patch queue, while the assessed real-world priority remains low because of the narrow race prerequisites.
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 issue is in WireGuard's Noise handshake state machine, not in the underlying cryptography: handshake state and crypto material are copied under read locks, then written back under down_write(), and the code checks only the handshake state value. In the reported interleaving, thread B copies state before thread C's intermediate initiation sets the state back to waiting-for-response, so B's later write-back passes the state check and derives a session identical to A's. The fix rejects response consumption after an intermediate initiation by comparing the ephemeral private key kept on the stack with the peer's latest handshake state. No CWE is assigned in the supplied data; the CPE cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:* is the generic Linux kernel CPE, and EUVD identifies Linux 5.6 as the affected baseline with fixes in 6.6.160, 6.12.113, 6.18.57, 7.2.11, and 7.3.
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:N/S:U/C:H/I:H/A:L
Network-reachable WireGuard packets with no credentials needed (AV:N/PR:N/UI:N); the multi-thread timing race makes it AC:H, and session-key confusion affects tunnel confidentiality and integrity with minor availability impact.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
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.
Executive ViewAI
A high-severity flaw in the Linux kernel's WireGuard driver, affecting versions 5.6 and later, could theoretically allow duplicate session keys under a highly improbable timing race, but the maintainers consider exploitation practically impossible. The risk to the organization is low due to the absence of public exploit code, minimal exploitation likelihood (EPSS 0.21%), and the narrow technical preconditions. Leadership should note that while the CVSS score is high, real-world impact is expected to be negligible, though standard patch management remains advisable.
Apply vendor patch.
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-108725
GHSA-c2jq-9mfv-9wqh
NVD
CVE.org
EPSS
Exploit-DB