Skip to main content

Ladybird Browser CVE-2026-119332

| EUVDEUVD-2026-114396 HIGH
Use After Free (CWE-416)
2026-10-30 security-advisories@github.com
8.8
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

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

  1. Recon
    Lure victim to malicious web page
  2. Delivery
    Register objects and force GC of dead records
  3. Exploit
    Trigger cleanup, callback calls unregister() freeing next node
  4. Install
    Iterator reads target/held_value after free
  5. C2
    Heap-spray reclaims freed 32-byte record
  6. Execute
    Deliver crafted NaN-boxed JS::Value to callback
  7. Impact
    Type confusion enabling read/write in WebContent 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

Exploitation requires the victim to load attacker-controlled JavaScript in Ladybird's WebContent process and for the page to drive the FinalizationRegistry cleanup path: register at least two objects (the second with an unregister token), make them unreachable, trigger cleanup (via cleanupSome() or GC pressure), and have the first record's cleanup callback call registry.unregister(token) on the second record so remove_by_token() frees the node the retained iterator points to. No authentication is required (PR:N) and it works against default configurations - any webpage can trigger it - but it does require user interaction in the form of visiting the malicious page (UI:R). Limiting factors: reliable deterministic crash is demonstrated on ASAN/instrumented builds; turning the UAF into a controlled type-confusion/RCE in production builds additionally requires a successful same-size (32-byte) heap spray during the callback window and a separate information leak to defeat ASLR, which is not included in the provided data.

Impact

This is a genuine high-priority issue, not a CVSS-inflated one. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.8) is consistent with the mechanism: a remote, unauthenticated attacker triggers an attacker-reachable heap use-after-free in the LibJS FinalizationRegistry simply by getting a victim to visit a web page (UI:R). The SSVC/priority signal from vuln.today is 'this_week' (not act_now/emergency), which aligns with the absence of a CISA KEV listing and no observed active exploitation. A detailed, reproduced PoC is published in the GHSA advisory (GHSA-6cmv-xmff-qjph), including ASAN output and both a command-line and browser trigger, so exploitability of the crash is confirmed even though weaponized RCE additionally requires a heap spray and an ASLR-defeating information leak. No EPSS score was provided in the input, so probabilistic exploitation likelihood cannot be compared. The main caveat is a patch-status conflict: the description and advisory state the flaw is fixed by commit 209579c96473c75bd5eba9701fcadb841a045964, while the package metadata line says 'not yet patched (All versions through commit 8121ff82)' - verify the fix has actually landed in a consumable build before closing out. Net: a reliable remote-triggerable memory-corruption primitive in a browser engine warrants prompt patching, tempered only by the product's very small real-world footprint.

Exploit ScenarioDerived

An attacker hosts a malicious web page containing JavaScript that registers two objects in a FinalizationRegistry, forces them to become garbage, and triggers cleanup; the cleanup callback for the first dead record calls unregister() on the second record's token, freeing the node the engine's saved iterator still points to. On the next loop iteration the WebContent process reads target and held_value from freed memory, reliably crashing instrumented builds and, after a same-sized heap spray (e.g. Uint32Array), handing the attacker control of the held_value JS::Value for a type-confusion primitive. A full working PoC (ASAN-confirmed, exit 134) is published in the GitHub Security Advisory, and the attack needs only that the victim visit the page (UI:R).

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

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

Alert me

AnalysisAIv1 – Oct 30, 2026

