Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconLure victim to malicious page
-
DeliveryServe crafted WASM module with ESM JS import
-
ExploitTrigger dangling FunctionType reference
-
InstallEmpty result poisons destination register
-
C2array.set bit-casts value to ArrayInstance pointer
-
ExecuteAchieve arbitrary write
-
ImpactExecute code in WebContent process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Expired pointer prevention
|
| Exploitation Conditions | Exploitation requires the victim to load attacker-controlled HTML in Ladybird (UI:A - active user interaction, e.g., visiting a page) and specifically requires the WebAssembly ESM-integration path: a WebAssembly module must import a JavaScript function via ESM so that WebAssemblyModule.cpp routes creation through create_host_function with the stack-local Wasm::FunctionType. The standard WebAssembly.instantiate path does NOT trigger the bug (it uses a long-lived reference), so the ESM import mechanism is a hard prerequisite. Successful escalation also requires the WASM module to declare a statically non-empty result type whose stale/empty runtime result leaves an attacker-influenced value consumed by the WASM-GC array.set handler. No authentication is needed (PR:N), but exploitation is limited by high attack complexity and a present attack requirement (AC:H/AT:P) - indicative of a race/timing window and precise heap layout control - and by Ladybird's small deployment footprint. WebAssembly and WASM-GC support must be enabled (default in affected builds). |
| Impact | Signals are mostly aligned toward genuine severity but tempered by exploitation difficulty and deployment scope. The CVSS 4.0 base score is 8.9 with vector AV:N/AC:H/AT:P/PR:N/UI:A/VC:H/VI:H/VA:H and subsequent-system impact SC:H/SI:H/SA:H - network reach, no privileges, but high attack complexity (AC:H) plus a present attack requirement (AT:P, consistent with the race/timing and precise heap grooming the primitive implies) and required active user interaction (UI:A, victim must visit a page). Publicly available exploit code (VulnCheck PoC) meaningfully raises real-world risk, but the CVE is NOT in CISA KEV and there is no evidence of active exploitation, so this is 'PoC exists' rather than 'exploited in the wild' - those are distinct signals. No EPSS score was provided, so probabilistic exploitation likelihood cannot be quantified here. The dominant risk-limiting factor is prevalence: Ladybird is a pre-1.0 experimental browser with a very small production footprint, so mass-exploitation potential is low even though per-target impact (renderer RCE) is high. Priority is real for anyone actually running Ladybird, but the aggregate internet-wide risk is constrained by its niche deployment. |
| Exploit ScenarioDerived | A victim using Ladybird navigates to an attacker-controlled web page that serves a crafted WebAssembly module using ESM integration to import a JavaScript function, triggering the dangling FunctionType reference. The stale result-type data yields an attacker-influenced value that the WASM-GC array.set handler bit-casts into an ArrayInstance pointer, giving an arbitrary write that is chained to code execution in the WebContent process. A public proof-of-concept from VulnCheck (github.com/bikini/exploitarium) demonstrates the chain, and the described AC:H/AT:P profile means the exploit likely relies on precise heap/timing conditions rather than a single deterministic request. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv3 – Jul 01, 2026
Reachable code execution in the Ladybird browser arises from a dangling-reference flaw (CWE-825) in the WebAssembly ESM-integration module loader, where a stack-local Wasm::FunctionType is captured by reference and read after destruction. A malicious web page can chain the resulting stale result-type data into an arbitrary write via the WASM-GC array.set handler and gain code execution in the WebContent process. Reported by VulnCheck with publicly available exploit code exists; it is not listed in CISA KEV, so no confirmed active exploitation, but a working PoC lowers the barrier for weaponization.
Earlier versions of this analysis (2)
Reachable code execution in the Ladybird browser arises from a dangling C++ reference in the WebAssembly ESM-integration module loader, where WebAssemblyModule.cpp hands a stack-local Wasm::FunctionType to create_host_function whose callback outlives it. A malicious web page can exploit the resulting stale result-type data to force an arbitrary write through the WASM-GC array.set handler and achieve code execution in the WebContent process. Publicly available exploit code exists (reported by VulnCheck) and the flaw is verified reachable from plain HTML, though it is not listed in CISA KEV and shows no evidence of active exploitation.
Reachable code execution in the Ladybird browser stems from a dangling-reference flaw in its WebAssembly ESM-integration module loader, affecting all released versions (CPE ladybirdbrowser:ladybird:*). When a JavaScript function is imported into a WASM module via the ESM path, a stack-local Wasm::FunctionType outlives its scope, letting a host callback read freed result-type data and ultimately drive the WASM-GC array.set handler into a bit-cast arbitrary write. A malicious web page can chain this to execute code in the WebContent process; publicly available exploit code exists (VulnCheck), though there is no public exploit identified as actively exploited (not in CISA KEV).
RemediationAI
No vendor-released patch version is identified in the available data; the references point only to the vulnerable source file on the master branch and the VulnCheck advisory, so users should upgrade to the latest Ladybird build once the maintainers publish a fix that removes the dangling FunctionType reference (track https://github.com/LadybirdBrowser/ladybird and the advisory at https://www.vulncheck.com/advisories/ladybird-web-reachable-code-execution-via-dangling-functiontype-reference-in-webassembly-esm-integration for the fixed commit/tag, and rebuild from source). Until a patched build is confirmed, the most effective compensating control is to avoid using Ladybird for general web browsing of untrusted content, since the bug is reachable from ordinary HTML; where the engine must run, restrict it to trusted sites only. If a build-time toggle or runtime flag to disable WebAssembly (or specifically WASM ESM integration) is available, disabling WebAssembly execution removes the vulnerable code path at the cost of breaking any site that depends on WASM. Running Ladybird under strong OS-level sandboxing/seccomp and as an unprivileged user limits post-exploitation impact of a WebContent-process compromise but does not prevent the initial memory corruption.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The defect lives in Ladybird's LibWeb WebAssembly implementation (WebAssemblyModule.cpp), specifically the ESM (ECMAScript Module) integration path that lets JavaScript functions be imported into a WebAssembly module. During ESM link-loop iteration, a stack-local Wasm::FunctionType is passed by reference into create_host_function; the generated host callback captures that reference and reads it after the FunctionType object goes out of scope and is destroyed at the end of the iteration - a classic expired-pointer / use-of-freed-reference condition (CWE-825). The normal instantiate path is unaffected because it uses a long-lived reference. The stale result-type metadata causes the host callback to return an empty result vector for a statically non-empty result signature, leaving an attacker-influenced value in the destination register. That value is then consumed by the WASM-GC array.set handler, which bit-casts the reference's low bits directly to an ArrayInstance pointer after only a null check, producing an arbitrary write primitive that is escalated to control flow. The single affected CPE is cpe:2.3:a:ladybirdbrowser:ladybird, an independent, from-scratch browser engine.
Know when Ladybird 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
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:A/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Network-delivered via web page (AV:N) with no privileges (PR:N) but victim must visit a page (UI:R) and precise heap/timing control is needed (AC:H); renderer memory corruption crossing into process code execution justifies S:C and full C/I/A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
3DescriptionCVE.org
Ladybird contains a dangling-reference memory-safety flaw in its WebAssembly ESM-integration module loader. When a JavaScript function is imported into a WebAssembly module via the ESM path, WebAssemblyModule.cpp passes a stack-local Wasm::FunctionType by reference to create_host_function, whose host callback captures and later reads that reference; once the ESM link-loop iteration ends the FunctionType is destroyed, leaving the callback with a dangling reference (the normal instantiate path uses a long-lived reference and is not affected). Stale result-type data lets the host callback return an empty result vector for a statically non-empty result, so the destination register retains an attacker-influenced value that is then consumed by the WASM-GC array.set handler, which bit-casts the reference low bits to an ArrayInstance pointer after only a null check, yielding an arbitrary write. A web page can chain this into code execution in the WebContent process. Verified reachable from HTML content without any instrumentation or source modification.
Executive ViewAI
The Ladybird browser contains a critical memory corruption vulnerability (CVE-2026-58592, CVSS 8.9) in its WebAssembly engine that enables remote code execution when users visit malicious websites. Successful exploitation grants attackers direct execution privileges in the browser's content process, enabling credential theft, data exfiltration, and potential system-level compromise. With publicly available exploit code documented, this poses an immediate operational risk that demands rapid containment across all affected deployments.
No vendor-released patch identified at time of analysis. Interim mitigations include: disable WebAssembly in Ladybird configuration where operationally feasible; implement domain whitelisting to restrict browsing to internal and pre-approved external sites only; enforce OS-level process isolation and sandboxing; deploy network egress controls to prevent data exfiltration; monitor endpoint detection and response (EDR) alerts for anomalous WebContent process behavior; restrict Ladybird deployment to systems that do not process sensitive data until a patch is available.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-41130
GHSA-vm9p-mx69-hf3f
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB