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
functionparameter 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
functionparameter to the vulnerable endpoint - Why exploitation is possible: The application reflects attacker-controlled data from the
functionparameter 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
functionparameter (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
functionparameter 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.

