/

CVE-2026-92708

Severity:

HIGH RISK

(7.5)

Information Disclosure (CWE-200) in Svelte devalue

CVE-2026-92708

Awaiting Analysis

Vulnerability type

Category:

Information Disclosure

CWE:

CWE-200, CWE-226

Impact:

Cross-request Sensitive Data Exposure

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Svelte devalue can disclose unrelated process memory when its serialization functions handle typed arrays or Node.js Buffer objects backed by shared memory pools. In server-side-rendered applications, a public page that serializes a small Buffer may expose data from other requests, including request bodies or authorization headers, without requiring authentication.

Affected context

The issue affects applications using vulnerable Svelte devalue releases to serialize Node.js Buffer objects or other typed-array views during server-side rendering. Risk is greatest when public routes return small buffers, read small files, or otherwise serialize data backed by a shared process-wide ArrayBuffer, allowing unrelated bytes in that backing store to be included in rendered HTML.

Exploit preconditions

  • Attack surface: Public server-side-rendered pages or other responses that use devalue serialization
  • Required access: Typically no authentication; a requester needs access to an affected endpoint
  • Trigger point: Serialization of a Node.js Buffer or typed-array view
  • Why exploitation is possible: The serializer emits the complete backing ArrayBuffer instead of limiting output to the view's intended range, which may include residual data from other in-flight requests

Why this happens

The underlying bug is improper bounds handling when serializing typed-array views. Instead of serializing only the byte range represented by the view, the implementation serializes the entire backing ArrayBuffer; for Node.js Buffers, that storage can be shared across operations and requests. This maps primarily to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor and is also related to CWE-226: Sensitive Information in Resource Not Removed Before Reuse, because stale bytes in reusable process memory can become visible to another response.

Potential impact

  • Unrelated request bodies may be disclosed in rendered HTML
  • Authorization headers, tokens, or session material could be exposed
  • File contents or application data from other operations may leak
  • Attackers could collect sensitive memory fragments by repeatedly requesting affected pages
  • Privacy, tenant isolation, and credential confidentiality could be weakened

General mitigation guidance

Mitigation generally focuses on preserving typed-array boundaries and reducing the amount of sensitive data entering serialization paths.

Common defensive patterns include:

  • Use serialization behavior that respects the byte offset and length of typed-array views
  • Convert Node.js Buffer objects to appropriately bounded Uint8Array values before serialization
  • Avoid returning secrets, request metadata, or unnecessary file contents from server-rendered loaders
  • Keep sensitive data out of shared serialization and rendering contexts
  • Apply dependency governance that evaluates serializer behavior and security advisories
  • Use least-privilege handling for credentials and minimize their lifetime in application memory

How teams detect issues like this

Organizations can look for this issue through:

  • Static analysis and code review checks for serialization of Buffer or typed-array values in SSR loaders
  • Tests that serialize small views backed by larger buffers and verify that only the intended range is emitted
  • Integration tests that issue concurrent requests containing distinct sensitive markers and inspect rendered output for cross-request leakage
  • Dependency policy checks for vulnerable serializer implementations and transitive framework dependencies
  • Runtime monitoring for unexpected secrets, headers, or request content appearing in public HTML responses

Automated dependency scanning and code-review tools can help identify affected usage patterns, but behavioral tests are useful for confirming boundary handling.

Sources

SourceLink
github.comgithub.com/sveltejs/devalue/commit/46dc877b3570dafb1cd3291b9bb48cecef8f7266
github.comgithub.com/sveltejs/devalue/releases/tag/v5.9.3
github.comgithub.com/sveltejs/devalue/security/advisories/GHSA-j22f-vq7h-c4qm

Frequently asked

questions

Yes, when an affected server-side-rendered route is publicly reachable and serializes a Buffer or typed-array view. An attacker generally needs only to request the route repeatedly and inspect its output.

Not necessarily. Public pages can expose data without an authenticated session if their rendering path includes the vulnerable serialization behavior.

Ensure serializers emit only the intended view range, and convert Node.js Buffer values to bounded typed-array representations before serialization. Sensitive values should also be excluded from public rendering paths.

Add concurrent serialization tests, review typed-array boundary handling, minimize sensitive data in SSR loaders, and enforce dependency and security policies for serialization libraries.

Find out what's already
exploitable in your codebase.