Summary
FOG up to version 1.5.10.1754 contains an unauthenticated server-side request forgery (SSRF) vulnerability in getversion.php, where a user-controlled url parameter is used to make outbound requests.
By abusing this behavior, an attacker can coerce the FOG server into fetching internal web resources or local files, even without an authenticated web session when using the newService=1 flag.
Affected context
The issue occurs in FOG deployments that expose the getversion.php endpoint over HTTP(S), specifically in versions 1.5.10.1754 and below.
The vulnerability manifests when the application accepts a url parameter from the client and uses it to perform outbound HTTP or file fetch operations without sufficient validation or access control.
The problem is reachable even without a logged-in session if the request includes the newService=1 parameter, expanding the attack surface to any unauthenticated caller who can contact the FOG web interface.
Exploit preconditions
- Attack surface: Public or internal HTTP(S) access to the FOG web interface exposing getversion.php.
- Required access: Network-level ability to send HTTP requests to the FOG server; no valid user account is required if newService=1 is honored unauthenticated.
- Trigger point: An HTTP request to getversion.php with a crafted url parameter (and newService=1) that points to an internal host, internal web service, or local resource URL.
- Why exploitation is possible: The server trusts the caller-supplied url value and uses it directly to perform server-side requests, without enforcing strict allowlists, scheme restrictions, or authentication checks, allowing the attacker to pivot through the FOG host to other internal locations.
Why this happens
This vulnerability arises from using user-controlled input as a target for server-initiated network or file access without sufficient validation.
In getversion.php, the url parameter is treated as a trusted destination for outbound requests, embodying the pattern described by CWE-918: Server-Side Request Forgery (SSRF).
The code path likely lacks:
- Proper authentication or authorization checks for invoking remote fetch functionality
- Strict filtering or allowlisting of permissible URL schemes and hosts
- Separation between externally reachable update/version checks and internal or local-only resources
As a result, the FOG server can be coerced into making requests to internal services or file endpoints that would not normally be exposed to the attacker.
Potential impact
- Access to internal HTTP-based services that are not directly exposed to the attacker
- Retrieval of sensitive configuration data or metadata from local or internal endpoints
- Exposure of local files on the FOG server if file-like URLs or equivalent mechanisms are supported
- Use of the FOG server as a pivot to map or probe internal network topology
- Potential assistance in chaining with other vulnerabilities (e.g., hitting internal management panels or metadata services)
General mitigation guidance
Effective mitigation generally focuses on reducing trust in user-supplied URLs and constraining where the server can connect:
- Introduce strict allowlisting of remote endpoints that getversion.php (or equivalent update/version check code) is allowed to contact, such as specific vendor update servers or known domains.
- Reject or strip dangerous URL schemes (e.g., file-like or non-HTTP schemes) and restrict requests to HTTPS/HTTP over approved ports.
- Enforce authentication or capability checks before permitting any server-side network fetch initiated by a client-provided URL.
- Log and monitor unusual target URLs for version or update checks to detect misuse.
- Consider separating update/version retrieval logic from the main web interface, minimizing endpoints that accept arbitrary URLs, and design features to prefer static configuration or server-side-managed endpoints over user-supplied ones.
- Where possible, run the FOG web component with least-privileged network access (e.g., firewalling or egress controls that limit which internal addresses it can reach).
How teams detect issues like this
Detection typically involves a combination of code-level and operational measures:
- Static analysis: Search PHP code for patterns where remote resources are fetched using directly concatenated or passed-through request parameters (e.g., using file_get_contents, curl, or wrappers with $_GET/$_POST data).
- Code review: Flag any endpoint that:
- Accepts a URL or host parameter from the client, and
- Uses it for server-side HTTP/HTTPS or file access without strict allowlisting or authentication.
- Configuration and policy checks: Establish secure coding guidelines that forbid arbitrary user-driven URL fetches, and enforce them via code review templates or pre-commit hooks.
- Runtime monitoring: Inspect web server and application logs for repeated calls to getversion.php (or similar endpoints) with unexpected or internal-looking URLs (e.g., 10.x.x.x, 192.168.x.x, 127.0.0.1, or hostnames used only internally).
- Optional automated tools (SAST/DAST) can be tuned with rules for SSRF patterns, enhancing early-stage detection in CI pipelines.

