Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRun multi-threaded Tokio 1.54.0 runtime
-
DeliveryUse tokio::time::Interval poll_tick/tick().await
-
ExploitRace drops timer entry during firing
-
ExecutionUse-after-free on waker and task state
-
ImpactPanic, refcount corruption, or heap corruption
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Concurrency control, locking
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires all of: Tokio exactly at version 1.54.0, the multi-threaded runtime flavor (the current-thread runtime is not implicated), and application use of tokio::time::Interval via poll_tick or .tick().await. Sleep and Timeout are explicitly unaffected. The flaw manifests only within a narrow, timing-dependent race window between Interval polling and the time driver firing the entry (reflected by AC:H/AT:P), and it arises from the application's own concurrent timer usage rather than attacker-controlled input, which strongly limits realistic adversarial exploitation. Limiting factors: single affected version (now yanked), multi-threaded-runtime-only, Interval-only, and no required/available remote vector. |
| Impact | This is a memory-safety/reliability defect (CWE-362 race condition leading to use-after-free), not a conventional remotely-weaponizable vulnerability. The CVSS 4.0 vector (AV:L/AC:H/AT:P/PR:L/UI:N) is self-consistent and points to LOW real-world attack risk: exploitation is local, requires a high-complexity timing window and a specific attack requirement (AT:P), and the dominant impact is availability (VA:H - crashes/panics) with only limited integrity impact (VI:L) and no confidentiality impact (VC:N). Critically, the condition is triggered by the application's own normal concurrent use of tokio::time::Interval on a multi-threaded runtime rather than by attacker-supplied input, so the 'attacker' model is weak - this behaves far more like a correctness/stability bug than a targeted exploit primitive. No EPSS score, KEV listing, or working PoC is present in the input; the only references are the vendor advisory, fix PRs/commits, and the 1.54.1 release, i.e. remediation artifacts, not exploit code. The vuln.today decision label is 'this_month' (not act_now/emergency), consistent with a moderate-priority correctness fix. Signals are internally consistent - there is no CVSS-vs-description conflict here - but note the raw 5.8 score overstates adversarial threat; the practical urgency is driven by production crash risk, not exploitability. |
| Exploit ScenarioDerived | On a multi-threaded Tokio runtime, an application that polls a tokio::time::Interval races with the runtime's time driver as a timer fires, dropping the timer entry without synchronizing with the firing driver thread. This produces a use-after-free on the waker and task state, surfacing as an assertion panic, task reference-count corruption, or heap corruption that crashes the service. No public exploit was identified at time of analysis; the issue is primarily self-inflicted through ordinary Interval usage rather than attacker-driven, and the trigger depends on an inherently narrow timing window (AC:H/AT:P). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Heap memory corruption, task reference-count corruption and assertion panics can occur in Tokio 1.54.0 when an application polls tokio::time::Interval on the multi-threaded runtime, because Interval::poll_tick (including .tick().await) may drop an internal timer entry without synchronizing with the time driver thread that is firing it, yielding a use-after-free on the timer's waker and task state in safe Rust. The exposure is narrow: only the single affected release (since yanked) combined with the multi-threaded runtime flavor and use of Interval, while Sleep and Timeout are explicitly unaffected. This is a memory-safety and reliability defect driven by the application's own concurrent timer usage rather than attacker-controlled input - no public exploit code has been identified at time of analysis, and realistic adversarial exploitation is strongly limited; a fix ships in Tokio 1.54.1.
RemediationAI
Vendor-released patch: Tokio 1.54.1 - upgrade with cargo update -p tokio --precise 1.54.1 (or a later release) and rebuild so Cargo.lock no longer pins 1.54.0; the fix is upstream pull request https://github.com/tokio-rs/tokio/pull/8692 (commits 2b4eba7833864c04ecd2f3e5f4a97ff4f6fa28d0 and 5ed619bbaba87357ee5103d71b75e7c84cad99c9), documented in the advisory https://github.com/tokio-rs/tokio/security/advisories/GHSA-5wjr-9356-4wc8 and the https://github.com/tokio-rs/tokio/releases/tag/tokio-1.54.1 release. Because 1.54.0 has been yanked, any lockfile still resolving to it should be treated as needing corrective action even outside Interval usage, and teams that cannot move forward immediately can pin back to the prior 1.53.x line, which predates the regressing change in pull request 8458. Where the affected release must stay in place temporarily, the advisory-scoped exposures can be avoided by running the current-thread runtime flavor instead of the multi-threaded runtime, or by replacing Interval with Sleep or Timeout based scheduling, which are explicitly unaffected; the trade-off is that current-thread runtimes forgo multi-core task parallelism, and reworking periodic timers removes the drift-correcting behavior of Interval and requires re-implementing cadence logic, so both are containment measures rather than fixes.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Tokio's timer implementation stores pending deadlines in per-driver hierarchical timer wheels and represents each registered future as a pinned TimerEntry held in an intrusive linked list (TimerShared). CWE-362 describes the class: in Tokio 1.54.0, a change introduced by upstream pull request 8458 altered how TimerEntry owned and used the scheduler handle, and the deregistration path taken when Interval::poll_tick re-arms or drops an entry was no longer synchronized against the driver thread concurrently firing that same entry. The resulting data race frees or rewrites the waker and task state while the driver still references them - a use-after-free in safe Rust, which is significant because it means no unsafe block in downstream application code is required to reach memory unsafety. The upstream fix (pull request 8692, commits 2b4eba7833864c04ecd2f3e5f4a97ff4f6fa28d0 and 5ed619bbaba87357ee5103d71b75e7c84cad99c9) removes the scheduler handle stored inside TimerEntry and its PinnedDrop implicit cancel, instead threading a &scheduler::Handle through init, reset, poll_elapsed and an explicit cancel, so clearing a timer entry is performed against the driver obtained at call time rather than through stale internal ownership. CPE data (cpe:2.3:a:tokio-rs:tokio) identifies the Rust crate as the affected component; the advisory and package metadata constrain the vulnerable range to exactly 1.54.0, and behavior differs by runtime flavor - the multi-threaded runtime is confirmed affected, while the current-thread runtime is not implicated per the advisory.
Know when Tokio gets its next vulnerability
- 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
CVSS:4.0/AV:L/AC:H/AT:P/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Local, timing-dependent race (AV:L/AC:H) triggered by in-process Interval usage (PR:L, no UI); impact is crashes/UAF so A:H, limited I:L, and no confidentiality (C:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
Tokio is a runtime for writing applications with Rust. In 1.54.0, a race condition between tokio::time::Interval::poll_tick (including .tick().await) and the multi-threaded runtime's time driver could drop an internal timer entry without synchronizing with the driver thread that was firing it. The race caused a use-after-free on the timer's waker and task state in safe Rust, which could produce assertion panics, task reference-count corruption, or heap memory corruption. This issue is fixed in 1.54.1.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Race conditions occur when multiple concurrent requests exploit the brief time gap between checking a condition and acting upon it (TOCTOU - Time of Check, Time of Use).
An issue was discovered in the tokio crate before 1.8.1 for Rust. Rated medium severity (CVSS 5.9), this vulnerability i
Mio is a Metal I/O library for Rust. Rated critical severity (CVSS 9.1), this vulnerability is remotely exploitable, no
An issue was discovered in the tokio crate before 1.8.4, and 1.9.x through 1.13.x before 1.13.1, for Rust. Rated high se
An issue was discovered in the tokio-rustls crate before 0.13.1 for Rust. Rated high severity (CVSS 7.5), this vulnerabi
Tokio is a runtime for writing applications with Rust. Rated medium severity (CVSS 5.4), this vulnerability is remotely
EUVD-2026-109110
GHSA-5wjr-9356-4wc8
NVD
CVE.org
EPSS
Exploit-DB