/

CVE-2026-23880

Severity:

HIGH RISK

(7.3)

Stored XSS in OnboardLite Discord Account Migration

CVE-2026-23880

Awaiting Analysis

Vulnerability type

Category:

Stored Cross-Site Scripting (XSS)

CWE:

CWE-20, CWE-79, CWE-116

Impact:

Cross-Site Scripting leading to administrative account compromise and unauthorized actions

Severity:

HIGH RISK

(7.3)

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

OnboardLite versions prior to commit 1d32081a66f21bcf41df1ecb672490b13f6e429f contain a stored cross-site scripting vulnerability in the admin dashboard workflow for migrating a user's Discord account.

Malicious content associated with a user can be persisted and later executed in an administrator's browser when they trigger the Discord migration feature, potentially leading to session theft or account compromise.

Affected context

The vulnerability manifests in the OnboardLite web dashboard where administrators manage and migrate members' Discord accounts.

It affects deployments where user-controlled or indirectly user-sourced data is displayed in the admin UI during the Discord migration process without proper encoding.

The issue is most relevant in multi-user environments where untrusted members can influence profile or Discord-related fields that are later rendered in HTML in the admin dashboard.

Exploit preconditions

  • Attack surface: Web-based admin dashboard, specifically the UI flow for migrating a user's Discord account.
  • Required access: Ability for an attacker to create or control data associated with a user (for example, fields related to Discord or profile metadata) that will be displayed during the migration step.
  • Trigger point: An administrator viewing or interacting with the migration interface for the attacker-controlled user, causing the stored payload to be rendered in the browser.
  • Why exploitation is possible: The application accepts untrusted input and later embeds it into HTML responses without robust validation, context-appropriate output encoding, or sanitization, enabling injected script execution in the admin's browser context.

Why this happens

This issue is rooted in improper handling of untrusted data within a web rendering context, mapping primarily to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

User-controllable fields tied to Discord account migration are stored and later interpolated into HTML templates without strict validation (CWE-20: Improper Input Validation) and without correct neutralization or escaping of special characters (CWE-116: Improper Encoding or Escaping of Output).

As a result, attacker-supplied markup or script code is treated as active content by the browser instead of inert text, allowing arbitrary JavaScript execution when an admin loads the affected dashboard page.

Potential impact

  • Malicious JavaScript execution in the browser of an authenticated administrator.
  • Theft of admin session tokens or other sensitive browser-stored data within the application's origin.
  • Execution of unauthorized administrative actions via the admin's session (e.g., changing membership records or permissions).
  • Redirection of admins to phishing pages or the injection of deceptive UI to harvest credentials.
  • Use of the compromised admin context as a pivot for broader application or data compromise.

General mitigation guidance

Mitigations generally focus on reducing trust in user-controlled data and enforcing strict output handling in all HTML contexts:

  • Apply context-aware output encoding for all dynamic data rendered into HTML, JavaScript, attributes, and URLs in the dashboard, especially around Discord migration views.
  • Implement centralized input validation for all user-facing and integration-related fields, constraining length, character sets, and formats so that only expected, well-formed values are accepted.
  • Prefer auto-escaping templating engines configured to escape content by default, requiring explicit opt-out only for carefully reviewed fields.
  • Avoid rendering raw HTML from user or external sources; when rich content is necessary, use vetted sanitization libraries that remove scripts, event handlers, and dangerous attributes.
  • Enforce principle of least privilege in admin sessions and actions, so that even if an XSS occurs, the blast radius is reduced (e.g., step-up authentication for the most sensitive flows).

How teams detect issues like this

Organizations can approach detection of similar issues through a combination of review and tooling:

  • Static analysis rules targeting direct insertion of request parameters or stored user fields into templates without encoding, especially around admin and integration flows.
  • Code review checklists that require explicit verification of output encoding and sanitization whenever new dashboard views or migration workflows are introduced.
  • Security linters or SAST tools integrated into CI pipelines to flag unsafe templating patterns, direct DOM manipulation with untrusted data, and innerHTML-style assignments.
  • Dynamic testing with automated scanners or manual penetration testing focusing on stored XSS via user profile, integration, or configuration fields that later appear in privileged views.
  • Content Security Policy (CSP) monitoring (e.g., report-only mode) to surface unexpected inline script executions indicative of XSS attempts.

Sources

SourceLink
github.comgithub.com/HackUCF/OnboardLite/commit/1d32081a66f21bcf41df1ecb672490b13f6e429f
github.comgithub.com/HackUCF/OnboardLite/security/advisories/GHSA-93w8-83cg-h89g

Frequently asked

questions

Exploitation typically requires a user who can influence data that appears in the Discord migration screen, while the actual script execution occurs in an administrator's browser when they view that screen.

No. The attacker generally only needs the ability to submit or control data that is later rendered in the admin dashboard; the admin's normal usage of the migration feature triggers the stored payload.

The most robust fix is to apply strict, context-aware output encoding to all user-influenced fields in templates, combined with strong input validation and the use of auto-escaping templating frameworks so that raw HTML from untrusted sources is never rendered.

Adopt a secure-by-default view layer that escapes content automatically, define development standards for input validation and output encoding, enforce these via code review and automated checks, and, where possible, layer defenses such as CSP and well-scoped permissions to limit the impact of any missed instance.

Find out what's already
exploitable in your codebase.