Heap use-after-free in Ladybird Browser's LibJS FinalizationRegistry allows a malicious webpage to crash the WebContent process and, in production builds, potentially corrupt memory. The bug is reachable by unauthenticated remote attackers per the assessed CVSS vector (AV:N/PR:N) but requires the victim to load attacker-controlled JavaScript (UI:R); the advisory includes a public reproduction PoC that triggers the UAF on ASAN builds, while CISA KEV does not list active exploitation. Full type-confusion/RCE exploitation is not demonstrated in the provided data because it additionally depends on a same-size heap spray and an ASLR-defeating information leak.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed. Update to a Ladybird build that includes commit 209579c96473c75bd5eba9701fcadb841a045964 or later. The fix rewrites FinalizationRegistry::cleanup() so that dead records are identified and removed before invoking any JavaScript callback, avoiding retention of a raw iterator across reentrant code. Vendor references are the GHSA advisory https://github.com/LadybirdBrowser/ladybird/security/advisories/GHSA-6cmv-xmff-qjph and the fix commit https://github.com/LadybirdBrowser/ladybird/commit/209579c96473c75bd5eba9701fcadb841a045964. No complete runtime workaround was identified in the supplied data; because any page that drives the FinalizationRegistry cleanup path can trigger it, deploying the fixed build is the only complete remediation described.

Affected VersionsENISA

Ladybird < 209579c96473c75bd5eba9701fcadb841a045964

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 affected component is LibJS's implementation of JavaScript FinalizationRegistry, a garbage-collection cleanup mechanism. The root cause is CWE-416 use-after-free caused by iterator invalidation across a reentrant JavaScript callback in FinalizationRegistry::cleanup(): the code removes a dead record from m_records, retains an iterator to the next FinalizationRecord, and then invokes attacker-controlled JavaScript via vm.host_call_job_callback(). If that callback calls registry.unregister(token) for the next record, remove_by_token() frees the node the retained iterator points to, and the next cleanup iteration reads it->target and it->held_value from freed heap memory. The advisory shows the freed 32-byte FinalizationRecord layout (target at +0, held_value at +8, unregister_token at +16) and ASAN evidence of an 8-byte UAF read in FinalizationRegistry.cpp. On instrumented builds the result is a deterministic SIGABRT; in production, the freed slot can be reclaimed during the callback window with a 32-byte heap spray, and if the attacker controls the NaN-boxed held_value passed to the JS callback, that can become a type-confusion primitive. Turning that into reliable RCE would also require an information leak to defeat ASLR, which is not included in the supplied data.

Know when the next one hits your stack

  • 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 (github) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

Triggered by visiting a page (AV:N, UI:R) with no authentication (PR:N); the reentrant free is reliably reachable (AC:L) and yields a memory-corruption primitive in WebContent with high C/I/A.

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

Primary rating from Vendor (github).

CVSS VectorVendor: github

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

Lifecycle Timeline

2
Patch available
Oct 30, 2026 - 21:18 EUVD
CVE Published
Oct 30, 2026 - 20:17 cve.org
HIGH 8.8

DescriptionCVE.org

Ladybird is a truly independent web browser. Prior to 209579c96473c75bd5eba9701fcadb841a045964, FinalizationRegistry::cleanup() in Libraries/LibJS/Runtime/FinalizationRegistry.cpp removed a dead record from m_records, retained an iterator to the next FinalizationRecord, and then invoked attacker-controlled JavaScript through the cleanup callback. If that callback called unregister() for the next record, remove_by_token() freed the node referenced by the retained iterator, and the next cleanup iteration read its target and held_value fields after free. This reliably crashes instrumented WebContent builds and creates a memory-corruption primitive in production builds. This vulnerability is fixed by commit 209579c96473c75bd5eba9701fcadb841a045964.

Technical POC Analysis

CWE-416 (use-after-free) in JS::FinalizationRegistry::cleanup() in Libraries/LibJS/Runtime/FinalizationRegistry.cpp (advisory cites lines 82–103).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A high-severity memory corruption vulnerability in the Ladybird Browser's JavaScript engine could allow a malicious website to crash the browser and potentially compromise user systems. While no active exploitation has been observed, the availability of a public proof-of-concept lowers the barrier for attackers, and organizations with employees using Ladybird should prioritize remediation to protect against potential data breaches or operational disruptions.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis; implement browser isolation, disable JavaScript where feasible, and enforce strict user awareness training.

Threat Intelligence Overview

EPSS Score
0.2%
Top 85% exploitable
Prevalence
Rare
pre-release independent browser, negligible production deployment footprint
Data Quality
5 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.2%
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
Open
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

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.

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

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