Skip to main content

Wasmtime CVE-2026-115889

| EUVDEUVD-2026-109186 CRITICAL
Numeric Truncation Error (CWE-197)
2026-10-23 GitHub_M GHSA-897f-g5gm-fmxm
9.9
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted Wasm module to engine
  2. Delivery
    Inflate function to many SSA values
  3. Exploit
    Trigger silent bit-pack index overflow
  4. Execution
    Cranelift miscompiles, referencing wrong IR values
  5. Impact
    Type 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available

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

Alert me

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

wasmtime 37.0.0, < 43.0.0
wasmtime < 36.0.19

Affected Packages

euvd wasmtime fix: 36.0.19, 43.0.0

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

Vendor (GitHub_M) PRIMARY 9.9 CRITICAL
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 9.9 CRITICAL

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 23, 2026 - 22:03 EUVD
CVE Published
Oct 23, 2026 - 21:23 cve.org
CRITICAL 9.9

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Medium
popular standalone Wasm runtime, common in edge/serverless, not universal
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 CRITICAL
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0
CVE-2026-115893 CRITICAL
9.9 Oct 23

Sandbox escape in Wasmtime on aarch64 lets a user-supplied WebAssembly module redirect an oversized br_table branch to a

CVE-2023-26489 CRITICAL
9.9 Mar 08

wasmtime is a fast and secure runtime for WebAssembly. Rated critical severity (CVSS 9.9), this vulnerability is remotel

CVE-2022-39394 CRITICAL
9.8 Nov 10

Wasmtime is a standalone runtime for WebAssembly. Rated critical severity (CVSS 9.8), this vulnerability is remotely exp

CVE-2022-24791 CRITICAL
9.8 Mar 31

Wasmtime is a standalone JIT-style runtime for WebAssembly, using Cranelift. Rated critical severity (CVSS 9.8), this vu

CVE-2024-30266 MEDIUM POC
5.5 Apr 04

wasmtime is a runtime for WebAssembly. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity. Pu

CVE-2026-34987 CRITICAL
9.0 Apr 09

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

CVE-2026-34971 CRITICAL
9.0 Apr 09

Arbitrary memory read/write vulnerability in Bytecode Alliance Wasmtime versions 32.0.0 through 36.0.6, 42.0.0-42.0.1, a

CVE-2023-30624 HIGH
8.8 Apr 27

Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.8), this vulnerability is remotely exploit

CVE-2022-31146 HIGH
8.8 Jul 21

Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.8), this vulnerability is remotely exploit

CVE-2022-39393 HIGH
8.6 Nov 10

Wasmtime is a standalone runtime for WebAssembly. Rated high severity (CVSS 8.6), this vulnerability is remotely exploit

CVE-2026-27572 HIGH
7.5 Feb 24

Wasmtime's HTTP header handling in the wasmtime-wasi-http crate crashes when processing excessive header fields, allowin

CVE-2026-27195 HIGH
7.5 Feb 24

Wasmtime versions 39.0.0 and later experience a denial-of-service panic when async WebAssembly component functions are c

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