/

CVE-2026-34241

Severity:

HIGH RISK

(8.7)

Stored XSS in CtrlPanel Ticket Reply Notifications

CVE-2026-34241

Deferred

Vulnerability type

Category:

Stored Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Session hijacking and privilege escalation via stored XSS

Severity:

HIGH RISK

(8.7)

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

CtrlPanel billing software versions 1.1.1 and earlier contain a stored cross-site scripting (XSS) flaw in the ticket reply notification system, where reply content is saved and later rendered without proper escaping.

An attacker who can submit ticket replies can inject arbitrary JavaScript that executes in the browser of admins or users who receive the notification, enabling session hijacking and unauthorized actions within the victim's account.

Affected context

This vulnerability affects deployments of CtrlPanel (≤ 1.1.1) using the built-in ticketing system and notification mechanism.

It arises when:

  • Ticket replies are accepted from users or admins and stored as notification payloads.
  • The $newmessage reply content is written directly to the database without HTML/JavaScript sanitization.
  • Notification templates render this content using Blade's {!! !!} syntax, which outputs unescaped HTML in the recipient's browser.

Both admin-facing and user-facing ticket reply notifications are impacted, creating a bidirectional attack path between low-privileged users and administrators.

Exploit preconditions

  • Attack surface: Web-based ticket reply forms and any interface that triggers ticket reply notifications.
  • Required access:
  • A low-privileged user account that can open or reply to tickets; or
  • An administrative account (or a compromised admin session) replying to user tickets.
  • Trigger point:
  • The attacker submits a crafted ticket reply containing malicious JavaScript or HTML.
  • The notification is generated and stored, then later viewed by a target user or admin in their browser.
  • Why exploitation is possible:
  • Reply content ($newmessage) is trusted and stored verbatim in notification records.
  • Notification templates use Blade's {!! !!} directive, which bypasses automatic escaping, causing the browser to interpret attacker-controlled content as active HTML/JavaScript within the application origin.

Why this happens

The core issue is the direct embedding of untrusted user-controlled content into HTML without proper encoding or sanitization.

In the affected notification classes (App\Notifications\Ticket\Admin\AdminReplyNotification and App\Notifications\Ticket\User\ReplyNotification), the $newmessage field is persisted as-is and later rendered with Blade's raw output syntax {!! !!}, which disables Laravel's default HTML escaping.

This maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), where dynamic content originating from users is integrated into HTML output without context-aware escaping, allowing script execution in the victim's browser within the application's security context.

Potential impact

  • Hijacking of administrator sessions by executing JavaScript in admin browsers.
  • Unauthorized performance of administrative actions (e.g., account changes, configuration updates) on behalf of compromised admins.
  • Harvesting user or admin credentials through fake login prompts or in-page phishing flows.
  • Deployment of keyloggers to capture sensitive data entered into the application.
  • Targeting regular users from a malicious or compromised admin account using the same notification channel.
  • Lateral movement and privilege escalation within the hosting provider environment via compromised high-privilege accounts.

General mitigation guidance

Effective mitigation focuses on treating all message and notification content as untrusted and ensuring it is safely rendered:

  • Prefer Blade's escaped output syntax ({{ }}) for user-supplied and dynamic content to enforce automatic HTML encoding.
  • Apply context-aware output encoding on all notification fields that may contain user input, ensuring characters like <, >, ", and ' are neutralized before reaching the browser.
  • Introduce a server-side content sanitization layer for rich text fields, allowing only a minimal, vetted subset of HTML (if truly required) and stripping scripts, event handlers, and dangerous attributes.
  • Centralize rendering helpers for notifications and messages to avoid ad hoc raw output usages and to standardize secure patterns.
  • Reduce privileges where possible so that actions performed from a single compromised session are limited and auditable.
  • Establish secure-by-default templates where raw HTML output requires a deliberate, reviewed exception rather than being the default pattern.

How teams detect issues like this

Organizations can identify and monitor for similar stored XSS issues using a combination of code-centric and runtime approaches:

  • Static analysis: Configure rules or linters to flag:
  • Usage of Blade's {!! !!} directive, especially around variables tied to user-supplied data.
  • Direct concatenation or interpolation of request parameters into HTML strings or notification payloads.
  • Code review practices:
  • Require manual review of all view templates and notification classes that display ticket content, comments, or messages from users.
  • Maintain a checklist ensuring that all user-controlled fields are rendered with escaped helpers or pass through a sanitization routine.
  • Automated testing and security scanning:
  • Use dynamic application security testing (DAST) tools to submit benign XSS probes in ticket replies and verify whether they reappear as executable content in notifications.
  • Integrate security-focused unit and integration tests that validate notification rendering, checking for proper HTML encoding of special characters.
  • Policy and CI integration:
  • Enforce pull-request gates that reject unsafe templating patterns detected by static analyzers.
  • Periodically audit high-risk components (ticketing, messaging, notifications) for raw output patterns and document any justified exceptions.

Sources

SourceLink
github.comgithub.com/Ctrlpanel-gg/panel/releases/tag/1.2.0
github.comgithub.com/Ctrlpanel-gg/panel/security/advisories/GHSA-cmrr-q3hw-3vqh

Frequently asked

questions

Yes. Any authenticated user who can submit ticket replies can exploit the issue to target admins or other users. Conversely, a malicious or compromised admin account can target regular users through the same notification channel.

The attacker typically needs a valid CtrlPanel account with the ability to create or reply to tickets. No direct access to server internals or the database is required; exploitation occurs entirely through the web interface and notification system.

The most robust fix is to ensure all user-supplied content is rendered using escaped output by default (e.g., Blade {{ }}), optionally combined with server-side sanitization for fields that must support limited HTML. Raw output helpers should be eliminated or heavily restricted and only used with pre-sanitized, trusted content.

Adopt a secure templating policy where automatic escaping is the default, enforce context-aware output encoding for every point where user data reaches the DOM, and ensure code review and automated checks flag any use of raw output. Additionally, treat ticket messages, comments, and notifications as high-risk inputs and regularly test them with security tooling and regression tests focused on XSS.

Find out what's already
exploitable in your codebase.