/

CVE-2026-24837

Severity:

HIGH RISK

(7.6)

Stored XSS in DNN Persona Bar Module Friendly Names

CVE-2026-24837

Analyzed

Vulnerability type

Category:

Stored Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to admin session compromise and UI takeover

Severity:

HIGH RISK

(7.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

DNN (DotNetNuke) contains a stored cross-site scripting vulnerability where a module's friendly name can embed script code that executes within the Persona Bar interface.

When an attacker can define or modify a module friendly name, malicious JavaScript may later run in the browser of administrators or other users performing module operations in the Persona Bar.

Affected context

This vulnerability occurs in DNN installations using versions starting from 9.0.0 and prior to 9.13.10 and 10.2.0, where the Persona Bar is used to manage modules.

The issue is specifically tied to how module friendly names are rendered during module-related operations in the Persona Bar without sufficient output encoding or filtering.

It is most relevant in environments where users beyond fully trusted administrators can create, edit, or manage modules, or where an attacker can influence module metadata via compromised accounts or integrations.

Exploit preconditions

  • Attack surface: Web-based administrative interface (Persona Bar) in the DNN CMS.
  • Required access: Ability to create or modify a module's friendly name (e.g., via module configuration permissions, compromised admin/host account, or elevated contributor role).
  • Trigger point: Viewing or interacting with module operations in the Persona Bar that render the stored friendly name to the browser.
  • Why exploitation is possible: The application interprets untrusted module friendly name content as HTML/JavaScript, without robust output encoding, enabling attacker-controlled scripts to execute in the context of the authenticated user's session.

Why this happens

The underlying bug class is stored cross-site scripting as defined in CWE-79.

User-controlled data (the module friendly name) is stored server-side and later embedded into Persona Bar pages without sufficient contextual output encoding or sanitization.

When the Persona Bar renders this data, the browser treats it as active content, allowing attacker-supplied JavaScript to execute in the privileged administrative context.

This reflects an insecure pattern where UI-facing metadata fields are assumed harmless and are not subject to strict output encoding or content restrictions.

Potential impact

  • Hijacking of administrator or privileged user sessions within DNN.
  • Execution of arbitrary JavaScript in the Persona Bar, including UI manipulation and data exfiltration.
  • Creation or modification of site content, modules, or configuration settings under the victim's privileges.
  • Installation of backdoors or malicious modules via the compromised admin interface.
  • Persistent compromise of the administrative experience, including injection of further malicious scripts.

General mitigation guidance

Mitigation typically focuses on treating all user-controlled display strings as untrusted and enforcing strict output encoding:

  • Apply context-appropriate output encoding when rendering module metadata, including friendly names, in HTML or script contexts.
  • Restrict allowed characters and markup in module friendly names, using whitelist-based validation to ensure they remain plain text.
  • Centralize encoding and sanitization logic for all Persona Bar views so that UI components cannot accidentally output raw user-controlled values.
  • Enforce least-privilege principles for roles that can create or edit modules, limiting who can influence metadata that appears in administrative interfaces.
  • Consider applying content security policies (CSP) to reduce the impact of any residual script injection, such as disallowing inline JavaScript where feasible.

How teams detect issues like this

Detection can rely on a combination of code, configuration, and behavioral analysis:

  • Static analysis rules that flag direct rendering of user-controlled fields (like module friendly names) without explicit encoding helpers in Persona Bar views and related templates.
  • Code review checklists that include verifying that all module metadata is passed through a centralized HTML-encoding or sanitization API before display.
  • Automated tests or security scanners configured to attempt script injection via module configuration fields and monitor for reflected execution in the admin UI.
  • Runtime monitoring and logging of unusual Persona Bar behavior, such as unexpected script errors, DOM modifications, or requests initiated from administrative pages.
  • Periodic review of module metadata for suspicious patterns (e.g., event handlers, script tags, or JavaScript URLs) that might indicate stored XSS payloads.

Sources

SourceLink
github.comgithub.com/dnnsoftware/Dnn.Platform/security/advisories/GHSA-vm5q-8qww-h238

Frequently asked

questions

Yes. If an attacker can obtain or abuse credentials or any role that can define or modify module friendly names, they can inject a payload that later executes when a privileged user opens the affected Persona Bar views.

Exploitation generally requires permissions to create or edit modules or their metadata. This might correspond to administrator, host, or elevated content manager roles, or a lower-privileged account if misconfigured permissions allow module manipulation.

The safest pattern is to treat module friendly names and similar UI strings as untrusted data and always apply strict contextual output encoding before rendering them in HTML, attributes, or scripts. Complement this with conservative input validation that restricts friendly names to benign characters and formats.

Preventing similar issues involves adopting a consistent "encode-on-output" strategy for all user-controlled content, using well-reviewed helper APIs; applying secure coding guidelines that forbid raw injection of user data into templates; and integrating security testing—such as XSS-focused automated scanning and code review rules—into the development lifecycle for all admin and configuration interfaces.

Find out what's already
exploitable in your codebase.