Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconLure victim to malicious web page
-
DeliveryRegister objects and force GC of dead records
-
ExploitTrigger cleanup, callback calls unregister() freeing next node
-
InstallIterator reads target/held_value after free
-
C2Heap-spray reclaims freed 32-byte record
-
ExecuteDeliver crafted NaN-boxed JS::Value to callback
-
ImpactType 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). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
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.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.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
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.
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
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
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.
EUVD-2026-114396
NVD
CVE.org
EPSS
GitHub
Exploit-DB