CVE-2026-126409 in Wasmtimeinfo

Summary

by MITRE • 11/13/2026

Wasmtime 47.0.0 before 48.0.8, 49.0.0 before 49.0.5, and 50.0.0 before 50.0.1 contains a cross-engine type confusion vulnerability because StructType::with_finality_and_supertype does not validate that the supplied supertype belongs to the same Engine. Embedders using multiple engines that create a GC struct type with another engine's supertype can trigger runtime panics or GC heap corruption, causing denial of service; guest WebAssembly cannot trigger it.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/13/2026

The vulnerability identified in Wasmtime versions 47.0.0 through 48.0.8, 49.0.0 through 49.0.5, and 50.0.0 through 50.0.1 represents a critical cross-engine type confusion flaw within the WebAssembly runtime environment. This issue stems from an insufficient validation mechanism in the StructType::with_finality_and_supertype function, which fails to verify that a supplied supertype originates from the same engine instance as the struct being constructed. In systems utilizing multiple isolated Wasmtime engines for security or performance isolation, this oversight allows an embedder application to inadvertently mix type definitions across different runtime contexts. The core technical failure lies in the assumption of type compatibility based solely on structural similarity rather than strict identity checks against the specific engine's internal registry, leading to a breakdown in the memory safety guarantees that WebAssembly is designed to provide.

From a security architecture perspective, this flaw aligns with CWE-841, which describes Improper Enforcement of Behavioral Constraints, specifically regarding type system integrity and cross-context validation failures. The vulnerability enables an attacker who controls the embedder application logic or can influence its configuration to trigger undefined behavior within the runtime. Because WebAssembly relies heavily on strict memory isolation and predictable execution environments, bypassing these engine-level boundaries compromises the fundamental security model of the platform. While guest WebAssembly code itself cannot directly exploit this condition due to the sandboxed nature of wasm modules, the vulnerability targets the host-side embedder API, making it a significant risk for applications that integrate Wasmtime as a library and manage multiple execution contexts concurrently.

The operational impact of exploiting this type confusion is severe, primarily manifesting as denial of service through runtime panics or heap corruption within the garbage collection subsystem. When an invalid supertype from one engine is applied to a struct in another, the internal data structures representing object hierarchies become inconsistent. This inconsistency can lead to memory corruption during garbage collection cycles, where the collector attempts to traverse or finalize objects based on corrupted type metadata. Such corruption may result in crashes, data leakage if adjacent memory regions are exposed, or unstable runtime behavior that disrupts service availability. The severity is heightened by the fact that heap corruption issues often have broader implications for system stability and can potentially be chained with other vulnerabilities to achieve arbitrary code execution, although direct exploitation from guest code remains impossible.

Mitigation strategies must focus on immediate software updates and architectural hardening of embedder implementations. Users running affected versions should upgrade Wasmtime to version 48.0.8 or later for the 48.x branch, 49.0.5 or later for the 49.x branch, and 50.0.1 or later for the 50.x branch, as these releases include patches that enforce strict engine identity checks before allowing type associations. For developers integrating Wasmtime into multi-engine architectures, it is critical to ensure that all type definitions are created within a single engine instance when they need to be related via inheritance or supertype relationships. Additionally, implementing rigorous validation layers in the embedder code can help detect and reject cross-engine type operations before they reach the runtime core. This vulnerability also relates to ATT&CK technique T1059, Command and Scripting Interpreter, specifically regarding abuse of system APIs for execution environment manipulation, although its primary classification remains a memory safety violation due to improper input validation in C++ codebases.

Responsible

VulnCheck

Reservation

11/10/2026

Disclosure

11/13/2026

Moderation

accepted

CPE

ready

EPSS

0.00206

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!