/

CVE-2026-72860

Severity:

HIGH RISK

(8.5)

SSRF (CWE-918) in 9router Provider Node Validation API

CVE-2026-72860

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-184, CWE-918

Impact:

Internal Network Access, Information Disclosure, and Credential Exposure

Severity:

HIGH RISK

(8.5)

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 vulnerability in 9router allows the provider-node validation endpoint to request caller-selected URLs without reliably confirming that destinations are public. An attacker who can access the endpoint may reach internal services, disclose limited response data, scan internal ports, or forward a supplied API key to an unintended destination.

Affected context

The issue occurs in deployments where the POST /api/provider-nodes/validate route accepts a caller-controlled baseUrl and performs server-side HTTP requests. Risk is higher when the endpoint is reachable by an authenticated dashboard user, when login enforcement is disabled, or when internal services are accessible from the 9router runtime. The validation logic relies on hostname-string checks rather than verified destination addresses and does not consistently account for redirects or IPv4-mapped IPv6 representations.

Exploit preconditions

  • Attack surface: The provider-node validation API and its server-side HTTP client
  • Required access: A dashboard session by default; no authentication when requireLogin is disabled
  • Trigger point: Submission of a provider-node validation request containing a caller-controlled destination
  • Why exploitation is possible: Destination validation does not resolve hostnames, revalidate redirected destinations, or correctly reject all IPv4-mapped IPv6 forms
  • Additional condition: The 9router process must have network reachability to an internal service for meaningful impact

Why this happens

The vulnerability is caused by incomplete SSRF defenses that treat hostname-string inspection as equivalent to validating the actual network destination. The guard does not perform DNS resolution, does not enforce destination checks after redirects, and contains an IPv4-mapped IPv6 check that is incompatible with the canonical form produced by the URL parser. Consequently, attacker-controlled names or address representations can resolve to private, loopback, or link-local networks while passing the filter. This maps primarily to CWE-918: Server-Side Request Forgery; the incomplete filtering behavior also relates to CWE-184: Incomplete List of Disallowed Inputs. Forwarding the caller-supplied API key further increases the impact when an internal destination receives the request.

Potential impact

  • An attacker could access loopback, link-local, or other internal HTTP services
  • Internal service responses may be partially disclosed through validation errors
  • Internal ports and services could be mapped through status and timing differences
  • A caller-supplied API key could be exposed to an unintended internal destination
  • Cloud or platform metadata could be queried where network access permits
  • Internal administrative interfaces could be reached and potentially abused

General mitigation guidance

Mitigation generally focuses on validating the effective network destination rather than only the original hostname string.

Common defensive patterns include:

  • Resolve hostnames and reject private, loopback, link-local, reserved, and otherwise non-public address ranges across IPv4 and IPv6
  • Normalize and validate all supported URL representations, including IPv4-mapped IPv6 addresses
  • Revalidate the destination for every redirect or disable redirects unless explicitly required
  • Use an outbound HTTP policy or egress proxy with an allowlist of permitted destinations
  • Avoid forwarding caller-controlled credentials to arbitrary upstream URLs
  • Return minimal, uniform validation errors without reflecting upstream response bodies
  • Apply authentication and authorization consistently to validation endpoints
  • Run the service with restricted network permissions and least-privilege credentials

How teams detect issues like this

Organizations can detect SSRF risks through:

  • Static analysis rules for server-side HTTP clients fed by request parameters
  • Code review checks for hostname-only filtering, unrestricted redirects, and missing DNS or IP-range validation
  • Tests covering private IPv4 and IPv6 ranges, mapped address representations, DNS rebinding behavior, and redirect destinations
  • Monitoring for validation requests targeting unusual hosts, link-local addresses, loopback ranges, or high volumes of distinct internal ports
  • Egress firewall and proxy policies that alert on unauthorized internal or metadata-service access
  • Review of logs for upstream response-body reflection and unexpected Authorization headers

Automated security review tools can help identify request-to-network data flows, but policy enforcement at the network boundary remains important.

Sources

SourceLink
github.comgithub.com/decolua/9router
github.comgithub.com/decolua/9router/blob/master/src/app/api/provider-nodes/validate/route.js
github.comgithub.com/decolua/9router/blob/master/src/shared/utils/ssrfGuard.js
github.comgithub.com/decolua/9router/issues/3293
github.comgithub.com/decolua/9router/pull/3370
vulncheck.comvulncheck.com/advisories/9router-server-side-request-forgery-via-api-provider-nodes-validate-because-the-ipv4-mapped-ipv6-denylist-check-is-unreachable

Frequently asked

questions

It can be exploitable through the network-facing validation route when an attacker has the required dashboard access, or without authentication if login enforcement is disabled. The vulnerable server must also be able to reach the targeted internal destination.

A dashboard session is required by default. Deployments that disable the login requirement may expose the route to unauthenticated callers.

Validate the resolved destination address against a strict public-network policy, handle IPv4 and IPv6 canonicalization correctly, recheck every redirect, and avoid forwarding caller-controlled credentials to arbitrary destinations.

Combine application-layer destination validation with outbound network allowlists, consistent authentication, restricted service privileges, security-focused tests, and monitoring for unexpected internal egress.

Find out what's already
exploitable in your codebase.