/

CVE-2026-35037

Severity:

HIGH RISK

(7.2)

Server-Side Request Forgery (SSRF) in Ech0 Website Title API

CVE-2026-35037

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and limited data exfiltration via server-side HTTP requests

Severity:

HIGH RISK

(7.2)

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 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_url query 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 to localhost or 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.254 or 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.

Sources

SourceLink
github.comgithub.com/lin-snow/Ech0/security/advisories/GHSA-cqgf-f4x7-g6wc

Frequently asked

questions

Yes. The vulnerable /api/website/title endpoint requires no authentication, so any remote user who can reach the Ech0 instance can attempt to exploit it by supplying crafted URLs.

Only network access to the Ech0 HTTP interface is required. The attacker does not need valid credentials or an existing account; they just need to send requests that include a malicious website_url parameter.

The most robust pattern is to strictly control where server-side HTTP requests can go, typically by enforcing host/domain allowlists, blocking internal and metadata address ranges, and validating resolved IP addresses. Avoid designing endpoints that act as open HTTP proxies for arbitrary URLs, and ensure any remaining network calls are narrowly scoped.

Treat any functionality that makes outbound network requests based on user input as high risk by default. During design and code review, require justification for such features, enforce URL and IP validation, apply network egress controls at the infrastructure level, and include SSRF-focused checks in automated testing and secure coding guidelines.

Find out what's already
exploitable in your codebase.