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.

