/

CVE-2026-28274

Severity:

HIGH RISK

(8.7)

Stored XSS in Initiative Project Management Platform

CVE-2026-28274

Analyzed

Vulnerability type

Category:

Stored Cross-Site Scripting (XSS)

CWE:

CWE-79, CWE-434

Impact:

Session Hijacking and Sensitive Data Exfiltration via Stored XSS

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

Initiative project management platform versions prior to 0.32.4 contain a stored Cross-Site Scripting (XSS) vulnerability in the document upload feature that allows HTML/HTM files to run arbitrary JavaScript under the application's origin.

Any user with upload permissions in the "Initiatives" section can upload a crafted HTML document that, when viewed by other users, executes script in their browser, enabling theft of session cookies, authentication tokens, or other sensitive data.

Affected context

The vulnerability appears in the document upload functionality within the "Initiatives" section of the Initiative platform.

It affects deployments where:

  • Users are allowed to upload .html or .htm documents,
  • The application later serves these files directly under its own domain and origin,
  • The returned content is not sandboxed (e.g., via iframes with restrictive attributes) or properly constrained from executing active content.

In such environments, viewing or sharing links to the uploaded HTML documents can expose other users to script execution in their authenticated browser context.

Exploit preconditions

  • Attack surface: Web interface for document upload and subsequent document viewing under the Initiative application origin.
  • Required access: An account with permissions to upload documents in the "Initiatives" section (no special administrative privileges are required beyond upload rights).
  • Trigger point: A victim user visits or is induced to visit the direct URL of the maliciously uploaded .html/.htm document while logged into the application.
  • Why exploitation is possible: The application accepts active HTML content as a document type, stores it, and later serves it under the same origin as the core app without sandboxing or content-type restrictions. This allows arbitrary JavaScript inside the uploaded HTML file to execute with the privileges of the authenticated session.

Why this happens

The core issue maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), combined with aspects of CWE-434: Unrestricted Upload of File with Dangerous Type.

Instead of treating uploaded documents purely as passive content (e.g., PDFs or images), the system allows raw HTML files to be uploaded and then served directly under the application's origin. Because these files are not isolated (for example, by using separate domains, sandboxed iframes, or strict Content Security Policies), any embedded JavaScript executes in the same security context as the main application.

This design pattern effectively turns user-uploaded content into executable application logic in the browser, breaking the separation between untrusted content and trusted UI and enabling stored XSS.

Potential impact

  • Theft of session cookies or authentication tokens from users who access the malicious document.
  • Exfiltration of sensitive data viewable within the app (e.g., project details, tasks, attached documents) to attacker-controlled endpoints.
  • Impersonation of affected users via hijacked sessions, potentially including project administrators or managers.
  • Execution of arbitrary actions in the victim's account (e.g., modifying initiatives, changing configurations) through DOM manipulation or forged requests.
  • Use of the platform as a pivot to conduct further phishing or social engineering against team members by hosting believable malicious pages under the trusted domain.

General mitigation guidance

Effective mitigation centers on strictly separating untrusted uploaded content from the main application context and avoiding execution of active content:

  • Constrain allowed upload types to passive formats (e.g., images, PDFs) and reject or transform active content types like .html and .htm where they are not strictly necessary.
  • If HTML content must be supported, serve it from an isolated origin or subdomain dedicated to untrusted content, preventing access to application cookies and storage.
  • Apply sandboxing mechanisms (such as <iframe sandbox> with restrictive flags) when rendering any user-supplied HTML, ensuring scripts cannot execute or cannot escape the sandbox.
  • Use Content Security Policy (CSP) to limit script execution from uploaded documents, preferring disallowing inline scripts and untrusted external script sources.
  • Align upload and rendering logic with a least-privilege model, treating all user-generated files as untrusted and avoiding direct reflection into the primary application document without sanitization or isolation.

How teams detect issues like this

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

  • Static analysis and code review:
  • Identify endpoints that accept file uploads and inspect how MIME types and extensions are validated.
  • Flag any code paths that serve uploaded files directly from the main application origin, especially when Content-Type: text/html is possible.
  • Look for uses of generic file serving handlers that do not distinguish between passive content and executable HTML.
  • Security policy enforcement:
  • Enforce architectural policies that require all user-uploaded HTML, if allowed at all, to be sandboxed or hosted on separate origins.
  • Incorporate checks in CI/CD to ensure CSP and upload validation logic remain in place and are not bypassed.
  • Operational monitoring:
  • Monitor access logs for unusual access patterns to uploaded .html/.htm documents, particularly if followed by anomalous user behavior.
  • Use web application firewalls or reverse proxies configured to block or warn on serving user-uploaded HTML content from the primary application domain.

Sources

SourceLink
github.comgithub.com/Morelitea/initiative/releases/tag/v0.32.4
github.comgithub.com/Morelitea/initiative/security/advisories/GHSA-v38c-x27x-p584

Frequently asked

questions

Yes. Any remote attacker who can obtain an account with document upload permissions, or compromise such an account, can upload a malicious HTML file. Other users who open the shared link to that file while logged in will execute the attacker's script in their browser.

The attacker needs upload permissions within the "Initiatives" section. They do not necessarily need administrative access; a standard user role that can upload documents is sufficient to plant the payload.

The most robust fix is to prevent active HTML content from being treated as a normal document: disallow .html/.htm uploads by default, or, if business requirements demand HTML uploads, host them on a separate, unprivileged origin and/or render them inside strongly sandboxed containers so that scripts cannot access the main application context.

Adopt a security model that treats all user-uploaded content as untrusted, restrict upload types to non-executable formats, and mandate content isolation (separate domains, sandboxing, and strict CSP) for any feature that renders user-controlled HTML. Regular security reviews of file upload and rendering paths, combined with automated checks in the development pipeline, can help catch similar patterns early.

Find out what's already
exploitable in your codebase.