Skip to main content

Ladybird CVE-2026-58592

| EUVDEUVD-2026-41130 HIGH
Expired Pointer Dereference (CWE-825)
2026-07-01 VulnCheck GHSA-vm9p-mx69-hf3f
8.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Recon
    Lure victim to malicious page
  2. Delivery
    Serve crafted WASM module with ESM JS import
  3. Exploit
    Trigger dangling FunctionType reference
  4. Install
    Empty result poisons destination register
  5. C2
    array.set bit-casts value to ArrayInstance pointer
  6. Execute
    Achieve arbitrary write
  7. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv3 – 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)
v2 Jul 01, 2026 - 20:31 cvss changed CVSS 8.9

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.

v1 Jul 01, 2026 - 20:16 CVSS 8.3

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

Ladybird 0

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

Vendor (VulnCheck) PRIMARY 8.9 HIGH
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
vuln.today AI 7.5 HIGH

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
High
Subsequent system: Integrity
High
Subsequent system: Availability
High

Lifecycle Timeline

3
Analysis Updated
Jul 01, 2026 - 20:31 vuln.today
v3 - CVSS changed
Analysis Updated
Jul 01, 2026 - 20:31 vuln.today
v2 - CVSS changed
CVSS changed
Jul 01, 2026 - 20:22 NVD
8.3 (HIGH) 8.9 (HIGH)

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Rare
experimental pre-1.0 independent browser, minimal production deployment
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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 Yes
EPSS 0.3%
Patch available No
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

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

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