External risk intelligence

Wasmtime Winch Compiler Memory Sandbox Escape Vulnerability

CVE advisorySeverity: CRITICAL (CVSS 9.0)

CVE-2026-34987

Wasmtime is a library/runtime embedded within other applications, not a standalone internet-facing service. Exploitation requires the specific non-default Winch compiler backend to be enabled and the application to execute untrusted WebAssembly code. While the host application might be internet-facing, the Wasmtime runtime itself is typically an internal component, making direct public-internet exposure uncommon.

Out-of-bounds Read

Bytecodealliance Wasmtime

25.0.0 to before 36.0.737.0.0 to before 42.0.243.0.0

Halo Surface Signal: 2 out of 5 — less likely to be public-facing.

External exposure likelihood

Horizon Alert

Summary of the vulnerability and why it matters

A recent analysis has identified a critical vulnerability in Wasmtime, a runtime for WebAssembly applications. This issue, specifically when the non-default Winch compiler backend is used, could allow specially crafted WebAssembly code to access unintended areas of host memory. While not enabled by default, the Winch compiler's usage could lead to potential data leaks or even arbitrary code execution on the host system.

  • Guest code could access unintended host memory.
  • Use Winch compiler; default is safer.
  • Confirm if Winch compiler is in use.

Attack Path

How an attacker could exploit the issue

An attacker could target Wasmtime when the specific Winch compiler backend is enabled and an application runs untrusted WebAssembly code. If an attacker can provide specially crafted WebAssembly code, it could bypass security checks. This could allow the WebAssembly code to read or write to memory outside its designated sandbox, potentially leading to data leaks, denial of service, or even arbitrary code execution on the host system.

  • Requires Winch compiler and untrusted Wasm.
  • Triggered by crafted Wasm code.
  • Risk of data leaks or code execution.

Live Threat

Current exploitation, exposure, and threat context

When the non-default Winch compiler is used and properly constructed guest WebAssembly code is executed, Wasmtime could allow access to host memory outside of its designated sandbox. This could potentially lead to denial-of-service conditions, leakage of sensitive host process data, or, in some scenarios, arbitrary code execution within the host process.

  • Host process memory
  • Untrusted Wasm execution via Winch
  • Data leak or arbitrary code execution

Operational Fix

Recommended remediation, mitigation, and detection steps

This vulnerability impacts Wasmtime when the non-default Winch compiler backend is used, potentially allowing guest WebAssembly code to access unauthorized host memory. Responsibility likely falls to the application owner integrating Wasmtime, the platform team managing the runtime, and the security team for exposure assessment. The first practical step is to identify all Wasmtime deployments, confirm if the Winch compiler is active, and then assess the risk posed by any potential exposure of this configuration.

  • Application and platform teams own remediation.
  • Verify Winch compiler use and Wasm hosts.
  • Plan updates or mitigating controls.

Supplementary metadata

Validate whether this threat affects your internet-facing exposure.

Halo Threat Intelligence helps prioritize remediation with Halo Surface Signal and H/A/L/O context. Start exposure validation with a free external attack surface trial.

Frequently asked questions

What is Wasmtime?

Wasmtime is a standalone runtime engine for WebAssembly (Wasm). Developers use it to run untrusted Wasm code securely within a host application by providing an isolated sandbox. It acts as the bridge between compiled WebAssembly modules and the host system, typically utilizing the Cranelift compiler backend by default to manage memory safety and performance.

What is the vulnerability in CVE-2026-34987?

This vulnerability is an out-of-bounds memory access issue, categorized as CWE-125 (Out-of-bounds Read) and CWE-787 (Out-of-bounds Write). It occurs due to an incorrect assumption in the Winch compiler backend regarding 32-bit memory offsets in 64-bit registers. This logic error allows guest Wasm code to bypass sandbox boundaries and read or modify memory belonging to the host process.

How is this vulnerability triggered?

The flaw is triggered only when the non-default Winch compiler backend is explicitly enabled; systems using the default Cranelift compiler are not impacted. An attacker must also be able to execute specially crafted WebAssembly code within that environment. If an application does not use the Winch compiler, this specific path to memory access is not present.

Is my software vulnerable according to Halo Surface Signal?

Halo Surface Signal labels the risk as 'Unlikely' because Wasmtime is an internal library, not a standalone internet-facing service. While your host application might be exposed to the internet, Wasmtime itself is an embedded component. The vulnerability requires your specific configuration to use the non-default Winch backend, which is uncommon.

How should I respond to CVE-2026-34987?

Start by auditing your software to determine if you are using the Winch compiler backend (-Ccompiler=winch). If Winch is in use, verify if you are running untrusted WebAssembly code that could be exploited. If you are impacted, prioritize updating Wasmtime to version 36.0.7, 42.0.2, or 43.0.1, as these releases contain the necessary fixes for this memory sandbox escape.

References