/

CVE-2026-27696

Severity:

HIGH RISK

(8.6)

SSRF in changedetection.io Watch URL Handling

CVE-2026-27696

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Data Exfiltration via SSRF

Severity:

HIGH RISK

(8.6)

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 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.

Sources

SourceLink
github.comgithub.com/dgtlmoon/changedetection.io/commit/fe7aa38c651d73fe5f41ce09855fa8f97193747b
github.comgithub.com/dgtlmoon/changedetection.io/security/advisories/GHSA-3c45-4pj5-ch7m

Frequently asked

questions

Yes. If the changedetection.io instance is reachable over the network and is running with no password (the default) or with weak/guessable credentials, a remote attacker can create watches pointing to internal URLs, effectively exploiting SSRF from anywhere they can access the web UI.

The attacker needs the ability to add or modify watch URLs. By default, this may require no authentication if a password is not configured. In deployments where authentication is enabled, any authenticated user with permission to create or edit watches can potentially exploit the bug.

The most robust pattern is to combine strict URL allowlisting with IP-based network restrictions: resolve hostnames, block private/loopback/link-local ranges, and only permit connections to explicitly trusted domains or hosts. Additionally, ensure the application never acts as a generic proxy for arbitrary user-supplied URLs.

Design features that fetch remote resources on behalf of users with SSRF in mind: define clear trust boundaries, restrict outbound destinations via allowlists and network controls, validate resolved IP addresses, and avoid granting the application broad access to internal networks. Incorporate these rules into coding standards, security reviews, and CI checks so that unsafe patterns are caught during development rather than in production.

Find out what's already
exploitable in your codebase.