/

CVE-2026-24833

Severity:

HIGH RISK

(7.6)

XSS in DNN Module Description / Persona Bar

CVE-2026-24833

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

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

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) allowed a module to be installed with rich-text content in its description field that could embed executable scripts.

When such a module was present, the malicious script would execute in the context of users viewing it in the Persona Bar, potentially compromising administrator sessions and sensitive data.

Affected context

The vulnerability appears in DNN installations where:

  • Administrators or privileged users can install modules that include HTML-rich descriptions
  • The module description field is rendered within the Persona Bar UI
  • Output encoding or script filtering is insufficient for the rich-text description content

In these conditions, a crafted module description can persistently inject script into the administration interface, affecting any user with access to the Persona Bar where the description is displayed.

Exploit preconditions

  • Attack surface: DNN administration interface (Persona Bar) where module descriptions are displayed
  • Required access: Ability to install or upload a module package, or otherwise influence the module description field
  • Trigger point: Viewing or interacting with the Persona Bar page that renders the malicious module description
  • Why exploitation is possible: The rich-text description field is treated as trusted HTML and rendered without sufficient output encoding or sanitization, allowing embedded scripts to execute in the browser of a privileged user.

Why this happens

This issue is a form of stored Cross-Site Scripting, mapped to CWE-79.

The root cause is that user-supplied rich-text content from the module description field is stored and later rendered into the Persona Bar interface without robust HTML/script sanitization and context-appropriate output encoding.

Because this HTML is considered part of the administrative UI, any <script> blocks or script-capable attributes can execute with the privileges of the currently logged-in administrator, turning the description field into a persistent XSS sink.

Potential impact

  • Theft of administrator session tokens or other sensitive cookies
  • Execution of arbitrary actions in the DNN admin interface on behalf of the victim (e.g., creating users, changing settings, installing additional modules)
  • Injection of further malicious content into the site, enabling deeper compromise or defacement
  • Lateral movement to other administrative accounts by altering permissions or user roles
  • Exfiltration of configuration data, including connection strings or API keys if exposed via the UI

General mitigation guidance

Effective mitigation focuses on treating all rich-text fields as untrusted and enforcing strict output encoding and sanitization:

  • Apply context-appropriate output encoding to any user-supplied text when rendering into the DOM, even in rich-text areas
  • Use a robust HTML sanitization library to remove or neutralize scripts, event handlers, and dangerous attributes from WYSIWYG content
  • Limit what HTML tags and attributes are allowed in module descriptions, favoring a safe whitelist over broad rich-text capabilities
  • Separate data from presentation by avoiding direct insertion of HTML fragments into administrative interfaces wherever possible
  • Enforce least privilege for module installation capabilities, restricting who can upload or install modules and review their metadata before activation

How teams detect issues like this

Organizations can detect this class of issue with:

  • Static analysis rules that flag direct rendering of unencoded user-supplied HTML into admin views, especially for fields marked as "rich text"
  • Manual code review focusing on:
  • Places where module metadata (name, description, etc.) is injected into Razor views, WebForms, or JavaScript templates
  • Usage of raw HTML rendering helpers and bypassing of standard encoding mechanisms
  • Content security policies (CSP) configured in report-only mode to surface unexpected inline script execution in administrative pages
  • Automated UI testing or security scanning that submits HTML/JavaScript payloads in module metadata and monitors for execution in the admin interface

Sources

SourceLink
github.comgithub.com/dnnsoftware/Dnn.Platform/security/advisories/GHSA-9r3h-mpf8-25gj

Frequently asked

questions

Yes, if an attacker can get a malicious module installed or otherwise control the module description, the payload will execute when a privileged user opens the Persona Bar page that renders it. The attacker does not need direct access to the victim's browser, only a way to supply the malicious description content.

Practically, exploitation requires the ability to install or influence a module's description field. This might mean compromised admin credentials, a malicious third-party module, or abuse of a workflow where untrusted parties can submit modules for installation. Once the module is present, any admin or user with Persona Bar access can be affected when they view it.

The safest pattern is to treat module descriptions as untrusted data, sanitize them using a strict, well-maintained HTML sanitizer, and always apply context-aware output encoding when rendering. Avoid rendering raw HTML from metadata fields in administrative views and strip or block executable constructs such as <script> tags and event handler attributes.

Establish a secure-by-default rendering model where:

  • All user-provided content, including rich text, is encoded by default
  • Any exceptions (e.g., allowed HTML) go through a centralized sanitization pipeline
  • Administrative and high-privilege views never display unreviewed, unsanitized user HTML
  • Code review and automated checks specifically flag raw HTML rendering and bypasses of encoding in UI layers, particularly around plugin/module ecosystems.
Find out what's already
exploitable in your codebase.