/

CVE-2026-25156

Severity:

HIGH RISK

(7.3)

Cross-Site Scripting (XSS) in HotCRP

CVE-2026-25156

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to account/session compromise and arbitrary in-application actions

Severity:

HIGH RISK

(7.3)

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

HotCRP versions from October 2025 through January 2026 incorrectly rendered all uploaded documents inline in the browser, instead of restricting inline delivery to a small set of safe content types.

This allowed uploaded HTML or SVG files to execute JavaScript in the victim's browser with access to their HotCRP session, potentially leading to arbitrary API calls and data exposure when a user clicked a malicious document link.

Affected context

The issue affects HotCRP deployments running versions that:

  • Include commit aa20ef288828b04550950cf67c831af8a525f508 (October 2025) up to, but not including, the fix
  • Serve uploaded conference documents directly from the application
  • Rely on Content-Disposition to control whether documents are rendered inline or downloaded

It manifests when:

  • Malicious HTML or SVG documents are uploaded as submission files or comment attachments
  • Users follow links to view these documents in the browser, causing them to be rendered in the HotCRP origin context

Exploit preconditions

  • Attack surface: Web interface for viewing uploaded documents (submissions and comment attachments).
  • Required access: Ability to upload files to any field that accepts general file/attachment uploads (not limited to PDFs only). This could be via a registered author, reviewer, or any role permitted to attach files.
  • Victim interaction: A logged-in user (e.g., PC member, reviewer, or chair) must click and view the malicious document through HotCRP's document viewer URL.
  • Trigger point: The browser loads the uploaded HTML/SVG with Content-Disposition: inline under the HotCRP origin, allowing embedded JavaScript to execute.
  • Why exploitation is possible: The application sends untrusted, active content (HTML/SVG) inline without forcing download or isolating it on a separate origin, enabling it to run scripts in the same security context as the application (CWE-79).

Why this happens

The root cause lies in misconfigured content handling that allowed untrusted, potentially active content types (such as HTML and SVG) to be rendered inline under the application's origin.

Instead of restricting inline rendering to a narrow set of safe, mostly passive types (e.g., text/plain, PDFs, and certain images), the affected versions delivered all document types inline by default, equivalent to embedding attacker-controlled HTML inside the application.

This violates the principle behind CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting): user-controlled content was allowed to execute script in the context of other users' sessions, without sanitization, output encoding, or origin isolation (download-only or separate domain).

Potential impact

  • Malicious JavaScript may execute in the browser of any user who opens the crafted document.
  • Attackers could potentially exfiltrate sensitive HotCRP data accessible to the victim (e.g., reviews, scores, comments, identities if visible).
  • An attacker-controlled script could perform arbitrary actions via the HotCRP web/API interface with the victim's privileges (e.g., modifying reviews, comments, or decisions).
  • Session tokens or CSRF protections could be bypassed in practice, as actions originate from the authenticated browser context.
  • Further phishing or misrepresentation of conference content may be possible by altering visible data for targeted users.

General mitigation guidance

Effective mitigation focuses on treating uploaded documents as untrusted active content and preventing them from executing within the application's origin.

Common defensive patterns include:

  • Restricting inline rendering to a minimal set of content types that are known to be passive (e.g., text/plain, application/pdf, specific image formats), and serving all other types as forced downloads using Content-Disposition: attachment.
  • Avoiding inline rendering of any content type capable of carrying script or active markup (such as text/html, image/svg+xml, and other browser-parsed formats) unless they are served from a separate, unprivileged origin dedicated to static, untrusted content.
  • Applying a strict Content Security Policy (CSP) for any views that might include user-supplied content, to limit script execution and resource loading where practical.
  • Minimizing trust in file upload fields: clearly separating "document" uploads from any feature that might render markup, and avoiding reuse of the same delivery path for both.
  • Applying the principle of least privilege to application features, so that even if a script runs, the account it hijacks has constrained access.

How teams detect issues like this

To detect this and similar issues, organizations can:

  • Use static analysis or configuration scanning to identify endpoints that serve user-uploaded content with Content-Disposition: inline or without strict content-type checks.
  • Review routes and controllers that stream uploaded files, verifying that only an explicit allowlist of MIME types is eligible for inline rendering, and that potential HTML/SVG types are not served on the primary application origin.
  • Implement security-focused code review checklists that include questions about how file uploads are stored, served, and isolated (e.g., origin, headers, CSP).
  • Run dynamic application security tests (DAST) or manual penetration tests specifically targeting file upload features, trying to render uploaded HTML/SVG and observing whether JavaScript executes in the application context.
  • Integrate automated review tools into CI/CD pipelines to flag changes that relax Content-Disposition policies or expand the set of inline-rendered MIME types without explicit justification.

Sources

SourceLink
github.comgithub.com/kohler/hotcrp/commit/8933e86c9f384b356dc4c6e9e2814dee1074b323
github.comgithub.com/kohler/hotcrp/commit/aa20ef288828b04550950cf67c831af8a525f508
github.comgithub.com/kohler/hotcrp/commit/c3d88a7e18d52119c65df31c2cc994edd2beccc5
github.comgithub.com/kohler/hotcrp/security/advisories/GHSA-p88p-2f2p-2476

Frequently asked

questions

Yes. Once an attacker can upload a malicious document, they can send links to that document to other users. Any logged-in user who opens the link in a browser is exposed, making this effectively remotely exploitable via normal web interactions.

The attacker needs the ability to upload files to the conference (e.g., as an author, reviewer, or any role that can submit attachments). They do not need administrative privileges; they only need a role that allows uploading to fields where general file types are accepted and then to convince or wait for another user to view the document.

The safest pattern is to strictly serve potentially active content (HTML, SVG, and similar types) as downloads using Content-Disposition: attachment, or to host uploads on a separate, unprivileged origin where scripts cannot impact the main application. Inline rendering should be restricted to a clear allowlist of known-safe MIME types.

Treat all uploaded files as untrusted, design file-serving endpoints around explicit allowlists, and enforce origin isolation or download-only behavior for any type that could contain active content. Complement this with security reviews focused on file upload features, automated checks for dangerous Content-Disposition and Content-Type combinations, and defensive browser headers such as CSP and X-Content-Type-Options where appropriate.

Find out what's already
exploitable in your codebase.