/

CVE-2026-24750

Severity:

HIGH RISK

(7.6)

Stored XSS in Kiteworks Secure Data Forms

CVE-2026-24750

Analyzed

Vulnerability type

Category:

Stored Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Authenticated Stored XSS with Potential Session Hijacking and Data Exposure

Severity:

HIGH RISK

(7.6)

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

Kiteworks Secure Data Forms prior to version 9.2.1 contain a stored cross-site scripting vulnerability that allows untrusted input to be rendered as active script in users' browsers.

An authenticated attacker who can modify forms may inject malicious script content that is later executed in the context of other users viewing or interacting with those forms.

Affected context

The vulnerability occurs within Kiteworks Secure Data Forms when user-controllable form content is persisted and then rendered back into web pages without sufficient output encoding.

It primarily affects deployments where authenticated users have privileges to create or modify forms, and where those forms are later viewed by other users, administrators, or external participants.

The risk is higher in environments where data forms are widely shared or used as part of workflow, approval, or intake processes.

Exploit preconditions

  • Attack surface: Web user interface for creating or modifying Kiteworks Secure Data Forms.
  • Required access: Authenticated account with permission to modify existing forms or create new ones.
  • Trigger point: A victim user views or interacts with a compromised form (e.g., opening the form, loading its preview, or accessing related pages where injected content is rendered).
  • Why exploitation is possible: Form fields or configuration values supplied by an attacker are stored server-side and later incorporated into HTML responses without proper context-aware output encoding or sanitization, enabling injected script to execute in the victim's browser.

Why this happens

This issue is a classic example of CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-site Scripting).

Application logic accepts attacker-controlled data in form definitions or metadata, stores it, and then embeds it directly into dynamically generated web pages.

Because the output layer does not consistently perform context-appropriate encoding or sanitization before rendering these values into HTML or script contexts, browsers interpret the injected content as executable JavaScript.

The defect lies in mixing untrusted, stored input with server-generated markup without enforcing strict output encoding on every rendering path.

Potential impact

  • Execution of arbitrary JavaScript in the context of the affected Kiteworks application.
  • Theft or misuse of session identifiers, leading to account impersonation in some configurations.
  • Unauthorized actions performed on behalf of victim users (e.g., modifying forms, accessing or transmitting data).
  • Exfiltration or manipulation of sensitive information accessible in the victim's browser session.
  • User interface redressing, phishing overlays, or deceptive prompts presented within the application.

General mitigation guidance

Effective mitigation focuses on correctly handling untrusted data at output time and constraining where and how dynamic content is allowed in the UI.

Recommended defensive patterns include:

  • Enforcing strict context-aware output encoding for all form-derived values before they are embedded into HTML, attributes, URLs, and script blocks.
  • Using a well-reviewed templating engine that automatically encodes variables and discourages direct string concatenation into HTML.
  • Applying server-side validation and sanitization rules to restrict dangerous characters or markup in fields that are not meant to contain HTML.
  • Avoiding dynamic insertion of user-controlled data into script or event-handler contexts; prefer data attributes or JSON structures that are safely parsed.
  • Implementing a strong Content Security Policy (CSP) to reduce the blast radius of any residual XSS issues.
  • Applying least-privilege principles to form modification rights, granting editing capabilities only to trusted roles.

How teams detect issues like this

Detection is most effective when combining secure coding practices with automated analysis and focused review of dynamic content paths.

Common strategies include:

  • Static analysis rules that flag direct concatenation of user-supplied values into HTML or JavaScript without encoding helpers.
  • Code review checklists that require verification of output encoding on all template variables sourced from stored form data.
  • Security testing (including manual penetration testing and automated DAST) that attempts to inject benign XSS probes into form fields and observes rendered output.
  • Centralized logging and monitoring for suspicious form content patterns (e.g., <script>, event-handlers like onload=, or javascript: URLs) to spot potential attempts.
  • Integration of security scanners into CI/CD pipelines to catch newly introduced unsafe rendering patterns early.

Sources

SourceLink
github.comgithub.com/kiteworks/security-advisories/security/advisories/GHSA-rfwm-2hq6-h84g

Frequently asked

questions

Yes, if the Kiteworks instance is reachable over the internet and an attacker has or can obtain valid credentials with form-editing permissions. The attacker can then craft a malicious form and send links or workflows that cause other users to load it.

The described issue requires an authenticated user who can modify forms. Elevated administrative privileges are not strictly required if standard users are allowed to edit or create forms that other users will view.

The safest pattern is to ensure all user-controlled, stored data from forms is treated as untrusted and is contextually output-encoded every time it is rendered. Using templating or UI frameworks that default to secure encoding, combined with avoiding inline script or event-handler injection, is a robust approach.

Adopt a defense-in-depth strategy: use secure-by-default templating, enforce centralized encoding utilities, implement strict input validation rules, apply a restrictive Content Security Policy, and require security-focused code reviews for any functionality that renders user-controlled content.

Find out what's already
exploitable in your codebase.