Summary
A server-side request forgery (SSRF) vulnerability in Ech0's unauthenticated /api/website/title endpoint allows attackers to supply arbitrary URLs that the server will fetch on their behalf.
By abusing this behavior, an attacker can probe internal services, cloud metadata endpoints, and localhost-only interfaces, with partial data from the target response exfiltrated via the extracted HTML <title> tag.
Affected context
The issue occurs in Ech0 instances that expose the /api/website/title endpoint to untrusted clients, such as over the public internet or shared networks.
The endpoint takes a website_url query parameter and performs a server-side HTTP request to that URL without validating destination hosts, IP ranges, or protocols.
This becomes risky when the Ech0 server has network access to internal services, metadata endpoints (e.g., 169.254.169.254), or localhost-only applications that are not otherwise reachable from the attacker's environment.
Exploit preconditions
- Attack surface: HTTP GET requests to
/api/website/title - Required access: None; the endpoint is unauthenticated and accepts input from any network client that can reach the Ech0 instance
- Input control: Ability to control the
website_urlquery parameter and point it at arbitrary URLs (including internal IPs and hostnames) - Network conditions: The Ech0 server can reach internal services, cloud metadata endpoints, or localhost-restricted applications through its network interfaces
- Why exploitation is possible: The server performs outbound HTTP requests based solely on user-supplied URLs, with no allowlist, blocklist, or network boundary checks, and returns data derived from the remote response (the
<title>element) to the attacker
Why this happens
This vulnerability stems from unvalidated server-side HTTP requests initiated based on user-controlled input, mapping directly to CWE-918: Server-Side Request Forgery (SSRF).
The /api/website/title endpoint is designed to fetch remote web pages and extract their <title> tag, but it trusts the website_url parameter without constraining which hosts or IP ranges are eligible targets.
As a result, external users can coerce the Ech0 server into acting as a network proxy, reaching resources that are only accessible from the server's network location.
Even though only the page title is returned, this transformation still leaks information about internal endpoints and can be chained with other weaknesses for broader compromise.
Potential impact
- Discovery and probing of internal HTTP services that are not directly exposed to the internet
- Access to cloud provider metadata services (e.g.,
http://169.254.169.254) that may return instance credentials or configuration data via the<title>or error messages - Interaction with localhost-bound admin panels, dashboards, or development services that rely on network isolation for security
- Partial data exfiltration through HTML
<title>contents and HTTP error messages that can reveal service names, versions, or environment details - Facilitation of further attacks such as credential theft, pivoting into internal networks, or chaining with other vulnerabilities reachable from the Ech0 host
General mitigation guidance
Effective mitigation focuses on constraining where server-side HTTP requests can go and reducing trust in user-supplied URLs.
Common defensive patterns include:
- Implementing strict allowlists for outbound destinations (e.g., specific domains or hostnames) that the server is permitted to fetch
- Rejecting or blocking requests to private, loopback, link-local, and metadata IP ranges (such as
127.0.0.0/8,10.0.0.0/8,169.254.0.0/16,172.16.0.0/12,192.168.0.0/16) and tolocalhostor similar internal hostnames - Normalizing and validating URLs after DNS resolution, re-checking that the resolved IP address is still within allowed ranges to avoid DNS rebinding issues
- Limiting response processing to reduce information leakage (e.g., not returning raw content or verbose error messages derived from internal responses)
- Running the application in a network-segmented environment where outbound connectivity from the web tier to sensitive internal or metadata services is minimized
- Applying least-privilege principles to any credentials or tokens that may be available to the Ech0 server, so that compromised requests have limited blast radius
How teams detect issues like this
Detection generally relies on a combination of code analysis, configuration review, and runtime monitoring:
- Static analysis and SAST: Search for HTTP client usage (e.g.,
fetch,axios,requests, or framework-specific HTTP utilities) where the URL or target host is derived from request parameters without validation, particularly in public API handlers. - Code review signals: Flag endpoints that:
- Accept full or partial URLs from clients
- Make outbound network calls from request handlers
- Do not enforce host/IP allowlists, blocklists, or network boundary checks
- Security testing (DAST): Use dynamic security scanners or manual testing to supply internal and metadata IPs to URL-taking endpoints and observe whether the response changes with the internal target.
- Logging and monitoring: Instrument outbound HTTP calls with structured logs that record destination host, IP, and calling endpoint, then alert on:
- Requests to private, loopback, or link-local IP ranges
- Traffic patterns targeting
169.254.169.254or similar metadata endpoints - Policy enforcement: Integrate security checks into CI/CD to prevent introducing new unaudited SSRF-like patterns and to enforce secure network egress policies at the platform level.

