Wasmtime Cranelift Bit-Packing Silent Overflow Miscompilation (CVE-2026-115889)
Detects presence and execution of vulnerable Wasmtime runtime versions affected by CVE-2026-115889, a critical (CVSS 9.9) bit-packing defect in the Cranelift compiler that causes silent integer overflow (CWE-197) and type-confusion miscompilation (CWE-843). Affected versions are Wasmtime < 36.0.19 and >= 37.0.0, < 43.0.0. A maliciously crafted WebAssembly module can trigger miscompilation that violates Wasm sandboxing guarantees, enabling memory corruption and potential sandbox escape. A public PoC exists via GHSA-897f-g5gm-fmxm. This detection surfaces vulnerable binaries, crate dependencies, and runtime process behavior indicative of guest-triggered miscompilation (crashes, SIGSEGV/SIGILL in JIT-compiled regions, and unexpected host access from Wasm workloads).
Vulnerability Intelligence
Public PoCAffected Software
- Vendor
- rust
- Product
- wasmtime
- Versions
- < 36.0.19, >= 37.0.0, < 43.0.0
Timeline
- Disclosed
- October 23, 2026
References & Proof of Concept
- PoChttps://github.com/advisories/GHSA-897f-g5gm-fmxm
- https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-897f-g5gm-fmxm
- https://github.com/bytecodealliance/wasmtime/pull/12613
- https://github.com/bytecodealliance/wasmtime/pull/14818
- https://github.com/bytecodealliance/wasmtime/commit/ba8f7d70caa1825b7f64fa75cd9d03f4a438dae0
- https://github.com/bytecodealliance/wasmtime/commit/f517bd6e890c7c1291ab9fe05d8cc0c9f11e56aa
- https://github.com/bytecodealliance/wasmtime/releases/tag/v36.0.19
- https://github.com/bytecodealliance/wasmtime/releases/tag/v43.0.0
- https://rustsec.org/advisories/RUSTSEC-2026-0380.html
CVSS
What is CVE-2026-115889 Wasmtime Cranelift Bit-Packing Silent Overflow Miscompilation (CVE-2026-115889)?
Wasmtime Cranelift Bit-Packing Silent Overflow Miscompilation (CVE-2026-115889) (CVE-2026-115889) maps to the Execution and Privilege Escalation tactics — the adversary is trying to run malicious code or instructions on a system in MITRE ATT&CK.
This page provides production-ready detection logic for Wasmtime Cranelift Bit-Packing Silent Overflow Miscompilation (CVE-2026-115889), covering the data sources and telemetry it touches: Microsoft Defender for Endpoint, DeviceProcessEvents. The queries below are rated critical severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.
MITRE ATT&CK
- Tactic
- Execution Privilege Escalation
// Detect vulnerable Wasmtime binaries/processes on managed endpoints (Microsoft Defender for Endpoint)
let vulnerableBelow36 = dynamic(["36.0.0","35","34","33","32","31","30"]);
DeviceProcessEvents
| where Timestamp > ago(7d)
| where FileName in~ ("wasmtime", "wasmtime.exe") or ProcessVersionInfoProductName has "wasmtime" or ProcessCommandLine has "wasmtime"
| extend Ver = extract(@"(\d+)\.(\d+)\.(\d+)", 0, ProcessVersionInfoProductVersion)
| extend Major = toint(extract(@"^(\d+)\.", 1, Ver)), Minor = toint(extract(@"^\d+\.(\d+)\.", 1, Ver)), Patch = toint(extract(@"^\d+\.\d+\.(\d+)", 1, Ver))
| extend IsVulnerable = iff(
(Major < 36) or
(Major == 36 and Minor == 0 and Patch < 19) or
(Major >= 37 and Major < 43), true, false)
| where IsVulnerable == true or isempty(Ver)
| project Timestamp, DeviceName, FileName, Ver, ProcessVersionInfoProductVersion, ProcessCommandLine, InitiatingProcessFileName, AccountName Identifies execution of Wasmtime binaries matching vulnerable version ranges (< 36.0.19 or >= 37.0.0 and < 43.0.0) via Defender for Endpoint process telemetry, including cases where version metadata is unavailable and warrants manual confirmation.
Data Sources
Required Tables
False Positives
- Patched Wasmtime builds that carry stale or inaccurate ProcessVersionInfoProductVersion metadata
- Vendored/embedded Wasmtime inside a host application that reports the host product name rather than wasmtime
- Developer or CI machines intentionally running older Wasmtime for regression testing in an isolated environment
Sigma rule & cross-platform mapping
The detection logic for Wasmtime Cranelift Bit-Packing Silent Overflow Miscompilation (CVE-2026-115889) (CVE-2026-115889) above is provided in a vendor-neutral
form so you can deploy it on any SIEM. The same logic is shipped here as native
KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the
following logsource:
logsource:
category: process_creation
product: windows Browse the community-maintained Sigma rules for this technique:
Platform-specific guides for CVE-2026-115889
References (9)
- https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-897f-g5gm-fmxm
- https://github.com/bytecodealliance/wasmtime/pull/12613
- https://github.com/bytecodealliance/wasmtime/pull/14818
- https://github.com/bytecodealliance/wasmtime/commit/ba8f7d70caa1825b7f64fa75cd9d03f4a438dae0
- https://github.com/bytecodealliance/wasmtime/commit/f517bd6e890c7c1291ab9fe05d8cc0c9f11e56aa
- https://github.com/bytecodealliance/wasmtime/releases/tag/v36.0.19
- https://github.com/bytecodealliance/wasmtime/releases/tag/v43.0.0
- https://rustsec.org/advisories/RUSTSEC-2026-0380.html
- https://github.com/advisories/GHSA-897f-g5gm-fmxm
Testing Methodology
Validate this detection against 3 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.
- Test 1 Detect vulnerable Wasmtime version via CLI
Expected signal: Process launch event for 'wasmtime' with version string 42.0.0 in the command line / version metadata.
- Test 2 Execute a trivial WebAssembly module through vulnerable Wasmtime
Expected signal: Wasmtime process launch with a .wat/.wasm argument on the command line, indicating guest module ingestion.
- Test 3 Inventory embedded Wasmtime crate version from Cargo.lock
Expected signal: File read / dependency-scan event exposing wasmtime crate version 40.0.1.
Response Playbook
Triage
- Confirm the exact Wasmtime version in scope: for standalone CLI run `wasmtime --version`; for embedded use inspect the application's `Cargo.lock` for the `wasmtime` crate version. Compare against affected ranges < 36.0.19 and >= 37.0.0, < 43.0.0.
- Determine whether the host accepts untrusted/attacker-supplied WebAssembly modules (multi-tenant serverless, plugin systems, edge compute). Hosts that only run first-party trusted Wasm are materially lower risk.
- Review process telemetry for the flagged host for abnormal Wasmtime terminations — SIGSEGV, SIGILL, SIGABRT, or Windows access-violation (0xC0000005) crashes — correlated with new or anomalous guest module loads.
- Check whether Cranelift JIT compilation is in use (default) versus the Winch baseline compiler or a precompiled AOT (.cwasm) artifact, since the defect is in the Cranelift optimizing path.
Containment
- Upgrade Wasmtime to a fixed release: 36.0.19 for the 36.x line, or 43.0.0+ for 37.x–42.x deployments. Rebuild and redeploy any application embedding the crate.
- Where immediate upgrade is not possible, restrict the runtime to execute only trusted, signed WebAssembly modules and disable ingestion of untrusted guest Wasm.
- For multi-tenant hosts, isolate or suspend tenants supplying unverified modules and apply additional OS-level sandboxing (seccomp, separate process/user, memory limits) around the Wasmtime process.
Evidence Collection
- Capture the suspect WebAssembly module(s), the Wasmtime version, launch command line, and any generated .cwasm cache artifacts for offline analysis.
- Collect crash evidence: core dumps, Windows error reports / WER dumps, and kernel/EDR records of the faulting process and faulting address within JIT-compiled memory regions.
- Preserve `Cargo.lock`, build manifests, and container image digests to establish the precise deployed version and provenance.
Escalation Criteria
- ! Escalate to incident response if a vulnerable host runs untrusted Wasm AND shows crashes or anomalous host-resource access (unexpected file/network syscalls) coincident with guest module execution — treat as potential sandbox escape.
- ! Escalate if the captured module reproduces miscompilation/memory corruption in an isolated reproduction environment, or matches the public PoC from GHSA-897f-g5gm-fmxm.
- ! Escalate to vendor/platform owners if the vulnerable runtime is embedded in a widely deployed product requiring coordinated patch rollout.
Investigation Guide
Forensic Artifacts
- >
Wasmtime version metadata (binary version info / Cargo.lock entry) - >
Cached compiled module artifacts (.cwasm files) in the Wasmtime module cache directory - >
Process crash dumps / core files showing faults in JIT-compiled memory regions - >
The attacker-supplied .wasm/.wat module and its ingestion logs
Tuning Guidance
Baseline the set of hosts legitimately running Wasmtime and the versions they carry; once an inventory is established, suppress known-patched (36.0.19+, 43.0.0+) hosts and alert only on vulnerable-range matches or on new/unexpected Wasmtime installations. If the runtime is embedded and does not expose a parseable version string, pivot to software-inventory/SBOM (Cargo.lock) scanning rather than process-version parsing to reduce null-version noise. Prioritize alerts from hosts that ingest untrusted WebAssembly.
Hunting Queries
Hunts for Wasmtime executions temporally correlated with process crash events (SIGSEGV/SIGILL/access violations), a behavioral indicator of triggered miscompilation or attempted sandbox escape.
DeviceProcessEvents | where FileName in~ ("wasmtime","wasmtime.exe") or ProcessCommandLine has "wasmtime" | join kind=inner (DeviceEvents | where ActionType in ("ProcessCrash","AppCrash")) on DeviceId | project Timestamp, DeviceName, ProcessCommandLine, ActionType index=endpoint (process="*wasmtime*") OR (sourcetype=*crash* "wasmtime") | transaction host maxspan=5m | search (SIGSEGV OR SIGILL OR 0xC0000005 OR access_violation) | table _time host process Atomic Red Team Tests
Installs and runs a Wasmtime version within the vulnerable range and queries its version, generating process telemetry that the detection should flag.
Command
curl -sSfL https://github.com/bytecodealliance/wasmtime/releases/download/v42.0.0/wasmtime-v42.0.0-x86_64-linux.tar.xz -o /tmp/wt.tar.xz && tar -xf /tmp/wt.tar.xz -C /tmp && /tmp/wasmtime-v42.0.0-x86_64-linux/wasmtime --version Cleanup
rm -rf /tmp/wt.tar.xz /tmp/wasmtime-v42.0.0-x86_64-linux Expected Telemetry
Process launch event for 'wasmtime' with version string 42.0.0 in the command line / version metadata.
Expected Detection
Detection flags the execution as is_vulnerable=true because 42.0.0 falls in the >= 37.0.0, < 43.0.0 range.
Runs a benign .wat module through a vulnerable Wasmtime build to simulate guest module execution that could carry a malicious payload in a real attack.
Command
printf '(module (func (export \"main\")))' > /tmp/t.wat && /tmp/wasmtime-v42.0.0-x86_64-linux/wasmtime run --invoke main /tmp/t.wat Cleanup
rm -f /tmp/t.wat Expected Telemetry
Wasmtime process launch with a .wat/.wasm argument on the command line, indicating guest module ingestion.
Expected Detection
Detection correlates vulnerable Wasmtime execution with module ingestion on the command line.
Scans a Rust project's Cargo.lock for a vulnerable wasmtime crate dependency, modeling SBOM-based detection of embedded vulnerable runtimes.
Command
printf '[[package]]\nname = \"wasmtime\"\nversion = \"40.0.1\"\n' > /tmp/Cargo.lock && grep -A1 'name = "wasmtime"' /tmp/Cargo.lock Cleanup
rm -f /tmp/Cargo.lock Expected Telemetry
File read / dependency-scan event exposing wasmtime crate version 40.0.1.
Expected Detection
SBOM/dependency scanning flags wasmtime 40.0.1 as within the vulnerable >= 37.0.0, < 43.0.0 range.