/

CVE-2025-45869

Severity:

HIGH RISK

(7.3)

SSRF (CWE-918) in LogicalDOC ShareFileCallback

CVE-2025-45869

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Network Access and Data Exposure

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

LogicalDOC Enterprise up to version 9.1.1 contains a server-side request forgery (SSRF) flaw in the ShareFileCallback servlet that allows the application server to initiate arbitrary HTTP requests.

By manipulating request parameters, an unauthenticated attacker can coerce the server into connecting to attacker-controlled hosts or internal services, exposing internal network resources and sensitive data.

Affected context

This vulnerability occurs in deployments of LogicalDOC Enterprise that expose the ShareFileCallback servlet over HTTP/HTTPS.

It is relevant where the application is allowed to make outbound connections (e.g., to external file-sharing or integration endpoints) and where network segmentation permits access to internal services from the application server.

Environments with default or permissive outbound firewall rules and insufficient validation of callback URLs are particularly susceptible.

Exploit preconditions

  • Attack surface: Publicly accessible ShareFileCallback servlet endpoint.
  • Required access: No authentication required; the flaw is reachable by any party able to send HTTP requests to the LogicalDOC server.
  • Trigger point: Attacker-controlled input parameters that define or influence the target URL for server-side callbacks or file-sharing operations.
  • Why exploitation is possible: The servlet constructs and issues outbound HTTP requests based directly on user-supplied values without robust validation, normalization, or restriction of target hosts, protocols, or paths.

Why this happens

The underlying issue maps to CWE-918: Server-Side Request Forgery (SSRF), where an application acts as an unintended proxy due to trusting client-supplied URLs or network locations.

In this case, the ShareFileCallback servlet uses attacker-controlled parameters to build server-side HTTP requests, likely without enforcing a strict allowlist or verifying that destinations are safe and external.

This insecure pattern allows an attacker to abuse legitimate integration logic to pivot into internal networks, query metadata services, or interact with services that were never meant to be internet-facing.

Potential impact

  • An attacker may cause the server to access internal HTTP services not directly exposed to the internet.
  • An attacker could retrieve sensitive information from internal APIs or cloud metadata services, depending on response handling.
  • An attacker may scan internal network services and infer topology, ports, and available endpoints.
  • An attacker could leverage SSRF to reach other vulnerable components and potentially chain it with additional flaws for deeper compromise.
  • An attacker can use the application as a network proxy to hide their origin when interacting with third-party systems.

General mitigation guidance

Effective mitigation focuses on reducing trust in user-controlled URLs and hardening outbound network behavior.

Common defensive patterns include:

  • Restricting callback and integration destinations to a strict allowlist of known, vetted domains and protocols.
  • Normalizing and validating all user-supplied URLs, blocking access to private IP ranges, localhost, and internal hostnames by default.
  • Implementing network-level egress controls so application servers cannot freely connect to arbitrary internal or external hosts.
  • Designing integrations so that sensitive internal services are never directly reachable via generic HTTP client utilities used for user-driven callbacks.
  • Applying least-privilege principles to service accounts and network routes so that, even if SSRF occurs, reachable resources are minimal and low impact.

How teams detect issues like this

Detection typically combines code-level analysis with runtime monitoring:

  • Use static analysis or manual review to locate servlet or controller logic that constructs outbound HTTP requests from request parameters, especially in integration or callback components.
  • Flag patterns where URL strings, hostnames, or URIs are derived directly from user input without passing through strict validation or allowlisting.
  • Monitor application logs and network telemetry for unusual outbound connection patterns, such as requests to internal IP ranges (10.x, 172.16–31.x, 192.168.x) or cloud metadata endpoints.
  • Enforce security policies in CI/CD that require explicit destination controls for components using HTTP client libraries.
  • Consider automated application security testing tools that include SSRF-specific checks against exposed endpoints.

Sources

SourceLink
github.comgithub.com/netero1010/Vulnerability-Disclosure/blob/main/CVE-2025-45869/README.md
logicaldoc.comlogicaldoc.com/

Frequently asked

questions

It is broadly exploitable in any environment where the ShareFileCallback servlet is accessible over the network and the server can make outbound HTTP requests, because no authentication is required to trigger the flaw.

The attacker only needs network access to the LogicalDOC HTTP endpoint hosting the ShareFileCallback servlet; no valid credentials are necessary to attempt exploitation.

The safest pattern is to ensure that any URLs or hosts used by server-side callbacks are strictly controlled: implement allowlists for destinations, block access to internal address ranges, and avoid constructing HTTP requests directly from user-supplied parameters.

To prevent similar issues, adopt design guidelines that treat outbound requests based on user input as high risk, enforce central URL validation utilities, restrict egress at the network layer, and include SSRF-specific checks in code reviews and automated security testing.

Find out what's already
exploitable in your codebase.