/

CVE-2026-30918

Severity:

HIGH RISK

(7.6)

XSS in facileManager fmDNS log_search_query Parameter

CVE-2026-30918

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution in User Browser

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

A reflected cross-site scripting (XSS) vulnerability in the fmDNS module of facileManager allows attacker-controlled input in the log_search_query parameter to be echoed back into HTTP responses without proper output encoding.

When a victim visits a crafted URL, malicious JavaScript embedded in this parameter can execute in the context of the application's domain, potentially leading to session hijacking, credential theft, or unauthorized actions.

Affected context

The issue occurs in the fmDNS module of facileManager when handling HTTP requests that include the log_search_query parameter.

The application reflects this value into the response page without consistently applying context-appropriate output encoding.

The vulnerability is most relevant in deployments where URLs containing this parameter are shared, logged, or linked in a way that could entice or mislead users into clicking attacker-crafted links.

Exploit preconditions

  • Attack surface: Public or internal web interface of the fmDNS module in facileManager.
  • Required access: Ability to send crafted URLs to target users (e.g., via email, chat, or embedded links); no prior authentication may be needed if the vulnerable page is accessible without login.
  • Trigger point: A victim user (typically with a browser session to facileManager) must follow a malicious link where the log_search_query parameter contains injected script.
  • Why exploitation is possible: The application takes untrusted input from the log_search_query parameter and reflects it directly into the HTML response without proper escaping or encoding, allowing injected script to be interpreted by the browser.

Why this happens

This vulnerability stems from insufficient output encoding of user-controlled data in server-generated HTML, aligning with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

The log_search_query parameter is accepted from the HTTP request and embedded into the response without context-aware escaping for HTML (or potentially JavaScript/attribute) contexts.

As a result, attackers can craft values that break out of the intended markup structure and introduce executable JavaScript, which the browser then runs in the security context of the facileManager domain.

Potential impact

  • Execution of arbitrary JavaScript in the victim's browser within the facileManager domain
  • Theft of session identifiers or other sensitive tokens stored in the browser
  • Unauthorized actions performed on behalf of the victim via session riding within the application
  • Manipulation of UI or displayed data to phish credentials or mislead administrators
  • Potential pivot to broader compromise of administrative workflows managed via facileManager

General mitigation guidance

Effective mitigation focuses on treating all client-supplied data as untrusted and ensuring it is safely represented in the response:

  • Apply context-aware output encoding for any data derived from log_search_query (e.g., HTML-escaping for element bodies, attribute encoding for attributes, JavaScript encoding for script contexts).
  • Avoid directly concatenating request parameters into HTML or client-side scripts; instead, pass values through templating engines or helper functions that enforce encoding by default.
  • Prefer server-side rendering patterns or frameworks that default to escaping and require explicit opt-out for raw HTML insertion.
  • Normalize and, where reasonable, restrict the allowed characters or patterns in search-related parameters to reduce attack surface.
  • Implement a general XSS defense strategy (e.g., content security policy, strict cookie attributes) as defense-in-depth, recognizing these do not replace proper output encoding.
  • Separate display logic from raw request handling so that all user-controlled fields pass through a central sanitization/encoding layer.

How teams detect issues like this

Organizations can identify and monitor this class of issue through a combination of review and testing:

  • Static analysis: Scan source code for patterns where request parameters (e.g., $_GET, $_POST, framework request objects) are directly embedded in views or echo statements without encoding.
  • Code review: Flag templates or controllers that inject variables into HTML, attributes, inline event handlers, or scripts; verify that all such variables pass through standard escaping helpers.
  • Dynamic testing: Use automated web scanners and manual penetration tests to probe parameters like log_search_query with typical XSS payload markers and observe reflected output.
  • Security policies: Enforce secure coding guidelines requiring context-aware escaping for all user input, backed by pre-merge checks and security gates in CI/CD.
  • Runtime monitoring: Employ web application firewalls or RASP solutions configured to detect and alert on anomalous script injection patterns, understanding they are complementary to code fixes.

Sources

SourceLink
github.comgithub.com/facileManager/facileManager/security/advisories/GHSA-284f-mff7-744x

Frequently asked

questions

Yes. An attacker can exploit it remotely by sending or embedding a crafted URL that includes a malicious value in the log_search_query parameter, as long as the target user's browser can reach the vulnerable facileManager fmDNS interface.

It depends on the deployment and access controls. If the page that processes log_search_query is publicly accessible, no authentication is needed. If it is restricted, the attacker must convince an authenticated user (such as an administrator) to click the malicious link while logged in.

The most robust fix is to ensure that all uses of log_search_query in responses go through strict, context-appropriate output encoding and to adopt templating or helper APIs that escape by default. Avoid printing raw parameter values into HTML or scripts and centralize encoding logic so it is applied consistently.

Preventive strategies include enforcing a secure coding standard that mandates output encoding for all untrusted data, using frameworks that default to safe rendering, conducting regular code reviews and automated scanning for XSS patterns, and complementing these with defense-in-depth controls like CSP and hardened cookie settings.

Find out what's already
exploitable in your codebase.