CVE-2023-26489 is a critical-severity (CVSS 9.9) Out-of-bounds Read vulnerability in wasmtime. A fix is available for wasmtime — see the affected versions and patch details below.
Guest-controlled out-of-bounds read/write on x86_64 in wasmtime
Exploitation Status
No confirmed exploitation observed yet
- A successful exploit gives an attacker total control of the affected component, not partial access.
- CISA’s own triage has not observed active exploitation or public proof-of-concept code for this CVE as of its last assessment.
Exploitation and automatability from CISA’s SSVC triage for CVE-2023-26489.
EPSS Exploitation Probability
EPSS (Exploit Prediction Scoring System) is a daily probability model maintained by FIRST.org. It estimates the likelihood a CVE will be exploited in production environments within the next 30 days, derived from real-world threat intelligence signals.
How urgent is this, really
CVE-2023-26489 plotted by exploitation likelihood (EPSS) against impact (CVSS). The shaded corner — EPSS 50%+ and CVSS 7.0+ — is where this CVE doesn't sit, though severity or exploitability alone can still warrant action.
Where this sits among everything scored
Of 377,333 CVEs with a current EPSS score, this one falls in the < 10% band (highlighted). Real counts from FIRST.org, not a sample — log-scaled since the landscape is heavily right-skewed.
Real-World Exposure
wasmtime🦀wasmtime🦀wasmtime🦀cranelift-codegen🦀cranelift-codegen🦀cranelift-codegenReal-time download stats are indexed for npm and PyPI packages. This vulnerability affects crates.io packages — download data is not available via public APIs for these ecosystems.
Description
wasmtime is a fast and secure runtime for WebAssembly. In affected versions wasmtime's code generator, Cranelift, has a bug on x86_64 targets where address-mode computation mistakenly would calculate a 35-bit effective address instead of WebAssembly's defined 33-bit effective address. This bug means that, with default codegen settings, a wasm-controlled load/store operation could read/write addresses up to 35 bits away from the base of linear memory. Due to this bug, however, addresses up to 0xffffffff * 8 + 0x7ffffffc = 36507222004 = ~34G bytes away from the base of linear memory are possible from guest code. This means that the virtual memory 6G away from the base of linear memory up to ~34G away can be read/written by a malicious module. A guest module can, without the knowledge of the embedder, read/write memory in this region. The memory may belong to other WebAssembly instances when using the pooling allocator, for example. Affected embedders are recommended to analyze preexisting wasm modules to see if they're affected by the incorrect codegen rules and possibly correlate that with an anomalous number of traps during historical execution to locate possibly suspicious modules. The specific bug in Cranelift's x86_64 backend is that a WebAssembly address which is left-shifted by a constant amount from 1 to 3 will get folded into x86_64's addressing modes which perform shifts. For example (i32.load (i32.shl (local.get 0) (i32.const 3))) loads from the WebAssembly address $local0 << 3. When translated to Cranelift the $local0 << 3 computation, a 32-bit value, is zero-extended to a 64-bit value and then added to the base address of linear memory. Cranelift would generate an instruction of the form movl (%base, %local0, 8), %dst which calculates %base + %local0 << 3. The bug here, however, is that the address computation happens with 64-bit values, where the $local0 << 3 computation was supposed to be truncated to a a 32-bit value. This means that %local0, which can use up to 32-bits for an address, gets 3 extra bits of address space to be accessible via this movl instruction. The fix in Cranelift is to remove the erroneous lowering rules in the backend which handle these zero-extended expression. The above example is then translated to movl %local0, %temp; shl $3, %temp; movl (%base, %temp), %dst which correctly truncates the intermediate computation of %local0 << 3 to 32-bits inside the %temp register which is then added to the %base value. Wasmtime version 4.0.1, 5.0.1, and 6.0.1 have been released and have all been patched to no longer contain the erroneous lowering rules. While updating Wasmtime is recommended, there are a number of possible workarounds that embedders can employ to mitigate this issue if updating is not possible. Note that none of these workarounds are on-by-default and require explicit configuration: 1. The Config::static_memory_maximum_size(0) option can be used to force all accesses to linear memory to be explicitly bounds-checked. This will perform a bounds check separately from the address-mode computation which correctly calculates the effective address of a load/store. Note that this can have a large impact on the execution performance of WebAssembly modules. 2. The Config::static_memory_guard_size(1 << 36) option can be used to greatly increase the guard pages placed after linear memory. This will guarantee that memory accesses up-to-34G away are guaranteed to be semantically correct by reserving unmapped memory for the instance. Note that this reserves a very large amount of virtual memory per-instances and can greatly reduce the maximum number of concurrent instances being run. 3. If using a non-x86_64 host is possible, then that will also work around this bug. This bug does not affect Wasmtime's or Cranelift's AArch64 backend, for example.
Affected Packages
| Ecosystem | Package | Vulnerable range | Fix |
|---|---|---|---|
| 🦀crates.io | wasmtime | ≥ 0.37.0&&< 4.0.1 | 4.0.1cargo update -p wasmtime --precise 4.0.1 |
| 🦀crates.io | wasmtime | ≥ 5.0.0&&< 5.0.1 | 5.0.1cargo update -p wasmtime --precise 5.0.1 |
| 🦀crates.io | wasmtime | ≥ 6.0.0&&< 6.0.1 | 6.0.1cargo update -p wasmtime --precise 6.0.1 |
| 🦀crates.io | cranelift-codegen | ≥ 0.84.0&&< 0.91.1 | 0.91.1cargo update -p cranelift-codegen --precise 0.91.1 |
| 🦀crates.io | cranelift-codegen | ≥ 0.92.0&&< 0.92.1 | 0.92.1cargo update -p cranelift-codegen --precise 0.92.1 |
| 🦀crates.io | cranelift-codegen | ≥ 0.93.0&&< 0.93.1 | 0.93.1cargo update -p cranelift-codegen --precise 0.93.1 |
Detection & mitigation playbook
Open-source dependencyDetect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for wasmtime, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.
Fix
Update wasmtime to 4.0.1 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms CVE-2023-26489 is resolved across your whole dependency graph.
Workarounds
If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.
How O3 protects you
O3 Security's impact-aware SCA analyses which vulnerable code paths your application actually calls, so a match like CVE-2023-26489 can be triaged on real exposure rather than presence alone.
Tailored to CVE-2023-26489. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.
Frequently Asked Questions
Is CVE-2023-26489 in your dependencies?
O3 Security finds CVE-2023-26489 across crates.io dependencies, including transitive ones, and its impact-aware SCA ranks findings by whether your code actually calls the vulnerable path.