/

CVE-2025-61312

Severity:

HIGH RISK

(7.3)

Cross-Site Scripting (XSS) in docuForm acc-menu_pricess.php

CVE-2025-61312

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution / Session Compromise

Severity:

HIGH RISK

(7.3)

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 the acc-menu_pricess.php component of GmbH Mecury Managed Print Services (docuForm) v11.11c allows attacker-supplied data to be echoed back into the browser without proper sanitization.

If a victim is tricked into visiting a crafted URL, an attacker can execute arbitrary JavaScript in the victim's browser within the application's domain context.

Affected context

The vulnerability exists in web-based deployments of docuForm v11.11c that expose the acc-menu_pricess.php endpoint.

It appears when user-controlled input is incorporated into the page response without sufficient HTML/JavaScript escaping.

The risk increases when application users routinely follow links from emails, chat, or other external sources that embed parameters pointing to this component.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the docuForm application, specifically acc-menu_pricess.php
  • Required access: Ability to send or publish URLs to targeted users (e.g., via email, chat, or embedded links)
  • Trigger point: A victim's browser loads a crafted link where a query parameter or form value is reflected into the page without escaping
  • Why exploitation is possible: The server-side logic directly injects unsanitized input into the HTML/JavaScript output, allowing attacker-controlled script execution in the browser

Why this happens

This issue stems from rendering untrusted input into a web page without proper context-aware output encoding.

The acc-menu_pricess.php component likely reads a request parameter, then echoes it into the response HTML or JavaScript without escaping dangerous characters such as <, >, ", ', and /.

This matches CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), where the server treats user input as content but fails to neutralize it before mixing it with executable markup or script contexts.

Potential impact

  • Theft of session identifiers or authentication tokens stored in cookies or web storage
  • Execution of arbitrary JavaScript in the victim's browser under the application's origin
  • Unauthorized actions performed on behalf of the victim (e.g., changing settings, viewing or modifying data)
  • Injection of malicious content or redirects, enabling phishing or malware distribution
  • Harvesting of sensitive information displayed in the victim's browser session

General mitigation guidance

Effective mitigation focuses on robust output encoding and reducing trust in client-supplied data:

  • Apply context-aware output encoding for all user-controlled data rendered into HTML, attributes, URLs, or script blocks, using well-maintained encoding utilities
  • Validate and constrain inputs to expected formats (e.g., whitelisting characters or patterns) before using them in responses
  • Avoid directly concatenating user input into HTML or JavaScript; prefer safe templating engines that perform escaping by default
  • Enable and harden Content Security Policy (CSP) to reduce the impact of any residual XSS issues
  • Limit sensitive operations to CSRF-protected POST requests and minimize reliance on cookies that are accessible to JavaScript

How teams detect issues like this

Detection generally involves a mix of automated analysis and targeted review:

  • Use static analysis or linters to flag direct echo/print of request parameters in PHP or template files without encoding
  • During code review, look for patterns where $_GET, $_POST, or combined request variables are inserted into HTML/JS without passing through escaping helpers
  • Employ dynamic application security testing (DAST) tools to probe parameters for reflected XSS behavior
  • Add security-focused unit and integration tests that verify all reflected user inputs are safely encoded for their output context
  • Integrate automated scanning into CI/CD pipelines to catch new or reintroduced XSS patterns early

Sources

SourceLink
ZeroBreach.deZeroBreach.de
gist.github.comgist.github.com/ZeroBreach-GmbH/c970fab734432e6f9bc39b2d20f96e5c
docuform.dedocuform.de/

Frequently asked

questions

Yes. An attacker can host or send a malicious link targeting the vulnerable endpoint; exploitation occurs when a victim's browser follows that link and loads the page.

Not necessarily. If the vulnerable endpoint is accessible without authentication, anyone who can craft and send URLs can attempt exploitation. If access requires login, the attacker must either have an account or convince an already authenticated user to click the crafted link.

Ensure that all data originating from the client is properly validated and then encoded according to its output context (HTML body, attribute, URL, or JavaScript). Use trusted templating or helper functions that apply context-aware escaping by default, and remove any direct concatenation of raw request parameters into response markup.

Adopt a standardized encoding library, enforce secure coding guidelines for handling user input, and integrate static/dynamic security tests into the development workflow. Combining these with defense-in-depth measures such as CSP and strict input validation greatly reduces the likelihood and impact of future XSS vulnerabilities.

Find out what's already
exploitable in your codebase.