CVE-2026-115393 is a type confusion vulnerability in the bytecodealliance wasmtime project affecting multiple version ranges prior to fixed releases. The flaw arises because several Store APIs do not validate that objects belong to the Store's Engine, allowing embedders mixing objects between Engines to cause trampoline signature mismatches. This can lead to out-of-bounds stack writes, garbage collector heap corruption, or panics. The vulnerability has a low CVSS 4.0 base score and requires high privileges and user interaction to exploit.
CVE-2026-115392 is a high-severity vulnerability in the bytecodealliance wasmtime runtime that allows filesystem sandbox escape. It affects multiple version ranges before specific fixed releases. The issue arises because the cap-std dependency mishandles 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 can read host files via preexisting symlinks. The vulnerability is fixed in versions 24.0.13, 36.0.14, 46.0.3, and 47.0.4.
CVE-2026-115391 is a vulnerability in the WASIp3 implementation of wasmtime versions 46.0.0 before 46.0.3 and 47.0.0 before 47.0.4. It allows guest-specified-length writes to be buffered without limits, which can cause excessive memory consumption on the host system and potentially exhaust host memory resources.
CVE-2026-115390 is a vulnerability in bytecodealliance's wasmtime affecting versions 47.0.0 before 48.0.3 and 49.0.0 before 49.0.1. It involves a fuel accounting flaw in Cranelift-compiled call_ref and try_table catch paths that allows malicious guests to reset consumed fuel, enabling them to run code exponentially longer on linear fuel and evade timeouts and periodic yields. This can lead to denial of service conditions.
CVE-2026-115389 is a 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 flaw involves improper accounting of host memory allocations when lifting guest values through the Val API, allowing a malicious WebAssembly guest to allocate significantly more host memory than tracked, bypassing hostcall fuel limits and causing denial of service.
CVE-2026-115388 is a vulnerability in wasmtime-wasi-http in Wasmtime versions before 36.0.16, 37.0.0 before 48.0.3, and 49.0.0 before 49.0.1. The flaw allows malicious guests to bypass the wasi:io/streams check-write allowance for outgoing HTTP bodies, enabling oversized writes that do not trap as intended. This can lead to uncontrolled resource consumption by holding host memory allocations for the store's lifetime, potentially exhausting host memory.
CVE-2026-115387 is a denial of service vulnerability in the bytecodealliance wasmtime-wasi component. It allows guest WASI programs to cause the host to panic by passing filesystem timestamp values with overflowing sub-second fields, resulting in a crash. Multiple version ranges of wasmtime are affected, with fixes available in versions 36.0.16, 48.0.3, and 49.0.1.
CVE-2026-115386 is an information disclosure vulnerability in the WASIp1 fd_readdir implementation of bytecodealliance's wasmtime. It affects versions before 36.0.17, versions from 37.0.0 up to but not including 48.0.4, and versions from 49.0.0 up to but not including 49.0.2. The flaw causes uninitialized struct padding to be copied into guest memory, allowing guests with a preopened directory to receive three bytes of leftover host stack or heap memory per directory entry.
CVE-2026-115385 is a denial of service vulnerability in bytecodealliance's wasmtime versions 46.0.0 before 48.0.4 and 49.0.0 before 49.0.2. The flaw exists in the wasmtime-wasi WASIp3 implementation, where guests with mutable preopened directory access can cause the Unix host process to abort by invoking set-times or set-times-at with negative timestamps before the epoch, triggering an assertion failure that crashes the host.
Wasmtime versions 39.0.0 before 48.0.4 and 49.0.0 before 49.0.2 contain a critical stack buffer overflow vulnerability. This flaw allows malicious guests to write approximately 16KB to the native stack by supplying mistyped async callback result types, potentially overwriting return addresses. Exploitation can lead to host crashes or sandbox escapes.
CVE-2026-115383 is a vulnerability in bytecodealliance's Wasmtime affecting versions 47.0.0 before 48.0.4 and 49.0.0 before 49.0.2. It involves improper validation of WebAssembly tags with subtypes, allowing malicious guests to mis-type exception object payloads. This can corrupt the garbage-collected heap and cause Wasmtime to panic when the exceptions proposal is enabled.
CVE-2026-115382 is a denial-of-service vulnerability in the wasi:http implementation of wasmtime versions 46.0.0 before 48.0.4 and 49.0.0 before 49.0.2. It allows a guest to cause the host to panic and crash by specifying a zero between-bytes-timeout request option, which is passed directly to a Tokio API that triggers the panic.
CVE-2026-115381 is a medium severity vulnerability in the bytecodealliance wasmtime project affecting versions before 36.0.17, between 37.0.0 and 48.0.4, and between 49.0.0 and 49.0.2. It involves unbounded memory allocation in the wasmtime-wasi WASIp2 write-zeroes method of SinkOutputStream, which is used by default when stdout/stderr are not configured. A malicious WebAssembly guest can exploit this to request large zero-filled writes, exhausting host memory and causing a denial of service.
CVE-2026-115380 is a denial of service vulnerability in the wasmtime-wasi WASI preview 0 poll_oneoff adapter of the wasmtime runtime. The flaw allows malicious guest modules to submit many subscriptions, causing O(n) host work per subscription without consuming or checking fuel limits, leading to long-running host computations. This affects multiple versions of wasmtime prior to fixed releases.
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 vulnerability arises from missing garbage collection rooting that leaves references unrooted across try_call when compiling WebAssembly modules. This flaw can lead to garbage collection heap corruption or incorrect execution when attackers supply specially crafted Wasm modules. The issue has been fixed in versions 48.0.4 and 49.0.2.
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.
Wasmtime is a runtime for WebAssembly. Prior to 24.0.7, 36.0.7, 42.0.2, and 43.0.1, Wasmtime's implementation of transcoding strings between components contains a bug where the return value of a guest component's realloc is not validated before the host attempts to write through the pointer. This enables a guest to cause the host to write arbitrary transcoded string bytes to an arbitrary location up to 4GiB away from the base of linear memory. These writes on the host could hit unmapped memory or could corrupt host data structures depending on Wasmtime's configuration. Wasmtime by default reserves 4GiB of virtual memory for a guest's linear memory meaning that this bug will by default on hosts cause the host to hit unmapped memory and abort the process due to an unhandled fault. Wasmtime can be configured, however, to reserve less memory for a guest and to remove all guard pages, so some configurations of Wasmtime may lead to corruption of data outside of a guest's linear memory, such as host data structures or other guests's linear memories. This vulnerability is fixed in 24.0.7, 36.0.7, 42.0.2, and 43.0.1.