CVE-2026-33032 / MCPwn

Strumentazione di rilevamento non distruttiva per il bypass di autenticazione MCP di nginx-ui noto pubblicamente come MCPwn. Consente l'acquisizione non autenticata di qualsiasi istanza nginx-ui che esegua una versione vulnerabile, tramite due sole richieste HTTP.

Indice

1. Fatti rapidi
2. Panoramica della vulnerabilità
3. Analisi tecnica approfondita
4. Strategia di rilevamento
5. Installazione
6. Utilizzo
7. Esempio di output
8. Catena con CVE-2026-27944
9. Rimedi
10. Uso responsabile
11. Riferimenti
12. Licenza

Fatti rapidi

Panoramica della vulnerabilità

nginx-ui espone un'interfaccia Model Context Protocol (MCP) che consente a un operatore autenticato di pilotare strumenti distruttivi come la modifica della configurazione di nginx, comandi di riavvio e operazioni di backup tramite JSON-RPC.

L'endpoint /mcp è protetto dal middleware AuthRequired(), mentre il suo endpoint gemello /mcp_message, che riceve effettivamente le invocazioni degli strumenti, è stato distribuito senza il middleware. Qualsiasi client in grado di raggiungere l'interfaccia tramite rete può:

1. Aprire uno stream Server Sent Events (SSE) su /mcp e ricevere un nuovo sessionID senza presentare alcuna credenziale.
2. Utilizzare quel sessionID per invocare qualsiasi strumento MCP registrato inviando una POST a /mcp_message, sempre senza autenticazione.

L'attaccante ottiene il controllo completo del processo nginx: può modificare i server block per reindirizzare il traffico, estrarre le chiavi private TLS tramite letture di percorsi, ricaricare o arrestare nginx e impiantare backdoor persistenti.

Analisi tecnica approfondita

Causa principale a livello di codice

// vulnerabile (pre-2.3.4)
r.GET("/mcp",          AuthRequired(), mcpHandler)
r.POST("/mcp_message", mcpMessageHandler)    // middleware mancante

// corretto in 2.3.4
r.GET("/mcp",          AuthRequired(), mcpHandler)
r.POST("/mcp_message", AuthRequired(), mcpMessageHandler)

Una singola chiamata di funzione mancante nella registrazione delle route è stata sufficiente a trasformare l'interfaccia MCP in un gateway RCE non autenticato.

Schema dell'attacco end-to-end

  Attaccante                              nginx-ui (<2.3.4)
     |   1) GET /mcp  (senza auth)             |
     | -------------------------------------->  |
     |   2) event: endpoint data: /mcp_message?sessionID=XYZ
     | <--------------------------------------  |
     |   3) POST /mcp_message?sessionID=XYZ     |
     |      body: JSON-RPC call_tool "nginx_reload" o
     |             "edit_config {...}"          |
     | -------------------------------------->  |
     |   4) 200 OK; strumento eseguito con pieni privilegi
     | <--------------------------------------  |

Matrice di impatto

Strategia di rilevamento

Questo repository evita intenzionalmente qualsiasi azione distruttiva. Il rilevatore utilizza solo metodi MCP di sola lettura (tools/list). La logica:

> Passo 1  Identificare nginx-ui tramite
>         GET /               (titolo HTML, bundle JS)
>         GET /api/settings   (JSON che fa riferimento a chiavi nginx-ui)
>         Estrarre la versione tramite header / regex sul body
> Passo 2  Aprire lo stream SSE su /mcp
>         Estrarre il primo sessionID dall'evento "endpoint"
> Passo 3  POST /mcp_message?sessionID=<id>
>         Body: {"jsonrpc":"2.0","method":"tools/list","params":{}}
>         Nessun header Authorization
> Passo 4  Vulnerabile se status 200 e il body contiene un manifest degli strumenti
>         Corretto se status 401 / 403 / 404
>         Inconcludente altrimenti

Perché è sicuro

Il metodo JSON-RPC tools/list è di sola lettura. Enumera quali strumenti conosce il server MCP ma non ne invoca nessuno. Lo script rifiuta di inviare POST con qualsiasi altro metodo e non costruisce mai payload per strumenti distruttivi.

Installazione

git clone https://github.com/your-org/CVE-2026-33032-detector.git
cd CVE-2026-33032-detector
python3 --version      # 3.9 o successiva
# Non sono richiesti pacchetti di terze parti.

Per il componente Nmap NSE, copia nginx-ui-mcpwn.nse nella tua directory locale degli script e aggiorna il database degli script:

cp nginx-ui-mcpwn.nse /usr/share/nmap/scripts/
sudo nmap --script-updatedb

Utilizzo

