CVE-2026-115393 is a type confusion vulnerability in the bytecodealliance wasmtime project affecting multiple version ranges before specific fixed releases. The flaw arises because certain Store APIs do not validate that objects belong to the Store's Engine, allowing embedders to mix objects between Engines. This can cause trampoline signature mismatches leading to out-of-bounds stack writes, garbage collector heap corruption, or panics.
CVE-2026-115392 is a high-severity vulnerability in the bytecodealliance wasmtime runtime affecting multiple version ranges before specific fixed releases. It allows a filesystem sandbox escape via mishandling of symbolic links with trailing slashes on macOS and Linux kernels lacking openat2 support. This flaw enables a guest with write access to any sandboxed directory to read and write any host-accessible file, and read-only guests to read host files through preexisting symlinks.
Wasmtime versions 46.0.0 before 46.0.3 and 47.0.0 before 47.0.4 contain a vulnerability in the WASIp3 implementation where guest-specified-length writes are buffered without limits. This can lead to excessive memory consumption on the host system, potentially exhausting host memory resources.
Wasmtime 47.0.0 before 48.0.3 and 49.0.0 before 49.0.1 contains a fuel accounting flaw in Cranelift-compiled call_ref and try_table catch paths. Malicious guests can reset consumed fuel after calls to run exponentially long on linear fuel, evading timeouts and periodic yields for denial of service.
CVE-2026-115389 is a resource allocation vulnerability in bytecodealliance's wasmtime affecting versions before 36.0.16, between 37.0.0 and before 48.0.3, and between 49.0.0 and before 49.0.1. The issue arises because wasmtime does not properly account for host memory allocations when lifting guest values via the Val API, allowing a malicious WebAssembly guest to allocate significantly more host memory than tracked. This can lead to denial of service due to resource exhaustion. The vulnerability has a low severity rating and no known exploits in the wild. No patch links are provided in the input data.
CVE-2026-115388 is a vulnerability in the wasmtime-wasi-http component of Wasmtime that allows uncontrolled resource consumption. Versions before 36.0.16, 37.0.0 before 48.0.3, and 49.0.0 before 49.0.1 do not enforce the wasi:io/streams check-write allowance for WASIp2 outgoing HTTP bodies. This flaw permits a malicious guest to write oversized buffers to outgoing HTTP body resources, causing host memory exhaustion by holding allocations for the store's lifetime.
CVE-2026-115387 is a denial of service vulnerability in bytecodealliance's wasmtime-wasi component. It affects multiple version ranges of wasmtime before specific fixed versions. The flaw allows guest WASI programs to cause the host to panic by passing filesystem timestamp values with overflowing sub-second fields, leading to a crash.
Wasmtime before 36.0.17, 37.0.0 before 48.0.4, and 49.0.0 before 49.0.2 contains an information disclosure vulnerability in the WASIp1 fd_readdir implementation that copies uninitialized struct padding into guest memory. Guests with a preopened directory can list entries to receive three bytes of leftover host stack or heap memory per directory entry.
Wasmtime 46.0.0 before 48.0.4 and 49.0.0 before 49.0.2 contains a denial of service vulnerability in the wasmtime-wasi WASIp3 implementation that allows guests to abort the Unix host process. Guests with mutable preopened directory access can call set-times or set-times-at with negative seconds timestamps before the epoch, triggering an assertion failure that crashes the host.
CVE-2026-115384 is a critical stack buffer overflow vulnerability in bytecodealliance's wasmtime affecting versions 39.0.0 before 48.0.4 and 49.0.0 before 49.0.2. It arises from improper input validation of async callback result types, allowing malicious guests to write approximately 16KB to the native stack. This can lead to crashing the host or escaping the sandbox environment.
Wasmtime versions 47.0.0 before 48.0.4 and 49.0.0 before 49.0.2 have an improper validation vulnerability related to WebAssembly tags with subtypes. This flaw allows malicious guests to mis-type exception object payloads, potentially corrupting the garbage-collected heap and causing Wasmtime to panic when the exceptions proposal is enabled.
Wasmtime 46.0.0 before 48.0.4 and 49.0.0 before 49.0.2 contains a denial-of-service vulnerability in its wasi:http implementation that allows guests to panic the host. Guests can specify a zero between-bytes-timeout request option, which is forwarded directly to a Tokio API that panics, crashing the host embedding.
Wasmtime before 36.0.17, 37.0.0 before 48.0.4, and 49.0.0 before 49.0.2 contains an unbounded memory allocation in the wasmtime-wasi WASIp2 write-zeroes method of SinkOutputStream, the default stream used when stdout/stderr are not configured. A malicious WebAssembly guest can request huge zero-filled writes, exhausting host memory and causing denial of service.
Wasmtime before 36.0.17, 37.0.0 before 48.0.4, and 49.0.0 before 49.0.2 contains a denial of service vulnerability in the wasmtime-wasi WASI preview 0 poll_oneoff adapter, which performs O(n) host work per subscription without consuming or checking fuel. Malicious guest modules can pass many subscriptions to force long-running host computation that ignores configured fuel limits.
CVE-2026-115379 is a use-after-free vulnerability in bytecodealliance's wasmtime affecting versions 47.0.0 before 48.0.4 and 49.0.0 before 49.0.2. The flaw involves missing garbage collection rooting that leaves references unrooted across try_call when compiling WebAssembly modules. This can cause garbage collection heap corruption or incorrect execution when attackers supply specially crafted Wasm modules.
Wasmtime, a WebAssembly runtime, contains a vulnerability in its handling of bulk-data-transfer instructions like memory.copy when combined with preemption via epochs or fuel and store state mutations or computation cancellations. This can lead to exposure of intermediate internal states, causing semantic inconsistencies and potential segfaults. The issue affects embedders using Store::epoch_deadline_callback and performing store mutations or resuming computations after cancellation. Wasmtime versions 46.0.0 up to but not including 46.0.2 and 47.0.0 up to but not including 47.0.3 are affected. The vulnerability is fixed in versions 46.0.2 and 47.0.3 by reverting to a behavior that avoids preemption points during these operations.
Wasmtime is a runtime for WebAssembly. In versions prior to 24.0.9, 36.0.10, and 44.0.2, when a filesystem preopen is given DirPerms::all() and FilePerms::READ without FilePerms::WRITE, this access control mechanism can be bypassed via the wasip2 descriptor.open-at or wasip1 path_open interfaces by opening a file with only the OpenFlags::TRUNCATE oflag. The root cause is that the clause handling OpenFlags::TRUNCATE in crates/wasi/src/filesystem.rs (Dir::open_at, lines 967–969) did not set open_mode |= OpenMode::WRITE;, which is later used for the access control check against FilePerms to determine whether opening the file is permitted; the single-line fix adds that missing assignment, after which the affected calls correctly fail with error-code.not-permitted and ERRNO_PERM respectively. Only wasmtime-wasi embeddings that combine DirPerms::MUTATE with FilePerms::READ are affected by this bug. In particular, the Wasmtime project's wasmtime-cli's use of wasmtime-wasi is not affected, because it always sets FilePerms::all() for all preopens. This issue has been fixed in versions 24.0.9, 36.0.10 and44.0.2.
Wasmtime is a runtime for WebAssembly. From 30.0.0 to 36.0.8, 43.0.2, and 44.0.1, Wasmtime's allocation logic for a WebAssembly table contained checked arithmetic which panicked on overflow. This overflow is possible to trigger, and thus panic, when a table with an extremely large size is allocated. This is possible with the WebAssembly memory64 proposal where tables can have sizes in the 64-bit range as opposed to the previous 32-bit range which would not overflow. The panic happens when attempting to create a very large table, such as when instantiating a WebAssembly module or component. This vulnerability is fixed in 36.0.8, 43.0.2, and 44.0.1.
Wasmtime is a runtime for WebAssembly. From 25.0.0 to before 36.0.7, 42.0.2, and 43.0.1, Wasmtime's Winch compiler contains a bug where a 64-bit table, part of the memory64 proposal of WebAssembly, incorrectly translated the table.size instruction. This bug could lead to disclosing data on the host's stack to WebAssembly guests. The host's stack can possibly contain sensitive data related to other host-originating operations which is not intended to be disclosed to guests. This bug specifically arose from a mistake where the return value of table.size was statically typed as a 32-bit integer, as opposed to consulting the table's index type to see how large the returned register could be. When combined with details about Wnich's ABI, such as multi-value returns, this can be combined to read stack data from the host, within a guest. This vulnerability is fixed in 36.0.7, 42.0.2, and 43.0.1.