Summary
A Server-Side Request Forgery (SSRF) vulnerability in changedetection.io's watch URL handling allows attackers to make the server fetch arbitrary URLs, including internal network endpoints.
When authentication is weak or disabled (the default), a user can register internal URLs as "watches," causing the server to retrieve and expose the response content via the web UI, enabling data exfiltration from otherwise non-public services.
Affected context
This vulnerability affects deployments of changedetection.io that:
- Allow users to add or modify watch URLs through the web interface
- Run with default or weak authentication controls, or where many users can create watches
- Are deployed on hosts or containers with network access to internal or sensitive services (e.g., intranet apps, metadata services, admin panels, or databases over HTTP)
The issue arises because the application's URL validation only inspects the URL string and not the resolved IP address, allowing access to private, loopback, or link-local address ranges.
Exploit preconditions
- Attack surface: The web interface where users can configure or update watch URLs.
- Required access:
- Any network access to the changedetection.io web UI.
- No authentication needed if password is not configured (default), otherwise a valid user account is enough.
- Trigger point: Submitting or editing a watch that points to an internal or otherwise non-public URL (e.g., http://127.0.0.1:8080, http://10.0.0.5/, or link-local/metadata endpoints).
- Why exploitation is possible: The URL validation function
is_safe_valid_url()checks the URL syntactically but does not validate the resolved IP against private, loopback, or link-local ranges. The server then performs the HTTP request itself and stores the full response, which is rendered back to the user, turning the application into a blind proxy into internal networks.
Why this happens
The underlying issue is incomplete URL safety validation in the context of server-initiated HTTP requests.
Instead of treating user-supplied URLs as untrusted and constraining where the server may connect, the validation logic focuses on URL format and misses a critical step: resolving the hostname and verifying that the resulting IP address does not belong to private, loopback, or link-local address ranges.
This matches CWE-918: Server-Side Request Forgery, where an attacker controls the target of a server-side HTTP client and leverages the server's own network position to reach internal or protected resources.
The bug is conceptual rather than purely syntactic: any design that allows arbitrary user URLs to be fetched server-side, without strict allowlisting or IP/network checks, creates an SSRF risk.
Potential impact
- Exfiltration of sensitive data from internal web applications accessible from the changedetection.io host.
- Exposure of administrative interfaces or management panels that are not directly reachable from the attacker's network.
- Discovery and mapping of internal network services (hostnames, ports, technologies) via response content and error behavior.
- Potential interaction with cloud metadata services (if reachable), which may lead to credential disclosure or further privilege escalation.
- Use of the server as a pivot point for additional attacks against internal HTTP-based services (e.g., abusing internal APIs).
General mitigation guidance
Effective mitigation typically combines network-level controls with defensive URL handling patterns:
- Treat user-controlled URLs as untrusted input and apply strict allowlists (e.g., only specific hostnames or domains that are meant to be monitored).
- Resolve hostnames server-side and verify that the resulting IP is not within:
- Loopback ranges (127.0.0.0/8, ::1)
- Private RFC1918 ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16)
- Link-local and other non-routable ranges (169.254.0.0/16, fe80::/10, etc.).
- Deny or heavily restrict requests to bare IP addresses, especially those in internal ranges.
- Use a dedicated outbound proxy or egress gateway with policies that limit where the application can connect, decoupling user input from raw network reachability.
- Run the application with least-privilege network access, isolating it from unnecessary internal networks or metadata endpoints.
- Enable and enforce authentication by default, and restrict who can create or modify watch URLs, especially in multi-tenant environments.
How teams detect issues like this
Organizations can detect and monitor for SSRF patterns using a blend of code-level and operational techniques:
- Static analysis / code review:
- Flag internal HTTP client calls (e.g., requests.get, fetch, HTTP libraries) that consume user-controlled URLs.
- Check URL validation helpers to ensure they perform hostname resolution and enforce IP/network allow/deny rules.
- Look for absence of allowlists or IP range checks where outbound connections are driven by user input.
- Configuration and policy enforcement:
- Implement CI checks that reject changes introducing unrestricted outbound HTTP calls.
- Enforce security policies requiring explicit allowlists for any functionality that fetches remote content on behalf of users.
- Runtime monitoring:
- Log outbound HTTP requests, including destination IP/host, and alert on connections to private or unexpected networks.
- Monitor for abnormal patterns of watch creation pointing to local or private IPs.
- Automated SAST/DAST tools, when configured with SSRF-specific rules, can help surface these patterns early in development and test environments.

