Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLoad malicious guest into vulnerable embedder config
-
DeliveryInvoke bulk op (memory.copy/table.grow/array.copy)
-
ExploitTrigger fuel/epoch preemption mid-operation
-
ExecutionCallback mutates Store (memory growth/GC)
-
PersistInvalidated pointers or null table elements
-
ImpactCrash, invalid memory access, or GC 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 | Exploitation requires a non-default embedding: the host must either (1) install a Store::epoch_deadline_callback (or fuel callback) that MUTATES the Store - such as growing linear memory, growing a non-nullable table, or triggering garbage collection - or (2) continue using a Store after a trap or cancellation instead of discarding it. The attacker-controlled guest must then execute a bulk operation (memory.copy, table.grow/fill, or array.copy) and hit the fuel/epoch preemption window during that operation. Limiting factors: embeddings whose callbacks only read host data in Store<T>, and embeddings that discard the Store after timeout/epoch deadline, are explicitly NOT affected; success also depends on winning a race-condition timing window (AC:H/AT:P), and the affected version range is narrow (46.0.0-46.0.1 and 47.0.0-47.0.2). |
| Impact | This is a genuinely low-priority issue despite being a memory-safety/GC-corruption bug, and the signals are consistent rather than conflicting. The vendor CVSS 4.0 base score is 2.0 (Low) with a vector (AV:N/AC:H/AT:P/PR:H/UI:P) that reflects heavy preconditions: high attack complexity, a present attack requirement (AT:P, i.e. a timing/race window), high privileges, and passive user interaction. No EPSS score, no CISA KEV listing, and no public exploit (POC) were provided, so exploitation status is 'no public exploit identified at time of analysis' - not active exploitation. The critical caveat is that this is NOT a flaw in default Wasmtime behavior: it only manifests when an embedder writes callbacks (Store::epoch_deadline_callback) that mutate the Store, or continues using a Store after a trap/cancellation. The advisory explicitly states embeddings that only access host data in Store<T>, and those that discard a Store after timeout/epoch deadline, are unaffected. The headline CWE-362 (race condition) and the DoS tag track the crash/invalid-access outcome, but reaching GC heap corruption requires a specific, non-default embedding pattern plus precise preemption timing. Net: real bug, correctly patched, but low real-world risk - prioritize routine patching, not emergency response. |
| Exploit ScenarioDerived | An embedder configures an epoch-deadline or fuel callback that mutates its Store (e.g. grows linear memory or triggers GC), or keeps using a Store after a trap/cancellation. A malicious guest module invokes a bulk operation such as memory.copy, table.grow, or array.copy and arranges for preemption mid-operation, so the callback-induced mutation invalidates retained raw pointers or GC pointers or leaves null elements in a non-nullable table. No public exploit code was identified; successful abuse also depends on winning the race window (CVSS AC:H/AT:P). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Invalid intermediate VM state can be exposed in Wasmtime 46.0.0 through 46.0.1 and 47.0.0 through 47.0.2 when an embedder mutates a Store from inside its fuel or epoch preemption callback - or keeps using the Store after a trap/cancellation - while a guest is mid-way through a bulk operation such as memory.copy, table.grow, table.fill, or array.copy. Hitting that preemption window can leave null elements in a non-nullable table, invalidate retained raw pointers after linear-memory growth during memory.copy, or invalidate GC pointers when the callback triggers garbage collection during array.copy, yielding a crash, invalid memory access, or GC heap corruption (integrity and availability impact only, no confidentiality loss). Exploitation is gated on a non-default embedding configuration (assessed CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:L/A:L; PR:H in the assessed vector), requires winning a timing race, and no public exploit has been identified at time of analysis. Vendor-released patches are available in Wasmtime 46.0.2 and 47.0.3.
RemediationAI
Upgrade to the exact patched releases: Wasmtime 46.0.2 (https://github.com/bytecodealliance/wasmtime/releases/tag/v46.0.2) for the 46.x line, or Wasmtime 47.0.3 (https://github.com/bytecodealliance/wasmtime/releases/tag/v47.0.3) for the 47.x line - vendor-released patches that remove the per-chunk fuel/epoch checks from inside memory.copy, memory.fill, table.fill/grow, and array.copy so those operations run atomically with respect to host callbacks (fix commits 3ebfbe5af4927c157d6fcaca42b8dbb6d17b73fb, 99b0bc39d447317a4102c056081c83a9a84a46e0, a3eb27af01ba5a30320a90ea1405059cdfedd353; PRs 14041, 14043, 14045; full details in GHSA-2hw9-mc66-jc2q). If upgrading is not immediately possible, apply the following compensating controls in order of preference: (1) audit every Store::epoch_deadline_callback and fuel callback so they only read host data held in Store<T> and never call memory.grow, table.grow, or anything that can trigger garbage collection - this eliminates the reentrancy that produces the invalid state, at the cost of giving up legitimate in-callback cleanup or resource-limiting logic; (2) never reuse a Store after a trap, cancellation, deadline, or timeout - allocate a fresh Store (and instance) per invocation and drop the old one, which trades some throughput and allocation overhead for immunity since discarded stores are unaffected; (3) as a last resort, disable both tunables.consume_fuel and tunables.epoch_interruption in the Wasmtime Config, which removes the in-operation preemption checks entirely and makes bulk operations atomic, but this forfeits time-slicing and exposes the host to unbounded-running guests (a denial-of-service trade-off that should only be taken with an external process-level watchdog, such as killing the executing thread or process on a wall-clock deadline). Because exploitation also depends on winning a narrow race window and requires a privileged/non-default embedder configuration, remediation can be scheduled on a normal patch cadence rather than treated as an emergency.
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
Wasmtime is the Bytecode Alliance's WebAssembly runtime, and it implements two cooperative preemption mechanisms - fuel metering (consume_fuel) and epoch-based interruption (epoch_interruption) - that let a host bound guest execution time. Prior to the fix, the Cranelift translator inserted these checks inside bulk operations themselves: raw_bulk_memory_operation split memory.copy/memory.fill into 'uninterruptable chunks' (128 MiB) with an epoch_check and a manual_fuel_check executed per chunk, and similar checks guarded expensive GC/table opcodes such as array.copy and table.grow. Because those checks fire while the operation is only partially complete, the underlying root-cause class is CWE-362 (concurrent execution using shared resource with improper synchronization): a reentrant call into the embedder's Store::epoch_deadline_callback (or fuel callback) can observe and mutate half-updated VM bookkeeping. Three concrete corruption paths are described - a cancelled non-nullable table growth that leaves null elements in a table declared non-nullable, a linear-memory growth (e.g., memory.grow triggered from the callback) during a chunked memory.copy that invalidates raw pointers the compiled code still holds, and callback-triggered garbage collection during array.copy that invalidates GC references the operation is still using. The upstream fix (PRs 14041/14043/14045, commits 3ebfbe5, 99b0bc3, a3eb27a, released in 46.0.2 and 47.0.3) removes manual_fuel_check and the chunked inner-loop preemption scheme, converts raw_bulk_memory_operation to return WasmResult, and moves the preemption/trap checks (pre_translate_bulk_op, translate_entity_fill) ahead of the bulk operation so the operation itself executes atomically with respect to host callbacks. Affected builds are those with fuel and/or epoch interruption enabled; the CPE cpe:2.3:a:bytecodealliance:wasmtime:*:*:*:*:*:*:*:* covers the package family. Note that the same 46.0.2 release (2026-07-31) also shipped an unrelated fix for GHSA-hgjw-h833-99q9, so operators should not conflate the two advisories.
Know when Wasmtime 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:N/AC:H/AT:P/PR:H/UI:P/VC:N/VI:L/VA:L/SC:N/SI:N/SA:N
Requires a non-default embedder callback that mutates the Store (PR:H) and winning a preemption race (AC:H); impact is crash/memory corruption affecting integrity and availability, not confidentiality, within the host process (AV:L).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Wasmtime is a runtime for WebAssembly. From 46.0.0 until 46.0.2 and 47.0.3, fuel and epoch preemption checks inside bulk operations including memory.copy, table.grow, and array.copy can expose invalid intermediate state when an embedder mutates a Store in Store::epoch_deadline_callback or continues using a Store after cancellation or a trap. A cancelled non-nullable table growth can leave null elements, linear-memory growth during memory.copy can invalidate retained raw pointers, and callback-triggered garbage collection during array.copy can invalidate GC pointers, resulting in a crash, invalid memory access, or GC heap corruption. Embeddings whose callbacks only access the host data in Store<T>, and embeddings that discard a Store after timeout or epoch deadline, are not affected. This issue is fixed in versions 46.0.2 and 47.0.3.
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
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).
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
wasmtime is a fast and secure runtime for WebAssembly. Rated critical severity (CVSS 9.9), this vulnerability is remotel
Wasmtime is a standalone runtime for WebAssembly. Rated critical severity (CVSS 9.8), this vulnerability is remotely exp
Wasmtime is a standalone JIT-style runtime for WebAssembly, using Cranelift. Rated critical severity (CVSS 9.8), this vu
wasmtime is a runtime for WebAssembly. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity. Pu
Memory sandbox escape in Wasmtime's Winch compiler (versions 25.0.0 to before 36.0.7, 42.0.2, 43.0.1) enables authentica
Arbitrary memory read/write vulnerability in Bytecode Alliance Wasmtime versions 32.0.0 through 36.0.6, 42.0.0-42.0.1, a
Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.8), this vulnerability is remotely exploit
Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.8), this vulnerability is remotely exploit
Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.6), this vulnerability is remotely exploit
Wasmtime's HTTP header handling in the wasmtime-wasi-http crate crashes when processing excessive header fields, allowin
Wasmtime versions 39.0.0 and later experience a denial-of-service panic when async WebAssembly component functions are c
Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 7.5), this vulnerability is remotely exploit
EUVD-2026-91765
GHSA-2hw9-mc66-jc2q
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB