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: inlineunder 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: inlineor 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.

