/

CVE-2026-29519

Severity:

HIGH RISK

(8.2)

Reflected XSS (CWE-79) in Lucee CFML URL Path Parsing

CVE-2026-29519

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Arbitrary JavaScript Execution in Victim Browser

Severity:

HIGH RISK

(8.2)

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

Lucee CFML Server contains a reflected cross-site scripting flaw in how it parses and reflects URL paths back into HTTP responses without proper output encoding.

An unauthenticated attacker can craft a malicious URL that injects arbitrary JavaScript into a victim's browser, which becomes dangerous when users with access to the Lucee administrative interface are tricked into visiting the link.

Affected context

This vulnerability arises in Lucee CFML Server deployments that dynamically reflect portions of the URL path into HTML output or UI elements without context-appropriate encoding.

It primarily affects HTTP endpoints where the request path is reused in responses, such as status pages, error templates, or navigation headers.

The issue is more impactful in environments where authenticated users, including administrators, regularly follow links to the Lucee administrative interface or related tooling via browser-based access.

Exploit preconditions

  • Attack surface: Public or internal Lucee HTTP endpoints reachable via a web browser.
  • Required access: No authentication is required; the attacker only needs the ability to send or share crafted URLs.
  • Trigger point: A victim must visit (directly or via redirect/embedded link) a URL whose path contains attacker-supplied HTML/JavaScript that is reflected into the response.
  • Why exploitation is possible: The URL path is incorporated into the server's response without context-aware escaping or encoding, allowing injected script content to execute in the victim's browser within the Lucee application origin.

Why this happens

The underlying flaw aligns with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

Lucee's URL handling logic reuses the raw or insufficiently sanitized request path inside HTML responses, templates, or error pages.

Because the application does not perform context-appropriate output encoding (for example, HTML-encoding or JavaScript-encoding) before rendering user-controlled path data, injected tags or script fragments are interpreted as active content instead of plain text, leading to reflected XSS.

Potential impact

  • Attackers may execute arbitrary JavaScript in the context of the Lucee application's origin.
  • Attackers could perform session hijacking by stealing session identifiers or tokens stored in cookies or web storage.
  • Attackers may initiate unauthorized actions against the Lucee administrative interface on behalf of authenticated users (e.g., CSRF-like interactions via XSS).
  • Attackers can alter or spoof page content to perform phishing attacks or trick users into sensitive operations.
  • Attackers may pivot to further compromise by capturing credentials, manipulating configuration, or planting persistent browser-side payloads.

General mitigation guidance

Mitigation generally centers on enforcing strict output encoding and limiting how user-supplied data is reflected:

  • Apply context-aware output encoding to all user-controllable data derived from the URL path before embedding it into HTML, JavaScript, attributes, or URLs.
  • Avoid directly echoing raw URL components in templates; instead, use canonicalized and validated values or internal identifiers.
  • Introduce a centralized encoding/escaping utility for CFML views to ensure consistent handling of all reflected data.
  • Constrain what characters and patterns are accepted in path segments where reflection is necessary, rejecting or normalizing potentially dangerous content such as <, >, ", ', and script-related patterns.
  • Isolate administrative interfaces behind additional protections (e.g., VPNs, IP allowlists, or separate domains) to reduce the likelihood that untrusted links share the same origin as sensitive consoles.

How teams detect issues like this

Detection efforts can focus on both code-level indicators and runtime behavior:

  • Use static analysis or code search to identify templates or handlers that insert request path variables directly into HTML without passing through encoding helpers.
  • During code review, flag any use of URL- or path-derived variables in views, especially where they appear inside <title>, headings, breadcrumbs, or error messages.
  • Implement content security policies (CSP) and monitor CSP violation reports, which can surface unexpected inline script execution paths.
  • Conduct automated and manual XSS testing with security scanners that inject special characters in path components and observe whether they are reflected in responses.
  • Introduce secure coding guidelines and linting rules for CFML and Java-based view layers, enforcing mandatory use of encoding APIs for any reflected user input.

Sources

SourceLink
github.comgithub.com/L4V4D0/CVE-2026-29519-Lucee-Reflected-XSS
vulncheck.comvulncheck.com/advisories/lucee-cfml-server-reflected-xss-via-url-path-parsing

Frequently asked

questions

This issue is broadly exploitable anywhere Lucee endpoints are reachable and users can be enticed to click or follow crafted URLs; it is not limited to public internet exposure and can also affect internal deployments accessed via browsers.

No authentication is required for exploitation.

The attacker only needs to craft a malicious URL and convince a target user—potentially an authenticated administrator—to visit it.

The most robust fix is to ensure all data derived from the URL path is passed through context-appropriate output encoding before being rendered, ideally using centralized helper functions, and to remove any unnecessary reflection of raw path components.

Adopting a systematic encoding strategy for all user input, enforcing secure coding guidelines, incorporating automated checks in CI pipelines, and performing periodic XSS-focused testing can significantly reduce the chance of introducing similar vulnerabilities.

Find out what's already
exploitable in your codebase.