/

CVE-2026-55409

Severity:

HIGH RISK

(7.6)

Stored XSS (CWE-79) in Filament RichEditor component

CVE-2026-55409

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to authenticated user compromise

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

A stored cross-site scripting (XSS) issue in Filament's RichEditor field causes disabled fields to render unsanitized HTML content.

If untrusted data is stored in this field, an attacker could inject malicious HTML or JavaScript that executes whenever other users view the affected form.

Affected context

This vulnerability appears in Filament-based Laravel applications using the RichEditor form component between versions 3.0.0 and 3.3.52.

It specifically affects scenarios where the RichEditor field is disabled and displays previously stored data, and that data has not already been sanitized or HTML-escaped at the time the form state was populated.

Applications that allow users or integrated systems to supply rich text content without robust server-side sanitization are more exposed, especially in admin panels or multi-user dashboards where high-privilege users routinely view form data.

Exploit preconditions

  • Attack surface: Web UI rendered by Filament forms, particularly views that include disabled RichEditor fields.
  • Required access: Ability to influence or submit content that ends up in the RichEditor field's stored state (e.g., creating or editing records, API ingestion, or indirect data flows).
  • Trigger point: A user with permission to view the affected form loads a page where the disabled RichEditor field displays the malicious content.
  • Why exploitation is possible: The disabled RichEditor field rendered its stored state as raw HTML without applying output encoding or HTML sanitization, allowing attacker-controlled markup and scripts to execute in the viewer's browser.

Why this happens

The root cause is a lack of appropriate output encoding or sanitization when rendering the RichEditor component in a disabled state.

While rich text editors typically accept HTML content, the component bypassed security controls and treated the stored value as trusted when disabled, emitting it directly into the page's DOM.

This behavior corresponds to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-site Scripting), where attacker-supplied data is included in HTML output without neutralizing script-relevant characters, enabling arbitrary script execution in the client context.

Potential impact

  • Compromise of authenticated user sessions via session token theft (depending on cookie attributes and environment).
  • Execution of arbitrary JavaScript in the context of the Filament application domain.
  • Unauthorized actions performed on behalf of high-privilege users (e.g., admins) through DOM manipulation or cross-site request forgery-like behavior using existing credentials.
  • Exfiltration or tampering of sensitive data displayed or accessible within the affected admin or management interface.
  • Lateral movement within the application, such as creating additional malicious records or planting secondary XSS payloads.

General mitigation guidance

Effective mitigation focuses on treating all rich text content as untrusted by default, especially at output time.

Recommended defensive patterns include:

  • Applying robust server-side HTML sanitization to any user-controllable rich text before storing or rendering it, using a well-maintained allowlist-based sanitizer.
  • Enforcing context-appropriate output encoding (e.g., HTML encoding for body content, attribute encoding for attribute values) for all dynamic content rendered in templates, regardless of form field enabled/disabled state.
  • Designing UI components so that "disabled" or read-only states do not bypass standard encoding/sanitization paths and instead reuse the same safe rendering pipeline as other views.
  • Restricting who can supply rich text and limiting which HTML tags and attributes are permitted, reducing the risk surface if sanitization gaps exist.
  • Applying the principle of least privilege in administrative interfaces so that successful XSS in one area has minimized impact on broader system operations.

How teams detect issues like this

Detection typically combines code-level and behavior-level approaches:

  • Static analysis: Configure linters or SAST tools to flag unescaped output in templates, especially where raw HTML rendering helpers or unescaped blade tags are used around rich text fields.
  • Code review: During review, scrutinize UI components that render user-controlled HTML, checking disabled/read-only variants for shortcuts that bypass normal encoding or sanitization.
  • Security testing: Incorporate automated and manual XSS testing into QA pipelines, including tests that insert harmless script-like payloads into rich text fields and verify output encoding in all view modes.
  • Runtime monitoring: Use Content Security Policy (CSP) violation reports and web application firewalls (WAFs) to detect suspicious script execution patterns or payloads indicative of stored XSS.

Sources

SourceLink
github.comgithub.com/filamentphp/filament/pull/20029
github.comgithub.com/filamentphp/filament/releases/tag/v3.3.53
github.comgithub.com/filamentphp/filament/security/advisories/GHSA-m9cv-24rx-8mv7

Frequently asked

questions

Yes. If an attacker can submit or influence the content stored in the RichEditor field (directly or indirectly), the payload can execute in browsers of other users who view the affected form, without additional interaction from the attacker.

The attacker must be able to cause data to be stored in the RichEditor field's state. This may involve having a regular user account with form submission rights, controlling an integration that feeds data into the field, or abusing another vulnerability that allows data tampering.

The most robust pattern is to apply server-side HTML sanitization to all rich text fields before rendering and to ensure that the rendering layer consistently uses context-appropriate output encoding, regardless of whether fields are editable, disabled, or read-only.

Adopt a strict output-encoding-by-default strategy in templates, standardize sanitization for any feature that renders HTML, add automated checks (SAST, linters, and tests) for unescaped outputs, and include XSS-focused reviews for new UI components, especially those handling rich text or HTML content.

Find out what's already
exploitable in your codebase.