EUVD-2026-88818Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen socket to lib0/Yjs service (pre-auth)
-
DeliverySend binary message with over-long length prefix
-
ExploitTrigger unbounded readUint8Array over-read
-
ExecutionAdjacent heap memory returned by decoder
-
PersistConsumer echoes/stores/re-serves value
-
ImpactAttacker recovers tenant data and session tokens
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The over-read is triggerable by any peer that can supply bytes to a lib0 binary decoder - reachable pre-authentication over a network socket in Yjs/lib0-based services (AV:N/PR:N), with no user interaction. The specific trigger is a wire-supplied length prefix in readUint8Array that exceeds the decoder's view, which before the 0.2.118 / 1.0.0-rc.33 fix was never bounds-checked. The key LIMITING factor for actual data exfiltration is that the consuming application must echo, store, or re-serve the decoded value back to the attacker to complete the leak; and the process must be running an affected version (0.2.1-0.2.117 or 1.0.0-rc.32 and earlier). Multi-tenant or shared-process deployments maximize the value of what is leaked (cross-tenant content and bearer tokens). |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N = 8.6 High) describes a pre-authentication, network-reachable heap over-read with a scope change and high confidentiality impact - a genuinely serious signal because lib0 is the low-level decoding library beneath Yjs, and any peer that can open a socket (including before auth) can feed bytes to the decoder. However, several risk signals are absent from the input: no EPSS score, no CISA KEV listing, and no public POC beyond the fix commit. The confidentiality impact is real (the advisory explicitly claims recovery of other tenants' document content, personal data, and live bearer session tokens), but full exfiltration is conditioned on the consuming application echoing, storing, or re-serving the decoded value back to the attacker - the raw over-read happens unconditionally, but the return channel is application-dependent, which tempers the C:H rating in practice. On balance this is a real priority for anyone embedding lib0/Yjs in a multi-tenant or pre-auth-reachable service, but the lack of KEV/EPSS/POC suggests no confirmed widespread exploitation yet; treat as patch-promptly rather than emergency-in-the-wild. Note the 'Buffer Overflow' tag is imprecise: CWE-125 is an out-of-bounds READ (information disclosure), not an overflow write. |
| Exploit ScenarioDerived | An unauthenticated remote peer opens a socket to a service built on Yjs/lib0 and sends a crafted binary message whose length prefix in readUint8Array exceeds the remaining buffer. The decoder returns whatever adjacent heap memory the host process allocated next - other tenants' document data or bearer session tokens - and where the application echoes, stores, or re-serves that decoded value, the attacker receives the leaked memory back. No public exploit code is identified at time of analysis beyond the vendor fix commit. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
Unauthenticated remote peers can read adjacent process memory from any service that feeds attacker-supplied bytes into the lib0 binary decoder, because readUint8Array never validated the wire-supplied length against the decoder's remaining view before the fix. Affected deployments are those running lib0 0.2.1 through 0.2.117, or 1.0.0-rc.32 and earlier - most notably Yjs-based collaboration and sync services where a peer can supply bytes to the decoder, including before authentication. The leak only completes when the consuming application echoes, stores, or re-serves the decoded value back to the attacker, but under that condition multi-tenant or shared-process hosts can expose other tenants' document content and live bearer session tokens; no public exploit code was identified at time of analysis and there is no CISA KEV entry, though the root cause is trivially reachable by anyone able to open a socket.
RemediationAI
Vendor-released patch: upgrade to lib0 0.2.118 (0.2.x line) or 1.0.0-rc.33 (1.0 pre-release line), which add a bounds check in readUint8Array that rejects any length prefix larger than the decoder's remaining bytes. Where an immediate library upgrade is not possible, apply the checks at the application boundary: validate or cap the declared length of every binary frame before handing it to the decoder, and wrap decode calls so that malformed frames are dropped rather than propagated. Because the confidentiality loss only materializes when the decoded value is echoed, stored, or re-served, the single most effective compensating control is to stop trusting and reflecting decoded output - never return decoded bytes whose lengths were not verified. Additional hard limits worth applying with their trade-offs: restrict the decoder socket to authenticated or network-trusted peers, which reduces the pre-auth exposure window but breaks legitimate unauthenticated handshakes; run untrusted multi-tenant decoding in per-tenant processes or sandboxes so an over-read cannot reach another tenant's heap or bearer tokens, at the cost of memory and IPC overhead; and shorten the lifetime of session tokens carried in-process to limit what a successful over-read is worth. Monitor for the new errorUnexpectedEndOfArray exception after patching, since legitimate clients sending truncated frames will now fail closed where they previously silently over-read. References: https://github.com/dmonad/lib0/security/advisories/GHSA-r5c8-rf4w-qrq8 and the fix commits at https://github.com/dmonad/lib0/commit/425f28dc82c8df1b6f7e1ab20ea1a0a15a3c355f and https://github.com/dmonad/lib0/commit/c4c9db0b41346a33aff31a51f1f09c3a17757f10.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
lib0 is the low-level binary encoding/decoding library underpinning Yjs and a wide range of CRDT-based collaboration and realtime sync stacks, so a defect here propagates into every consumer that parses wire data with it. The flaw is CWE-125 (out-of-bounds read): in decoding.js, readUint8Array consumed a length prefix taken directly from the wire without comparing it against the decoder's own bounds (the remaining bytes, decoder.arr.length - decoder.pos). A single over-long length prefix therefore drove the reader past the end of the legitimate buffer and returned whatever the host process had allocated adjacent in the heap, while the decoder advanced normally. The upstream fix adds an explicit guard for len < 0 || len > decoder.arr.length - decoder.pos and throws errorUnexpectedEndOfArray, converting a silent over-read into a hard decode failure - a behavior change consumers should expect for malformed or truncated frames. The CVSS vector AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N (8.6, High) reflects that this is network-reachable, requires no privileges or user interaction, and that the confidentiality impact can cross a security scope boundary because the leaked memory is not owned by the requesting tenant or session. Note that the accompanying tag labels it a buffer overflow, but the actual primitive is a read overrun with no write, so integrity and availability are unaffected.
Know when Lib0 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
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N
Pre-auth network trigger with trivial crafted length prefix (AV:N/AC:L/PR:N/UI:N); reads memory belonging to other tenants/process regions so S:C and C:H; no integrity or availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
A missing bounds check in the binary decoder in lib0, versions 0.2.1-0.2.117 and earlier and 1.0.0-rc.32 and earlier, lets any unauthenticated remote peer read adjacent process memory and receive it back. readUint8Array never compares the wire-supplied length against the decoder's own view, so one over-long length prefix returns whatever the host process allocated next: other tenants' document content, personal data, and live bearer session tokens**, recovered in full and at will. An attacker who can supply bytes to a lib0 decoder which means any peer that can open a socket, including before authentication reads adjacent process memory and, where the consumer echoes, stores or re-serves the decoded value, receives it back. This is patched in version 0.2.118 and 1.0.0-rc.33.
Technical POC Analysis
CWE-125 (out-of-bounds read) in lib0's binary decoder, specifically readUint8Array in decoding.js: js export const readUint8Array = (decoder, len) = { const view = new Uint8Array(decoder.arr.buffer,…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A memory-disclosure flaw in lib0 - the binary codec embedded in Yjs-based real-time collaboration and sync platforms - can leak adjacent process memory, exposing other tenants' document content and live bearer session tokens on any multi-tenant or shared-process deployment. Because the library is deeply embedded in real-time sync services and the leak path requires no elevated privileges, the practical risk is cross-customer data spillage followed by credential-based account takeover. No vendor patch is available, so leadership should treat containment as a deployment-engineering problem with a 30-day horizon.
No vendor-released patch identified at time of analysis. Interim mitigations: constrain or block network paths that let untrusted peers feed bytes directly into lib0's decoder; disable or gate features that echo, store, or re-serve decoded values back to the sender; enforce per-tenant process or worker isolation to prevent cross-tenant memory reads; rotate bearer tokens and session credentials on any host running affected lib0 versions (0.2.1 through 0.2.117, or 1.0.0-rc.32 and earlier); and monitor for anomalous payload lengths and decoder failures. Exploitation status: no public exploit identified at time of analysis.
Threat Intelligence Overview
NVD
CVE.org
EPSS
Vulnrichment
GitHub
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
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Exploit-DB