Skip to main content

Tokio CVE-2026-115567

| EUVDEUVD-2026-109110 MEDIUM
Race Condition (CWE-362)
2026-10-23 GitHub_M GHSA-5wjr-9356-4wc8
5.8
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Run multi-threaded Tokio 1.54.0 runtime
  2. Delivery
    Use tokio::time::Interval poll_tick/tick().await
  3. Exploit
    Race drops timer entry during firing
  4. Execution
    Use-after-free on waker and task state
  5. Impact
    Panic, 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).

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

tokio = 1.54.0

Affected Packages

cargo tokio fix: 1.54.1

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

Vendor (GitHub_M) PRIMARY 5.8 MEDIUM
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
vuln.today AI 5.3 MEDIUM

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).

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
High
Attack Requirements
Present
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.1%
Top 99% exploitable
Prevalence
High
dominant async runtime across Rust production services
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

29
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +29
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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).

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy