/

CVE-2026-41241

Severity:

HIGH RISK

(8.7)

XSS in pretalx Organiser Search Backend

CVE-2026-41241

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to organiser account compromise and backend actions in their browser

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

pretalx contained a stored cross-site scripting vulnerability where user-controlled names, emails, and submission titles were rendered into the organiser search dropdown using unsafe innerHTML interpolation.

An attacker who can set any of these fields could inject HTML or JavaScript that executes in an organiser's browser when their search results include the malicious record.

Affected context

This vulnerability occurs in the pretalx organiser backend interface, specifically in the search functionality that displays matching submissions and users in a dropdown.

It is relevant in deployments where organisers or administrators use the web backend to search for submissions, speakers, or users, and where untrusted users can control submission titles, speaker display names, or account names/emails.

The issue manifests when search results are rendered in the browser using innerHTML with unescaped, user-controlled content.

Exploit preconditions

  • Attack surface: The organiser/admin backend search UI in the pretalx web application.
  • Required access: Ability to register or otherwise create/update records that influence:
  • Submission titles
  • Speaker display names
  • User names or email addresses
  • Trigger point: An organiser performs a search whose results include a record containing malicious content in one of the above fields; the dropdown renders the result using innerHTML.
  • Why exploitation is possible: User-controlled fields are interpolated into HTML via innerHTML without appropriate context-aware escaping or use of safe DOM APIs, allowing attacker-supplied markup or scripts to be interpreted by the browser.

Why this happens

The core bug is a classic stored cross-site scripting pattern: persistent, user-controlled data is later rendered into privileged pages without proper output encoding.

In this case, the organiser search dropdown uses innerHTML to insert submission titles and user identifiers directly into the DOM, trusting that these strings do not contain executable HTML or JavaScript.

Because no context-aware escaping or use of safe DOM construction (e.g., text nodes) is applied, an attacker can embed tags or event handlers that the browser executes when the organiser searches and the crafted record appears.

This maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), where untrusted input is integrated into the response without appropriate sanitization or encoding for its HTML context.

Potential impact

  • Execution of arbitrary JavaScript in the organiser's browser when using the backend search.
  • Theft of organiser session tokens or impersonation of organiser accounts within that browser session.
  • Unauthorized actions in the pretalx backend on behalf of an organiser, such as modifying submissions, schedules, or user data.
  • Injection of further malicious content into conference materials or communications managed via pretalx.
  • Lateral movement to other integrated services if organiser accounts have elevated access or connected identities.

General mitigation guidance

Effective mitigation focuses on eliminating unsafe HTML injection patterns and enforcing strict separation between data and markup:

  • Prefer DOM APIs that treat user data as text, not HTML:
  • Use textContent or equivalent instead of innerHTML for user-controlled fields.
  • Construct DOM elements explicitly and assign attacker-controlled values only to text nodes or safe attributes.
  • Apply context-aware output encoding on all untrusted data rendered into HTML, attributes, or JavaScript contexts:
  • Encode HTML entities for text in HTML bodies.
  • Use attribute encoding for values placed into attributes.
  • Enforce a templating strategy that auto-escapes output by default and makes raw HTML insertion explicit and rare.
  • Introduce a clear data classification policy so that fields like titles and display names are always treated as untrusted, regardless of user role.
  • Consider applying a conservative HTML sanitization step for any field that must legitimately support markup, limiting allowed tags and attributes.
  • Reduce backend privilege exposure where possible, so that a compromised organiser session has limited ability to perform destructive actions.

How teams detect issues like this

Detection can combine automated analysis with targeted review and runtime monitoring:

  • Static analysis / linters:
  • Search for usage of innerHTML, outerHTML, document.write, or similar APIs where the values originate from user-controllable fields.
  • Enforce linting rules that forbid unsafe DOM sinks unless accompanied by an approved sanitization or encoding pattern.
  • Code review practices:
  • Flag any insertion of dynamic data into templates that bypass default escaping.
  • Review backend/admin interface code with the same rigor as public-facing pages, since it often handles high-privilege sessions.
  • Maintain a checklist for XSS, including verification that all user-controlled fields go through context-aware encoding.
  • Automated testing:
  • Add integration tests that populate fields (titles, names, emails) with typical XSS test strings and assert they render as inert text.
  • Use DAST or browser-based scanners against authenticated organiser views to detect script execution when viewing or searching for crafted records.
  • Runtime security controls:
  • Apply a restrictive Content Security Policy (CSP) to limit script execution sources and reduce impact if some XSS paths remain.

Sources

SourceLink
github.comgithub.com/pretalx/pretalx/security/advisories/GHSA-cjcx-jfp2-f7m2

Frequently asked

questions

Yes. Any user who can create or modify submission titles, display names, or user identifiers can inject malicious content. Exploitation occurs when an organiser, typically over the internet, uses the backend search interface and the crafted record appears in their results.

No. The attacker only needs the ability to control one of the affected fields, which may be possible for ordinary registered users or speakers. The organiser/admin role is only required on the victim side, whose browser executes the injected script when using the search.

The safest pattern is to treat all user-controlled data as untrusted and render it using APIs or templating mechanisms that escape content by default. Avoid innerHTML for such data, rely on textContent or equivalent text-only bindings, and use explicit, well-reviewed sanitization when raw HTML truly must be supported.

Adopt a defense-in-depth approach: use auto-escaping templates; consistently apply context-aware output encoding; ban unsafe DOM sinks in coding standards; add static and dynamic tests for XSS; and apply restrictive CSP where feasible. Combine these technical controls with secure code review practices focused on any path that renders untrusted data into admin or public views.

Find out what's already
exploitable in your codebase.