/

CVE-2026-24751

Severity:

HIGH RISK

(8.2)

Cross-Site Scripting (XSS) in Kiteworks Secure Data Forms

CVE-2026-24751

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Arbitrary JavaScript execution in the victim's browser within the Kiteworks application context

Severity:

HIGH RISK

(8.2)

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

A reflected cross-site scripting (XSS) flaw in Kiteworks Secure Data Forms allows attacker-controlled input to be echoed into web responses without proper sanitization or encoding.

If a victim user is lured into visiting a crafted link, the attacker's JavaScript can run in the context of the Kiteworks application, potentially impacting confidentiality, integrity, and session security.

Affected context

The vulnerability occurs in the Secure Data Forms component of Kiteworks when user-supplied data is reflected back into HTML responses.

It becomes relevant in scenarios where:

  • User-controlled parameters are included in form pages or response messages
  • Output is rendered in the browser without context-appropriate encoding
  • Users access Kiteworks via links provided over email, chat, or other channels

The issue is limited to the browser environment and relies on client-side script execution in the Kiteworks domain.

Exploit preconditions

  • Attack surface: Web interface of Kiteworks Secure Data Forms
  • Required access: Ability to send or expose a crafted URL or request to a logged-in or targeted user (e.g., via email, messaging, or embedded links)
  • User interaction: A victim must open the malicious link or interact with a crafted page that triggers the vulnerable response
  • Trigger point: HTTP request parameters or form inputs that are reflected into the page without proper encoding
  • Why exploitation is possible: The application returns attacker-controlled data directly into an HTML or JavaScript context without applying robust output encoding or sanitization, enabling script injection.

Why this happens

This vulnerability is rooted in improper output handling of untrusted input in a web context, aligning with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

The Secure Data Forms endpoint(s) accept parameters that are later embedded into the server-generated response.

Because these values are not consistently escaped according to their output context (e.g., HTML body, attribute, JavaScript), an attacker can craft input containing script-relevant characters that the browser interprets as executable code.

The fundamental pattern is treating user-controlled data as safe content in a page's markup or script without enforcing a strict separation between data and executable code.

Potential impact

  • Theft of session identifiers or sensitive browser-stored data associated with the Kiteworks application
  • Impersonation of the victim user within the Kiteworks UI (e.g., performing actions on their behalf)
  • Unauthorized access to or exfiltration of sensitive information displayed in Secure Data Forms
  • Manipulation of user interface elements to conduct phishing or prompt users to disclose additional credentials or data
  • Injection of malicious content into the rendered page, which could mislead users or alter their actions

General mitigation guidance

Effective mitigation focuses on strict separation of data and code and on treating all client-supplied values as untrusted:

  • Apply context-appropriate output encoding to all user-controlled data before rendering it into HTML, attributes, URLs, or JavaScript blocks.
  • Enforce a centralized encoding and templating strategy, using server-side frameworks that automatically escape variables in views by default.
  • Restrict or normalize inputs that are reflected in responses, rejecting or transforming characters that are not valid for the intended field or context.
  • Prefer patterns that avoid dynamic HTML or script construction from raw request parameters; use safe templating instead of manual string concatenation.
  • Implement a Content Security Policy (CSP) that limits where scripts can load from and disallows inline script execution where feasible, reducing XSS impact.
  • Follow least-privilege principles in the web session model so that compromise of a single session grants only the minimal necessary capabilities.

How teams detect issues like this

Detection usually combines code-centric and behavior-centric approaches:

  • Static analysis: Configure SAST tools or linters to flag unencoded uses of request parameters in templates, string concatenations into HTML, or direct insertion into JavaScript blocks.
  • Code review: Examine Secure Data Forms handlers for patterns where raw query parameters, form fields, or headers are embedded into views without a standardized encoding API.
  • Template audits: Verify that templating engines are configured to escape by default and that any deliberate unescaped output is rare, well-documented, and strongly justified.
  • Dynamic testing (DAST): Use automated and manual penetration testing tools to inject XSS test payloads into form fields and query parameters, observing whether they are reflected.
  • Security policies: Enforce development guidelines that mandate use of shared encoding libraries and forbid custom HTML/JS construction from user input.

Sources

SourceLink
github.comgithub.com/kiteworks/security-advisories/security/advisories/GHSA-xp8m-wmmp-f947

Frequently asked

questions

Yes. An external attacker can exploit this issue by sending a crafted URL or causing a victim to load a malicious page that interacts with the Kiteworks Secure Data Forms endpoint, as long as the victim's browser can reach the application.

The attacker typically needs no authenticated access to the application itself to craft the malicious link, but they do need the ability to deliver that link to a user (for example via email or messaging) and rely on the victim's browser being logged in or able to access the Kiteworks instance.

The most robust fix is to ensure all user-controlled data is passed through a centralized, context-aware output encoding mechanism before being rendered, combined with strict input validation and use of templating frameworks that escape content by default.

Standardize on secure coding patterns for web output: always treat user input as untrusted, rely on vetted encoding libraries and secure templating engines, enforce XSS-focused checks in code review and CI pipelines, and support these processes with SAST/DAST tools and a restrictive Content Security Policy.

Find out what's already
exploitable in your codebase.