/

CVE-2026-54694

Severity:

CRITICAL RISK

(9.6)

Stored XSS (CWE-79) in SkillTree Quiz Runs Interface

CVE-2026-54694

Deferred

Vulnerability type

Category:

Stored Cross-Site Scripting

CWE:

CWE-20, CWE-79, CWE-116, CWE-183, CWE-693

Impact:

Administrative browser compromise, unauthorized actions, and sensitive data exposure

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

SkillTree versions before the patched release contain a stored cross-site scripting vulnerability caused by unsafe HTML construction and rendering, combined with insufficient sanitization of user profile fields. An attacker who can register an account may execute JavaScript in an administrator's browser when the administrator views quiz-run data, potentially enabling administrative actions, data theft, or account compromise.

Affected context

The vulnerability occurs in SkillTree deployments where user-controlled profile values are displayed through the quiz-run interface. The affected rendering path constructs HTML from raw substrings and inserts it with Vue's v-html, while registration fields can retain markup without adequate sanitization. Exploitation depends on the attacker being able to create an account and an administrator later viewing the affected content.

Exploit preconditions

  • Attack surface: Public account registration and the administrator-facing Quiz Runs page
  • Required access: Ability to create or control a SkillTree user account; no administrator credentials are required
  • Trigger point: An administrator opens quiz-run data containing attacker-controlled profile fields
  • Why exploitation is possible: User-controlled values reach an HTML-rendering sink without reliable context-aware encoding or sanitization
  • Additional condition: The attacker-controlled content must satisfy the relevant field and rendering constraints

Why this happens

The primary flaw is CWE-79: Improper Neutralization of Input During Web Page Generation, or stored cross-site scripting. StringHighlighter.js interpolates raw values into an HTML string, and HighlightedValue.vue assigns that string, as well as unfiltered plain values, through v-html, which updates the DOM using innerHTML.

Related weaknesses include inadequate input validation and output encoding, represented by CWE-20 and CWE-116. The insecure pattern is treating user-controlled text as trusted markup and relying on field length limits or filtering that is not appropriate for the HTML context. Once rendered in an administrator's origin, the script executes with that user's browser privileges.

Potential impact

  • An attacker may execute arbitrary JavaScript in an administrator's browser.
  • The attacker could perform administrative actions through the victim's authenticated session.
  • Sensitive application data could be read and transmitted to an external service.
  • Projects, accounts, or other platform resources could be modified or deleted.
  • The vulnerability could enable persistence, account creation, or broader platform compromise.
  • User activity or browser information could be monitored.

General mitigation guidance

Mitigation should focus on ensuring that user-controlled values remain data throughout the rendering pipeline.

Common defensive patterns include:

  • Render untrusted values as text rather than injecting them into HTML.
  • Prefer framework-native text interpolation and avoid v-html for untrusted content.
  • Apply context-aware output encoding at the final rendering boundary.
  • If limited rich text is required, use a well-maintained allowlist-based sanitizer with a restrictive policy.
  • Validate registration fields for expected content and treat length limits as supplementary controls rather than XSS defenses.
  • Review and remove alternate rendering paths that bypass sanitization.
  • Use a patched, maintained application release and apply defense-in-depth browser controls such as an effective Content Security Policy.
  • Limit administrative privileges and protect state-changing endpoints with robust authorization and request-forgery defenses.

How teams detect issues like this

Organizations can detect similar issues through:

  • Static analysis rules identifying v-html, innerHTML, template interpolation into HTML, and equivalent DOM sinks.
  • Searches for user-controlled registration or profile fields flowing into rendering components without encoding or sanitization.
  • Code review checks for string-built HTML and sanitization performed only at input or only for selected display paths.
  • Dynamic testing that submits harmless markup markers and verifies they are rendered as text rather than interpreted as HTML.
  • Content Security Policy reporting and browser telemetry for unexpected script execution or external script requests.
  • CI policies that flag unsafe HTML rendering APIs and require security review for exceptions.

Automated code-review and software-composition tools may help identify risky sinks and missing defensive controls, but should be supplemented with manual data-flow analysis.

Sources

SourceLink
github.comgithub.com/NationalSecurityAgency/skills-service/security/advisories/GHSA-hqfg-c8wf-w2g8

Frequently asked

questions

Yes, within the application's normal web workflow. An attacker generally needs only to create an account and place content that an administrator later views in the Quiz Runs interface.

No. The described attack chain uses a self-registered account, while the resulting script executes with the privileges of the administrator who views the affected page.

Treat profile and quiz-related values as untrusted text, render them with safe text interpolation, and eliminate unsafe HTML injection. If formatted content is required, use strict allowlist sanitization at the rendering boundary and deploy a maintained patched release.

Establish secure-by-default frontend policies that prohibit unsafe HTML sinks for untrusted data, combine context-aware output encoding with input validation, test every display path, enforce Content Security Policy, and review authorization and request-forgery protections for administrative APIs.

Find out what's already
exploitable in your codebase.