CVE-2026-34987

Critical

Published: 09 April 2026

Published

09 April 2026

Modified

15 April 2026

KEV Added

—

Patch

—

CVSS Score 9.9 CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H

EPSS Score 0.0005 15.5th percentile

Risk Priority 20 60% EPSS · 20% KEV · 20% CVSS

Summary

CVE-2026-34987 is a critical-severity Out-of-bounds Read (CWE-125) vulnerability in Bytecodealliance Wasmtime. Its CVSS base score is 9.9 (Critical).

Operationally, exploitation aligns with the MITRE ATT&CK technique Exploit Public-Facing Application (T1190); ranked at the 15.5th percentile by exploit likelihood (below the median); it is not currently listed in the CISA KEV catalog.

The strongest mitigations our analysis identified are NIST 800-53 CM-6 (Configuration Settings) and SI-2 (Flaw Remediation).

Threat & Defense at a Glance

What attackers do: exploitation maps to Exploit Public-Facing Application (T1190) and 1 other technique. What defenders deploy: see the NIST 800-53 controls recommended below.

Threat & Defense Details

Mitigating Controls (NIST 800-53 r5)AI

SI-2 Flaw Remediation good match

prevent

Requires timely patching of flaws like the Winch compiler bug in Wasmtime to eliminate the memory sandbox bypass vulnerability.

CM-6 Configuration Settings good match

prevent

Mandates secure configuration settings for Wasmtime, such as defaulting to the unaffected Cranelift backend instead of enabling the vulnerable Winch compiler.

SC-39 Process Isolation partial match

prevent

Enforces process isolation mechanisms to prevent guest WebAssembly code from accessing host memory outside the intended sandbox.

MITRE ATT&CK Enterprise TechniquesAI

T1190 Exploit Public-Facing Application Initial Access

Adversaries may attempt to exploit a weakness in an Internet-facing host or system to initially access a network.

attack.mitre.org →

T1203 Exploitation for Client Execution Execution

Adversaries may exploit software vulnerabilities in client applications to execute code.

attack.mitre.org →

Why these techniques?

The vulnerability allows remote supply of malicious WebAssembly code to exploit memory corruption (out-of-bounds read/write) in the Winch backend, escaping the sandbox for host RCE or data access; this directly maps to exploitation of public-facing applications (T1190) and client execution via vulnerable runtime (T1203).

Confidence: HIGH · MITRE ATT&CK Enterprise v18.1

NVD Description

Wasmtime is a runtime for WebAssembly. From 25.0.0 to before 36.0.7, 42.0.2, and 43.0.1, Wasmtime with its Winch (baseline) non-default compiler backend may allow properly constructed guest Wasm to access host memory outside of its linear-memory sandbox. This vulnerability requires…

use of the Winch compiler (-Ccompiler=winch). By default, Wasmtime uses its Cranelift backend, not Winch. With Winch, the same incorrect assumption is present in theory on both aarch64 and x86-64. The aarch64 case has an observed-working proof of concept, while the x86-64 case is theoretical and may not be reachable in practice. This Winch compiler bug can allow the Wasm guest to access memory before or after the linear-memory region, independently of whether pre- or post-guard regions are configured. The accessible range in the initial bug proof-of-concept is up to 32KiB before the start of memory, or ~4GiB after the start of memory, independently of the size of pre- or post-guard regions or the use of explicit or guard-region-based bounds checking. However, the underlying bug assumes a 32-bit memory offset stored in a 64-bit register has its upper bits cleared when it may not, and so closely related variants of the initial proof-of-concept may be able to access truly arbitrary memory in-process. This could result in a host process segmentation fault (DoS), an arbitrary data leak from the host process, or with a write, potentially an arbitrary RCE. This vulnerability is fixed in 36.0.7, 42.0.2, and 43.0.1.

Deeper analysisAI

CVE-2026-34987 is a high-severity vulnerability (CVSS 3.1 score of 9.9) affecting Wasmtime, a runtime for WebAssembly, in versions from 25.0.0 up to but not including 36.0.7, 42.0.2, and 43.0.1. The issue resides in the non-default Winch (baseline) compiler backend, enabled via the -Ccompiler=winch flag; Wasmtime defaults to the Cranelift backend, which is unaffected. It stems from an incorrect assumption that a 32-bit memory offset stored in a 64-bit register has its upper bits cleared, potentially allowing properly constructed guest WebAssembly code to access host memory outside the linear-memory sandbox on both aarch64 (with an observed proof-of-concept) and x86-64 (theoretical). This flaw, linked to CWE-125 (out-of-bounds read) and CWE-787 (out-of-bounds write), enables access up to 32 KiB before the memory start or ~4 GiB after, independent of guard regions or bounds checking, with variants possibly reaching arbitrary in-process memory.

Exploitation requires an attacker to supply malicious guest Wasm executed in a Wasmtime instance configured with the Winch compiler. Per the CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C), it is remotely exploitable over a network with low privileges in a scoped context, without user interaction. Successful exploitation can cause a host process segmentation fault for denial of service, leak arbitrary data from the host, or enable arbitrary read/write primitives leading to remote code execution.

The Wasmtime security advisory at https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-xx5w-cvp6-jv83 details the fix in releases 36.0.7, 42.0.2, and 43.0.1. Mitigation involves upgrading to these patched versions or avoiding the Winch compiler backend by sticking to the default Cranelift configuration.