/

CVE-2026-54458

Severity:

CRITICAL RISK

(9.6)

Stored DOM XSS (CWE-79) in AVideo YPTSocket Plugin

CVE-2026-54458

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Authenticated Session Hijack and Administrative Account Takeover

Severity:

CRITICAL RISK

(9.6)

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

WWBN AVideo's YPTSocket plugin contains a stored DOM-based Cross-Site Scripting flaw that lets anonymous attackers inject arbitrary JavaScript into the admin UI via WebSocket metadata.

When an administrator views a page that renders the online-users debug panel, attacker-controlled values are reflected into the DOM without sanitization, leading to execution in the admin's authenticated origin and enabling full account takeover.

Affected context

This vulnerability arises in AVideo deployments that enable and render the YPTSocket online-users debug panel in administrator views.

The issue is exposed when the server issues signed WebSocket tokens to unauthenticated callers, then reuses attacker-controlled URL parameters (such as webSocketSelfURI and page_title) in broadcast messages to all connected clients.

On the client side, those broadcast values are interpolated directly into HTML content and appended into the DOM, creating a stored DOM XSS condition visible whenever admins view the affected dashboard components.

Exploit preconditions

  • Attack surface: The YPTSocket WebSocket endpoint and any admin page that displays the online-users debug panel.
  • Required access: None; attackers can be fully unauthenticated, only needing the ability to open a WebSocket connection using the public token issuance endpoint.
  • Trigger point: An administrator browses a page that renders the YPTSocket online-users debug panel while the malicious WebSocket connection is active or its data remains stored.
  • Why exploitation is possible: User-supplied webSocketSelfURI and page_title parameters are accepted without validation, persisted into an in-memory SQLite table, then broadcast to all clients; the client-side script interpolates these values into an HTML template literal and passes it to $.append(), allowing arbitrary script-capable markup (e.g., inline handlers) to become live DOM.

Why this happens

The underlying bug is a classic Cross-Site Scripting pattern where untrusted input flows from transport-layer metadata into the user interface without sanitization or encoding.

On the server, the YPTSocket plugin treats attacker-controlled WebSocket URL parameters as trusted data, storing them and distributing them to clients.

On the client, the DOM construction logic uses these values directly within HTML template strings that are appended to the document, failing to apply any context-aware escaping or to restrict allowed markup.

This behavior maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), specifically a stored DOM XSS variant that turns persistence and broadcast into a multi-user exploitation channel.

Potential impact

  • Attackers can execute arbitrary JavaScript in the administrator's browser context.
  • Attackers can read non-HttpOnly cookies and CSRF tokens exposed in the admin dashboard.
  • Attackers can issue authenticated requests to any admin-only endpoint via the victim's session.
  • Attackers can exfiltrate sensitive DOM content from the admin interface, including configuration and user data.
  • Attackers can perform full administrative account takeover and chain into destructive or persistent configuration changes.

General mitigation guidance

Mitigation for this class of issue focuses on preventing untrusted data from being interpreted as executable or markup-bearing content in the browser.

Common defensive patterns include:

  • Treating all WebSocket metadata and query parameters as untrusted input, enforcing strict validation and normalization before persistence or broadcast.
  • Applying context-appropriate output encoding for any user-controlled data rendered into HTML, CSS, JavaScript, or URLs in client-side templates.
  • Avoiding direct string concatenation or template interpolation into HTML fragments; instead, construct DOM nodes using safe APIs (e.g., document.createElement, property assignment) and restrict which fields can influence markup.
  • Limiting debug panels and diagnostic overlays to privileged contexts and ensuring they never render raw user data.
  • Implementing least-privilege for admin sessions, including CSRF protections and scoped tokens, so that even if a UI component misbehaves, blast radius is reduced.

How teams detect issues like this

Detection typically combines code-centric and behavior-centric approaches:

  • Static analysis rules that flag uses of innerHTML, jQuery $.append, or template literals populated with untrusted data, especially in WebSocket or real-time update paths.
  • Data flow analysis to trace user-controlled parameters from network entry points (e.g., WebSocket URL query strings) into DOM-related sinks without validation or encoding.
  • Targeted code reviews focusing on debug panels, live user lists, and activity feeds that aggregate and display metadata originating from multiple users.
  • Security testing that simulates untrusted WebSocket clients sending crafted values and observes whether injected content is rendered by administrative dashboards.
  • Enforcement of secure coding guidelines through CI pipelines, using linters or SAST tools configured to highlight risky DOM manipulation patterns.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/8be71e53ccbe9b84b30870db386fb4d2b11e1c16
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-8whc-2wmv-ww35

Frequently asked

questions

It is broadly exploitable because any anonymous attacker can open a WebSocket connection and inject malicious values; exploitation succeeds whenever an administrator loads a page that renders the vulnerable debug panel.

No authentication is required. The attacker only needs network reachability to the AVideo instance and the ability to interact with the YPTSocket WebSocket endpoint, which currently issues signed tokens to anonymous callers.

The safest pattern is to treat all WebSocket-sourced and query parameter data as untrusted, enforce strict validation on allowed fields, and apply robust output encoding in the client before rendering.

In addition, avoid feeding raw user data into HTML-building helpers; use safe DOM APIs that separate data from markup.

Adopt a framework-wide XSS prevention strategy: standardize on context-aware encoding libraries, prohibit direct insertion of untrusted strings into HTML, rigorously review real-time and debug UI features, and integrate automated static analysis in CI to catch unsafe DOM operations before deployment.

Find out what's already
exploitable in your codebase.