Rilevatore Python

# Singolo target
python3 detect_nginx_ui_mcpwn.py --target https://nginx-ui.internal

# Scansione di massa da file
python3 detect_nginx_ui_mcpwn.py --targets targets.txt --workers 20

# Output JSON (NDJSON) adatto per il piping a jq
python3 detect_nginx_ui_mcpwn.py --target 10.0.0.5:9000 --json | jq .

Riferimento della riga di comando:

Nmap NSE

nmap -p 80,443,9000 --script nginx-ui-mcpwn 10.0.0.0/24
nmap -p 443 --script nginx-ui-mcpwn --script-args "nginx-ui-mcpwn.timeout=8" host.example.com

Esempio di output

Leggibile dall'uomo

 _   _       _                  _    _  ___   __  __  ____ ____
| \ | | __ _(_)_ __ __  __     | |  | ||_ _| |  \/  |/ ___|  _ \__      ___ __
|  \| |/ _` | | '_ \\ \/ /_____| |  | | | |  | |\/| | |   | |_) \ \ /\ / / '_ \
| |\  | (_| | | | | |>  <|_____| |__| | | |  | |  | | |___|  __/ \ V  V /| | | |
|_| \_|\__, |_|_| |_/_/\_\     |_____|_||___| |_|  |_|\____|_|     \_/\_/ |_| |_|
       |___/

  CVE-2026-33032 Rilevatore MCPwn nginx-ui > non distruttivo

[!] VULNERABILE https://nginx-ui.internal versione=2.3.2 evidenza=status=200; body_preview={"jsonrpc":"2.0","id":"...","result":{"tools":[{"name":"edit_config",...
[+] corretto https://nginx-ui-patched:9000 versione=2.3.4 evidenza=status=401; body_preview={"error":"unauthorized"}
[.] non nginx-ui https://example.com evidenza=fingerprint negativo

Riepilogo: 1/3 target segnalati come vulnerabili

NDJSON

{"target":"https://nginx-ui.internal","reachable":true,"is_nginx_ui":true,"mcp_endpoint_present":true,"session_id_obtained":true,"mcp_message_unauthenticated":true,"vulnerable":true,"nginx_ui_version":"2.3.2","evidence":"status=200; body_preview=...","error":null}

Nmap

PORT     STATE SERVICE
9000/tcp open  http
| nginx-ui-mcpwn:
|   status: VULNERABILE
|   version: 2.3.2
|   session_id: abc123
|_  evidence: tools/list accettato senza credenziali

Catena con CVE-2026-27944

CVE-2026-27944 (il download non autenticato di /api/backup che perde la chiave AES nell'header X-Backup-Security) si combina perfettamente con MCPwn: l'archivio di backup espone il node_secret, che può essere utilizzato per autenticarsi su /mcp anche dopo l'applicazione della correzione per 33032, finché gli operatori non ruotano il segreto.

Il rilevatore complementare per 27944 si trova in una directory sorella di questo progetto di ricerca.

Rimedi

1. Aggiorna nginx-ui alla versione 2.3.4 o successiva.
2. Ruota node_secret, gli hash delle password amministratore e qualsiasi chiave privata TLS accessibile al processo nginx-ui.
3. Limita l'esposizione di nginx-ui a una VLAN di gestione, VPN o reverse proxy che imponga l'autenticazione prima che la route /mcp_message sia raggiungibile.
4. Esamina la cronologia della configurazione di nginx (Git o backup) per individuare direttive upstream / proxy_pass / ssl_certificate inattese introdotte nella finestra di esposizione.

Uso responsabile

Questi strumenti sono pubblicati per aiutare i difensori a identificare istanze non aggiornate all'interno di ambienti che sono autorizzati a testare. Non utilizzarli contro sistemi di cui non sei proprietario o per i quali non hai esplicita autorizzazione alla valutazione. Gli autori declinano ogni responsabilità per un uso improprio.

Riferimenti

• NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-33032
• Picus Security (analisi MCPwn): https://www.picussecurity.com/resource/blog/cve-2026-33032-mcpwn-how-a-missing-middleware-call-in-nginx-ui-hands-attackers-full-web-server-takeover
• Security Affairs: https://securityaffairs.com/190841/hacking/cve-2026-33032-severe-nginx-ui-bug-grants-unauthenticated-server-access.html
• BleepingComputer: https://www.bleepingcomputer.com/news/security/critical-nginx-ui-auth-bypass-flaw-now-actively-exploited-in-the-wild/
• Progetto upstream: https://github.com/0xjacky/nginx-ui

Licenza

Rilasciato sotto la Licenza MIT. Consulta le intestazioni dei singoli script per le note specifiche per file.