Summary
Nginx UI versions 2.3.4 and earlier allow an authenticated user to abuse the cluster node feature to perform Server-Side Request Forgery (SSRF).
By registering a cluster node that points to an arbitrary internal URL and sending API requests with a crafted X-Node-ID header, an attacker can have the Proxy middleware forward requests to internal services that should not be directly reachable, including those bound to localhost or restricted network segments.
Affected context
This vulnerability appears in Nginx UI deployments that:
- Expose the web interface to authenticated users who can manage or reference cluster nodes
- Use the built-in Proxy middleware to route API traffic based on an
X-Node-IDheader - Run Nginx UI in environments where internal services or localhost-bound endpoints are reachable from the Nginx UI host
In these conditions, internal-only HTTP(S) services become indirectly accessible through the Nginx UI server acting as a proxy, despite network segmentation or firewalling on the perimeter.
Exploit preconditions
- Attack surface: HTTP(S) interface of Nginx UI (web UI or API).
- Required access: Valid authenticated user with the ability to create or control cluster node configuration, or influence the
X-Node-IDheader. - Trigger point: Sending API requests through Nginx UI that are routed via the Proxy middleware using a chosen
X-Node-ID. - Why exploitation is possible: The application trusts the cluster node configuration and the
X-Node-IDselector without sufficient validation of target addresses or network scope, allowing user-controlled configuration to direct server-originated requests to arbitrary internal URLs.
Why this happens
The underlying issue is a classic Server-Side Request Forgery pattern, where untrusted user input indirectly controls where the server sends outbound HTTP requests.
In this case, the combination of:
- User-configurable cluster node endpoints, and
- Request routing based on a client-set
X-Node-IDheader
allows an authenticated user to turn the Nginx UI host into a generic HTTP proxy to arbitrary internal destinations.
This maps to CWE-918: Server-Side Request Forgery (SSRF), where the server's ability to reach internal or protected resources is exposed through insufficient validation of user-supplied URLs or routing metadata.
Potential impact
- Access to internal HTTP(S) services that are not directly exposed to the internet or user networks
- Interaction with services bound to
localhoston the Nginx UI host (e.g., admin panels, debug endpoints, metadata services) - Bypassing network segmentation and firewall rules by tunneling traffic through the Nginx UI server
- Potential exposure of sensitive configuration data, credentials, tokens, or system metadata
- Pivoting into further attacks, such as exploiting vulnerabilities on internal services reachable via SSRF
General mitigation guidance
Mitigation typically focuses on constraining where server-initiated requests can go and reducing trust in user-controlled routing parameters.
Useful defensive patterns include:
- Enforcing strict allowlists for cluster node target addresses or domains, and rejecting non-approved hosts, IPs, or schemes
- Blocking or tightly controlling access to link-local, loopback, and private network ranges from any proxy-like functionality
- Treating headers such as
X-Node-IDas untrusted input and applying access control and validation before using them to route requests - Separating administrative cluster-node management from regular user operations, and limiting who can define or modify node endpoints
- Running Nginx UI in a network segment with minimal visibility into sensitive internal services and applying least-privilege network policies (e.g., egress restrictions)
How teams detect issues like this
Organizations can look for SSRF risks and exploit attempts using a combination of code-centric and operational techniques:
- Static analysis and code review:
- Identify code paths where user-controlled values (such as headers or configuration fields) influence outbound HTTP client targets.
- Flag uses of arbitrary URLs in HTTP client calls without hostname or IP allowlists and without checks against private or loopback ranges.
- Look for proxy-like middleware that forwards requests based on request headers or user-configurable identifiers.
- Configuration and policy enforcement:
- Apply security policies that restrict egress traffic from application servers to known, approved destinations.
- Use infrastructure-level controls (firewalls, service meshes, or network policies) to block access from the Nginx UI host to sensitive internal services by default.
- Runtime monitoring and logging:
- Capture and analyze logs of outbound requests from Nginx UI, especially those targeting non-standard ports, internal IP ranges, or localhost.
- Set up alerts for unusual patterns, such as repeated requests to metadata services or new internal hosts not usually contacted.
- Automated tooling:
- Integrate SAST or security linters that specifically recognize SSRF patterns, such as user-influenced URL construction and proxy forwarding logic.

