Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted Wasm module to engine
-
DeliveryInflate function to many SSA values
-
ExploitTrigger silent bit-pack index overflow
-
ExecutionCranelift miscompiles, referencing wrong IR values
-
ImpactType confusion escapes sandbox to host
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Numeric truncation prevention
|
| Exploitation Conditions | Requires the host to compile and run an attacker-supplied, untrusted Wasm module using Wasmtime's default Cranelift backend; the malicious module must contain a sufficiently large or specially crafted function with enough SSA values to overflow the previously 24-bit-packed value index. The flaw only manifests in release builds, where the overflow guard (debug_assert) is compiled out. Limiting factors: the attacker must control the Wasm input and reach a Wasmtime engine that JIT/AOT-compiles untrusted guests (per CVSS PR:L); hosts that only run trusted/first-party modules are not exposed. Not dependent on a specific CPU architecture - any platform using the default Cranelift backend is affected. |
| Impact | This is a genuine high priority, not an inflated CVSS score. The vendor GHSA advisory confirms a default-configuration sandbox escape in the Cranelift backend on any architecture, and the vuln.today decision label is act_now with a vendor patch available. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C) is internally consistent with the mechanism: an attacker supplying an untrusted Wasm module (the PR:L privilege) can force miscompilation that breaks out of the sandbox (S:C scope change) with full C:H/I:H/A:H impact - a 9.9 is defensible. Signals that are MISSING: no EPSS probability and no CISA KEV status were provided in the input, so widespread-exploitation likelihood cannot be quantified. No PoC or working-exploit reference is present either - the only code references are the vendor fix PRs (12613, 14818) and commits, which are patches, not exploit code. So exploitation status is 'no public exploit identified at time of analysis' despite the critical score; the urgency here derives from the act_now decision label, confirmed default-config impact, and the sandbox-escape primitive, not from observed exploitation. One nuance worth noting to defenders: the flaw manifests specifically in release builds (the debug_assert overflow guard is compiled out), so it is a real-world production exposure even though debug builds would have panicked. |
| Exploit ScenarioDerived | An attacker who can submit a WebAssembly module to a host that compiles untrusted guests with Wasmtime's default Cranelift backend (e.g. an edge/serverless platform or plugin host) crafts a function with enough SSA values to overflow Cranelift's bit-packed value indices. The silent overflow makes the compiler reference the wrong IR values, producing a miscompiled, type-confused native function that lets the guest read/write outside its sandbox and act with host privileges. No public exploit identified at time of analysis; only vendor fix commits are published. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Wasmtime versions before 36.0.19, and the 37.0.0 through 42.x line, can silently miscompile attacker-supplied WebAssembly because Cranelift's SSA value-index packing overflows in release builds, letting a specially crafted or very large function make the compiler reference the wrong IR value and produce type confusion that may cross the Wasm sandbox boundary on any architecture using the default Cranelift backend. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C) reflects that a low-privileged position plus control of the compiled module is enough to reach a scope-changing impact, and the flaw is only reachable when the host actually compiles untrusted guests; hosts that only run first-party modules are not exposed. The vendor has released 36.0.19 and 43.0.0, and the priority label is act_now, though no public exploit has been identified at time of analysis.
RemediationAI
Upgrade Wasmtime to 36.0.19 if you track the 36.x maintenance branch, or to 43.0.0 if you are on 37.0.0 or later; these are the versions the vendor identifies as fixed, and the corresponding release artifacts are at https://github.com/bytecodealliance/wasmtime/releases/tag/v36.0.19 and https://github.com/bytecodealliance/wasmtime/releases/tag/v43.0.0, with the underlying changes in PRs https://github.com/bytecodealliance/wasmtime/pull/12613 and https://github.com/bytecodealliance/wasmtime/pull/14818 and commits ba8f7d70caa1825b7f64fa75cd9d03f4a438dae0 and f517bd6e890c7c1291ab9fe05d8cc0c9f11e56aa. Because the fix replaces the 24-bit packed fields with full u32 indices and explicit bounds handling, there is no partial or configuration-level mitigation documented by the vendor: the vulnerability lives in the compiler itself, so disabling or swapping backends is not offered as a workaround, and any pipeline that precompiles or AOT-builds untrusted modules must be upgraded too, not just JIT paths. Prioritize internet- or tenant-facing services that accept arbitrary Wasm, since the CVSS vector records PR:L and scope change; hosts that only compile first-party modules can be deprioritized accordingly, but should still be updated, and the vendor advisory at https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-897f-g5gm-fmxm should be tracked for any follow-up guidance.
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
Cranelift, Wasmtime's default compiler backend, stored the per-value metadata for its data-flow graph in a packed u64 named ValueDataPacked: a 2-bit tag, a 14-bit type, and two 24-bit fields (x and y) holding SSA value indices, with 0xffffffff reserved as a sentinel and remapped through encode_narrow_field/decode_narrow_field. The bounds check in that encoder was a debug_assert, which is compiled out of release builds, so any index at or above 2^24 was silently truncated rather than rejected - a numeric truncation error (CWE-197) that subsequently causes the IR to resolve to a different, wrongly typed value (CWE-843 type confusion). Because the truncation happens inside the compiler rather than in guest code, the resulting miscompilation is arbitrary and attacker-influenced, and the CVSS scope change (S:C) captures that it can break the sandbox guarantee rather than merely crash a guest. The upstream fix (PRs 12613 and 14818, commits ba8f7d70 and f517bd6e) abandons the narrow packing: x and y become full u32 fields in a packed struct, flags_and_type becomes a u16, and the sentinel/encode-decode helpers are removed so oversized indices are handled explicitly instead of wrapping. The trigger is not a specific CPU feature or architecture - any platform that runs the default Cranelift backend is in scope - and it requires a sufficiently large or deliberately crafted Wasm function body with many SSA values.
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
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
Attacker must be able to submit a guest module (PR:L) and fully controls module contents (AC:L); sandbox escape crosses into the host (S:C) with complete C/I/A loss.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Wasmtime is a runtime for WebAssembly. Prior to 36.0.19 and 43.0.0, the Cranelift compiler backend bit-packs SSA value indices in a way that can silently overflow in release builds when compiling a sufficiently large or specially crafted Wasm function with many SSA values. The overflow can make Cranelift reference incorrect IR values, causing arbitrary miscompilation, type confusion, and other attacker-controlled effects that may escape the Wasm sandbox on any architecture using the default Cranelift backend. This issue is fixed in versions 36.0.19 and 43.0.0.
Technical POC Analysis
Bug class: CWE-197 Numeric Truncation Error.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical vulnerability in Wasmtime, a WebAssembly runtime used to safely execute untrusted code, could allow a low-privileged attacker to escape the Wasm sandbox and compromise the host system. Organizations that compile third-party or user-supplied WebAssembly modules are at risk, potentially leading to data breaches or service disruption. Leadership should prioritize remediation because this flaw undermines a key security boundary relied upon for multi-tenant or plugin-based architectures.
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
Sandbox escape in Wasmtime on aarch64 lets a user-supplied WebAssembly module redirect an oversized br_table branch to a
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
EUVD-2026-109186
GHSA-897f-g5gm-fmxm
NVD
CVE.org
VulDB
Exploit-DB