Skip to main content
Vulnerability Database/CVE-2026-107807

CVE-2026-107807: Nginx UI Authentication Bypass Vulnerability

CVE-2026-107807 is an authentication bypass flaw in Nginx UI that exposes master credentials in logs and URLs, allowing attackers to gain persistent administrative access. This post explains its impact, affected versions, and mitigation steps.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-107807 Overview

CVE-2026-107807 affects Nginx UI, a web user interface for the Nginx web server. Versions 2.0.0 through 2.4.x accept the Node.Secret master credential through a node_secret query parameter in HTTP and WebSocket authentication paths. The parameter should only be transmitted via the X-Node-Secret header. Query parameters routinely appear in access logs, proxy logs, browser history, Referer headers, and deployment telemetry. An attacker who recovers the secret from any of these sources bypasses password, JWT, session, and second-factor checks. The resulting access is persistent and administrative. The issue is fixed in version 2.5.0. This is a cleartext storage of sensitive information issue [CWE-312].

Critical Impact

Recovery of the exposed Node.Secret grants persistent administrative API access to Nginx UI, including full configuration and secret material.

Affected Products

  • Nginx UI version 2.0.0 through 2.4.x
  • Fixed in Nginx UI 2.5.0
  • HTTP and WebSocket authentication endpoints accepting node_secret query parameter

Discovery Timeline

  • 2026-10-09 - CVE-2026-107807 published to NVD
  • 2026-10-09 - Last updated in NVD database

Technical Details for CVE-2026-107807

Vulnerability Analysis

Nginx UI uses Node.Secret as a master credential for inter-node and administrative API access. In vulnerable releases, the authentication middleware accepts this credential from two transport locations: the X-Node-Secret HTTP header and the node_secret query parameter. Query-string credentials are logged in multiple downstream systems that typically treat URLs as non-sensitive.

An attacker with read access to web server access logs, upstream proxy logs, SIEM data, browser history, or outbound Referer headers can extract the plaintext secret. Possession of the secret bypasses the standard authentication stack. Password verification, JWT validation, session cookies, and multi-factor authentication are all skipped when the Node.Secret is presented.

Root Cause

The root cause is cleartext storage of sensitive information in transport locations that are routinely persisted [CWE-312]. The authentication handler treats the query parameter as equivalent to the header without accounting for the different exposure surface of URL components. Logs, proxies, and browser components retain URLs by default and do not strip query strings.

Attack Vector

Exploitation requires access to any artifact that captures request URLs issued against the Nginx UI instance. Candidate sources include Nginx access.log, load balancer logs, CDN telemetry, APM traces, bookmarked URLs, and outbound HTTP requests that forward the Referer header. Once the secret is recovered, the attacker issues authenticated API calls with the node_secret parameter or the X-Node-Secret header to perform administrative actions, read configuration, and extract additional secrets.

go
// Security patch in api/audit/middleware.go - signed node authentication
package audit

import (
	"encoding/json"

	"github.com/0xJacky/Nginx-UI/model"
	"github.com/gin-gonic/gin"
	"github.com/spf13/cast"
	"github.com/uozi-tech/cosy/logger"
)

const (
	sensitiveRequestAuditKey  = "SensitiveRequestAudit"
	sensitiveResponseAuditKey = "SensitiveResponseAudit"
)

// MarkSensitiveRequest prevents one-time or legacy credentials in a request
// from being copied into audit storage.
func MarkSensitiveRequest(c *gin.Context) {
	c.Set(sensitiveRequestAuditKey, true)
}

// MarkSensitiveResponse prevents one-time credentials in a response from
// being copied into audit storage.
func MarkSensitiveResponse(c *gin.Context) {
	c.Set(sensitiveResponseAuditKey, true)
}

Source: GitHub Commit a3999bd. The patch adds signed node authentication and introduces markers that prevent sensitive credentials from being copied into audit storage.

Detect Identity Attacks the Moment Authentication Fails

Singularity™ Identity surfaces credential misuse, lateral movement, and privilege escalation in real time, so you can contain the breach before it spreads.

Stop Identity Attacks

Detection Methods for CVE-2026-107807

Indicators of Compromise

  • Any HTTP or WebSocket request against Nginx UI containing node_secret= in the query string, present in access.log, proxy logs, or SIEM.
  • Administrative API calls on Nginx UI that lack a corresponding interactive login or JWT session for the acting principal.
  • Referer headers in outbound requests from the Nginx UI host that embed node_secret values.
  • Configuration or secret-reading endpoints invoked from source IPs that have never performed password or MFA authentication.

Detection Strategies

  • Grep historical web, proxy, CDN, and APM logs for the literal substring node_secret= and treat any match as a compromise candidate.
  • Correlate administrative API activity against authentication records; flag API usage without a preceding /login or JWT issuance event.
  • Monitor Nginx UI configuration-change events and compare against a known operator baseline.

Monitoring Recommendations

  • Forward Nginx UI access logs and audit logs to a centralized data lake and retain long enough to cover the exposure window.
  • Alert on URL parameters named node_secret, secret, token, or api_key appearing in any ingress or egress log source.
  • Review third-party log repositories, backup snapshots, and browser telemetry stores that may contain historical URLs.

How to Mitigate CVE-2026-107807

Immediate Actions Required

  • Upgrade Nginx UI to version 2.5.0 or later immediately.
  • Rotate the Node.Secret value after upgrading, since the prior value may already be present in logs.
  • Audit all locations that retain URLs, including web server logs, reverse proxies, CDN logs, SIEM, and backups, for node_secret occurrences.
  • Revoke any derived credentials or configuration secrets that were accessible via the Nginx UI administrative API during the exposure window.

Patch Information

The fix is included in Nginx UI 2.5.0. See the GitHub Release v2.5.0 and the GitHub Security Advisory GHSA-pvgv-gcp7-v38g. The patch introduces signed node authentication and marks credential-bearing requests and responses as sensitive so they are excluded from audit storage. See the GitHub Commit a3999bd for implementation detail.

Workarounds

  • Restrict network access to the Nginx UI management interface to trusted administrative networks only.
  • Configure upstream proxies and web servers to strip or redact the node_secret query parameter from log entries until the upgrade is applied.
  • Disable logging of request URIs on components that cannot be upgraded immediately, accepting the operational trade-off.
  • Remove historical log files that contain the parameter from long-term storage after confirming no forensic requirement.
bash
# Example: redact node_secret from Nginx access logs using a log_format map
map $request_uri $sanitized_uri {
    "~*(.*)node_secret=[^&]*(.*)"  "$1node_secret=REDACTED$2";
    default                        $request_uri;
}

log_format sanitized '$remote_addr - $remote_user [$time_local] '
                     '"$request_method $sanitized_uri $server_protocol" '
                     '$status $body_bytes_sent "$http_referer" "$http_user_agent"';

access_log /var/log/nginx/access.log sanitized;

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.