/

CVE-2026-44015

Severity:

HIGH RISK

(8.5)

SSRF in Nginx UI Cluster Node Proxying

CVE-2026-44015

Modified

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources and services via SSRF

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

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-ID header
  • 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-ID header.
  • 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-ID selector 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-ID header

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 localhost on 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-ID as 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.

Sources

SourceLink
github.comgithub.com/0xJacky/nginx-ui/security/advisories/GHSA-wr32-99hh-6f35

Frequently asked

questions

It can be, but it depends on how Nginx UI is exposed. If the Nginx UI interface is reachable over the network (e.g., from the internet or a wider internal network) and users can authenticate, those users may be able to exploit the SSRF to reach internal services that the Nginx UI host can access.

Not necessarily. The vulnerability involves an authenticated user who can create or reference cluster nodes and send requests with the X-Node-ID header. If non-admin users have those capabilities, they may exploit the issue; access control design determines who is at risk.

The safest pattern is to treat cluster node endpoints and routing headers as untrusted and enforce strict network and host-level restrictions. This typically means applying allowlists for valid node destinations, blocking access to private and loopback ranges, and ensuring only trusted roles can define where the application is allowed to send requests.

Design proxy and routing features so that user input can only select among pre-approved, server-controlled destinations, never arbitrary URLs or addresses. Combine this with defense-in-depth: egress restrictions at the network layer, validation against private and loopback IP ranges, careful header handling, and security reviews that specifically look for server-initiated requests influenced by user data.

Find out what's already
exploitable in your codebase.