Skip to main content

Wasmi CVE-2025-66627

HIGH
Use After Free (CWE-416)
2025-12-09 security-advisories@github.com
7.8
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Submit crafted WebAssembly module to host
  2. Delivery
    Trigger specific linear memory growth
  3. Exploit
    Exploit use-after-free in linear memory
  4. Execution
    Gain attacker-controlled read/write in host memory
  5. Impact
    Execute code or exfiltrate data in host process

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires a host application that embeds Wasmi (vulnerable ranges: >=0.41.0 <0.41.2, >=0.42.0 <0.47.1, >=0.50.0 <0.51.3, and 1.0.0) AND executes attacker-influenced WebAssembly modules; the flaw is reached only when a guest module drives Wasmi's linear memory through 'certain memory growth conditions' (i.e. exercising memory.grow / linear-memory reallocation paths). Exploitation is LIMITED by the need to supply and run a module (PR:L - not fully anonymous unless the embedding exposes WASM execution to untrusted input) and by deployment: hosts that run only trusted, first-party modules are not practically exposed. The documented workaround - capping maximum linear memory sizes - constrains the growth conditions and reduces exploitability where configurable.

Impact

Signals are moderately consistent but point to a conditional, not a mass-exploitation, threat. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8 HIGH) describes a locally-reachable flaw with low attack complexity and some privilege required, yielding full confidentiality/integrity/availability impact within an unchanged scope - consistent with a use-after-free (CWE-416) in the interpreter's linear memory that an attacker-supplied WebAssembly module triggers. EPSS is very low (0.15%, 3rd percentile), the CVE is NOT on CISA KEV, and no public exploit was provided in the input, so there is no evidence of active or imminent widespread exploitation. The key nuance for interpreting 'AV:L/PR:L': in a Wasmi embedding the real threat surface is any host that executes untrusted/guest WebAssembly, where 'supplying a module' is the intended low-privilege capability - so for sandboxing or plugin/blockchain use cases this is effectively a sandbox-escape primitive and should be prioritized, whereas hosts that only run trusted, first-party modules face little practical risk. Net: a genuinely serious memory-safety bug (GHSA labels it 'Critical') worth prompt patching for anyone running untrusted WASM, but low real-world exploitation pressure today per EPSS/KEV. No conflicting data of note; vector and description align.

Exploit ScenarioDerived

An application embeds Wasmi to run untrusted or third-party WebAssembly modules (e.g. a plugin host or on-chain runtime). An attacker submits a crafted module that forces specific linear-memory growth conditions, triggering the use-after-free to read or corrupt host memory and potentially execute code in the host process. No public exploit code was identified at time of analysis, so this reflects the described capability rather than a weaponized PoC.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

Use-after-free in Wasmi's linear memory implementation, triggered when a WebAssembly module drives memory growth, can lead to memory corruption, information disclosure, or code execution in host applications that embed the interpreter (versions 0.41.0-0.41.1, 0.42.0-0.47.0, 0.50.0-0.51.2, and 1.0.0). Exploitation requires local access and the ability to supply a malicious module (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8); hosts running only trusted, first-party modules are not practically exposed. No public exploit identified at time of analysis and EPSS is low (0.15%, percentile 3%); vendor patches are available in 0.41.2, 0.47.1, 0.51.3, and 1.0.1.

RemediationAI

Upgrade Wasmi to a fixed release: 0.41.2, 0.47.1, 0.51.3, or 1.0.1, respectively, depending on the current version. The patch commit is https://github.com/wasmi-labs/wasmi/commit/0e6f0d2a8325602c58d6a53ce1c0e6045eb6a490. For environments where upgrading is not immediately possible, the vendor recommends limiting the maximum linear memory sizes where feasible; this constrains the memory growth conditions that trigger the use-after-free, but it may break modules that legitimately require large linear memories. Note that hosts running only trusted, first-party WebAssembly modules are not practically exposed, so the urgency depends on whether untrusted modules are executed. See the advisory for details.

Affected Packages

cargo wasmi fix: 0.41.2, 0.47.1, 0.51.3, 1.0.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in cargo

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Wasmi is a WebAssembly interpreter written in Rust and distributed as the rust/wasmi crate, used in constrained and embedded systems. The vulnerability is a use-after-free (CWE-416) in the linear memory implementation. Linear memory is the contiguous, resizable byte array that a WebAssembly module uses for its heap; when a guest module calls memory.grow, the host may reallocate the backing store. Under certain growth conditions, the reallocation leaves a dangling reference that can be accessed later, causing a use-after-free. The affected CPE is cpe:2.3:a:wasmi-labs:wasmi (rust). Because Wasmi is an interpreter, the attack surface is any host application that embeds it and executes untrusted or attacker-influenced WebAssembly modules; trusted-module-only deployments are not practically exposed. The CVSS vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) indicates local access with low privileges required to supply the module.

Know when Wasmi gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

NVD PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Attacker must supply a module to the local interpreter (AV:L, PR:L), triggering conditions are reliably reachable (AC:L), and UAF yields full memory read/corrupt/crash impact (C/I/A:H).

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from NVD.

CVSS VectorNVD

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionNVD

Wasmi is a WebAssembly interpreter focused on constrained and embedded systems. In versions 0.41.0, 0.41.1, 0.42.0 through 0.47.1, 0.50.0 through 0.51.2 and 1.0.0, Wasmi's linear memory implementation leads to a Use After Free vulnerability, triggered by a WebAssembly module under certain memory growth conditions. This issue potentially leads to memory corruption, information disclosure, or code execution. This issue is fixed in versions 0.41.2, 0.47.1, 0.51.3 and 1.0.1. To workaround this issue, consider limiting the maximum linear memory sizes where feasible.

Executive ViewAI

Why It Matters

The Wasmi WebAssembly interpreter, embedded in host applications to execute WebAssembly modules, contains a high-severity use-after-free vulnerability that could allow attackers to achieve code execution or access sensitive data when processing malicious modules. Organizations that use Wasmi to run untrusted WebAssembly from external sources are most at risk, as a successful exploit could compromise the host application and its data, though exploitation requires local access and low privileges. No public exploit has been identified at this time, but vendor patches are available and should be applied promptly to mitigate potential business disruption and data loss.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
popular Rust WASM interpreter for embedded/blockchain, but niche vs ubiquitous runtimes
Data Quality
4 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Affected Products (CPE)NVD

cpe:2.3:a:wasmi-labs:wasmi:*:*:*:*:*:rust:*:*
cpe:2.3:a:wasmi-labs:wasmi:*:*:*:*:*:rust:*:*
cpe:2.3:a:wasmi-labs:wasmi:*:*:*:*:*:rust:*:*
cpe:2.3:a:wasmi-labs:wasmi:1.0.0:*:*:*:*:rust:*:*

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy