/

CVE-2026-26723

Severity:

HIGH RISK

(8.2)

XSS in Key Systems Global Facilities Management Software

CVE-2026-26723

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Arbitrary JavaScript Execution in Victim's Browser

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 Key Systems Inc Global Facilities Management Software v. 20230721a allows untrusted data supplied via the function parameter to be returned to the browser without proper output encoding.

Under typical browser conditions, an attacker can craft a malicious link that, when visited by a victim, executes arbitrary script code in the context of the application's domain.

Affected context

The vulnerability occurs in web-facing functionality of the Global Facilities Management Software where the function parameter is accepted via HTTP requests and reflected into HTML or script responses.

It is relevant in deployments where:

  • The application is accessible over a network to users (internal or external)
  • The function parameter is controllable via URL, form fields, or query parameters
  • Output encoding or context-aware escaping is missing or incomplete before rendering the value in the browser

The issue is most impactful when exposed to authenticated users with elevated privileges, as their session context can be abused.

Exploit preconditions

  • Attack surface: Web interface of the Global Facilities Management Software
  • Required access: Ability to send crafted HTTP requests or links to application users; no prior authentication may be required depending on where the parameter is processed
  • Trigger point: User visits a maliciously crafted URL or interacts with content that submits the tainted function parameter to the vulnerable endpoint
  • Why exploitation is possible: The application reflects attacker-controlled data from the function parameter into the response without context-appropriate output encoding or sanitization, allowing injected script to run in the browser

Why this happens

This vulnerability stems from improper neutralization of input before it is included in web pages, mapping directly to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

The application takes the function parameter, treats it as display or logic data, and places it into an HTML or script context without applying strict validation and context-aware output encoding.

Because modern browsers execute script embedded in trusted page content, any unescaped control characters or script fragments supplied by an attacker can be interpreted as executable JavaScript.

Potential impact

  • Theft or misuse of user session cookies or authentication tokens (subject to browser protections)
  • Execution of arbitrary JavaScript in the victim's browser under the application's origin
  • Unauthorized actions performed on behalf of authenticated users (e.g., data changes, workflow approvals)
  • Defacement or injection of misleading content into the application's UI
  • Facilitation of further attacks such as phishing, credential harvesting, or pivoting to other internal assets

General mitigation guidance

Effective mitigation focuses on treating all user-supplied data, including the function parameter, as untrusted and applying strict output handling:

  • Apply context-aware output encoding (HTML, attribute, URL, JavaScript contexts) right before data is written into the response.
  • Enforce allowlists for expected values of the function parameter (e.g., pre-defined function names or identifiers) and reject or normalize anything outside that set.
  • Avoid constructing HTML or script fragments by string concatenation; prefer templating systems and frameworks that auto-encode by default.
  • Reduce the attack surface by minimizing the need to reflect raw user input; use opaque identifiers instead of free-form text where possible.
  • Complement code-level defenses with browser-side controls such as a restrictive Content Security Policy (CSP) to limit script execution sources and inlined scripts.

How teams detect issues like this

Detection typically combines code-level and runtime inspection:

  • Static analysis: Search for response generation code that includes request parameters (notably function) without passing through encoding/escaping routines; configure SAST rules targeting CWE-79 patterns.
  • Code review: Flag any use of query or form parameters directly embedded into templates, inline JavaScript, or DOM-building logic; verify that all outbound data is encoded according to its context.
  • Dynamic testing: Use automated scanners or manual penetration tests to inject benign XSS probes into the function parameter and monitor responses for unsanitized reflections.
  • Security policies: Enforce linting and framework-level guidelines that prohibit unsafe output functions and warn when encoding APIs are bypassed.

Sources

SourceLink
github.comgithub.com/chndlrx/vulnerability-disclosures/tree/main/CVE-2026-26723

Frequently asked

questions

Yes. An attacker can exploit this issue by sending or embedding a malicious URL that includes a crafted function parameter, causing code execution when a victim's browser loads the page.

It depends on where the vulnerable parameter is processed. If the affected endpoint is public, no authentication may be required to trigger XSS, although impact is greater when targeting authenticated users with meaningful privileges.

The safest approach is to combine strict allowlisting of acceptable function parameter values with context-aware output encoding on every use, and to avoid mixing raw user-controlled data into HTML or script constructs.

Adopt a systematic XSS defense strategy: use frameworks that auto-escape by default, mandate context-aware encoding at all output boundaries, minimize reflection of user input, and enforce secure coding guidelines with automated checks in the development and review process.

Find out what's already
exploitable in your codebase.