
Proof-of-concept containerizzato e ambiente di laboratorio per CVE-2026-121529, un errore di validazione dell'origine dell'API locale di FortiClient (CWE-346) che consente l'esecuzione remota di codice drive-by tramite il browser della vittima.
| CVE | CVE-2026-121529 |
| Componente | FortiClient / FortiClient Windows PAM / FortiClient Mac — endpoint dell'API locale (127.0.0.1:9191) |
| Affected | Windows e Windows PAM 7.4.0–7.4.7, 7.2.0–7.2.14; Mac 7.4.0–7.4.7 |
| Corretto in | 7.4.8 (ramo 7.4), 7.2.15 (ramo 7.2) |
| CWE | CWE-346 (Origin Validation Error) |
| Impatto | Esecuzione di codice remoto non autenticata con l'account del servizio FortiClient (SYSTEM su Windows) |
| Vettore | Una pagina web visitata dalla vittima; il browser della vittima stessa pilota l'API locale privilegiata |
| Trigger | L'header Origin di una richiesta cross-origin — o la sua assenza |
L'advisory di Fortinet (FG-IR-26-194, pubblicato il 2026-11-10) descrive la vulnerabilità come un errore di validazione dell'origine nell'API locale di FortiClient, FortiClient Windows PAM e FortiClient Mac che "può consentire a un attaccante remoto non autorizzato di eseguire codice o comandi non autorizzati" e richiede l'interazione con la vittima.
Fortinet2Shell è il nome che Baldur Security ha dato a questa classe di difetto — un endpoint FortiClient trasformato in una shell remota dal browser della vittima stessa. Questo repository è il laboratorio e la proof of concept per esso.
L'API locale è l'interfaccia di loopback utilizzata dai componenti di accesso privilegiato FortiPAM
sullo stesso endpoint. È in ascolto su 127.0.0.1:9191 e offre un'operazione di sessione privilegiata
che esegue un comando con i privilegi del servizio. Poiché il servizio
non valida mai l'origine del chiamante, una pagina su qualsiasi sito web può far sì che il
browser della vittima stessa piloti quell'API: il browser invia la richiesta, l'API la esegue,
e il browser restituisce la risposta allo script dell'attaccante. La vittima deve solo
visitare una pagina.
Questo repository contiene un laboratorio containerizzato che riproduce la vulnerabilità con un browser
reale, il differenziale rispetto a tre forme di rimedio, e i risultati di una
scansione 0-day contro il modello corretto. La scansione produce tre risultati rilevanti
per qualsiasi prodotto di questa forma: un rimedio basato solo sull'header CORS non arresta affatto l'attacco,
poiché un browser non applica alcuna politica CORS a un handshake WebSocket; un
rimedio con validazione dell'origine che accetta una richiesta senza header Origin viene
aggirato da un `` cross-origin; e un'esecuzione cieca può essere confermata tramite
un canale laterale basato su immagine.
FortiClient è software proprietario. Nessuno dei suoi codici, binari o configurazioni viene ridistribuito qui, e il fornitore non pubblica l'elenco degli endpoint dell'API locale né il suo codice di validazione dell'origine. Ciò che è riproducibile qui è quindi:
127.0.0.1:9191, un'operazione di sessione privilegiata che esegue un comando con i
privilegi del servizio, una variante WebSocket di tale operazione, e un
livello di validazione dell'origine;Tutto ciò che il laboratorio afferma sul prodotto del fornitore è tratto dall' advisory; tutto ciò che afferma sul modello è etichettato come tale. Il modello è la sola cosa che viene eseguita nel laboratorio, ed è deliberatamente costruito in modo che il comportamento vulnerabile e quello corretto differiscano solo nel livello di validazione dell'origine.
Il modello risiede in lab/forticlient_api.py e viene selezionato con FCT_MODE:
FCT_MODE | comportamento | versione riportata |
|---|---|---|
vuln | nessuna validazione dell'origine — l'Origin della richiesta viene riflesso in Access-Control-Allow-Origin insieme a Access-Control-Allow-Credentials: true | 7.4.7 |
fixed-cors | correzione che si limita a restringere gli header CORS; la richiesta viene comunque elaborata e la superficie WebSocket non è affatto coperta da CORS | 7.4.8 |
fixed-origin-only | correzione che valida l'origine lato server ma accetta comunque una richiesta priva dell'header Origin | 7.4.8 |
fixed-strict | correzione che valida l'origine lato server e richiede un header con segreto condiviso che una richiesta cross-origin non può impostare senza un preflight | 7.4.8 |
È il browser — non il server — a decidere se una pagina può leggere la risposta di una
richiesta cross-origin. Il server esprime tale decisione negli header di risposta CORS:
Access-Control-Allow-Origin indica l'unica origine autorizzata a leggere la
risposta, e Access-Control-Allow-Credentials: true consente inoltre alla richiesta
di trasportare cookie e altre credenziali.
Un'API locale che riflette l'Origin della richiesta stessa in quell'header, e la abbina
a Access-Control-Allow-Credentials: true, offre a ogni pagina su internet un canale
cross-origin valido verso un servizio locale privilegiato. L'origine non viene mai validata,
e CWE-346 è esattamente questo: il server si fida del valore che dovrebbe verificare.
Il modello vulnerabile lo fa in _send():
origin = cors_origin if cors_origin is not None else self.headers.get("Origin")
if cors_allowed(origin) and origin:
# The vulnerable build echoes ANY origin and allows credentials.
self.send_header("Access-Control-Allow-Origin", origin) # <-- any origin
self.send_header("Access-Control-Allow-Credentials", "true")
e cors_allowed() nella modalità vuln restituisce True per ogni input:
def cors_allowed(origin):
if MODE == "vuln":
# 7.4.7 model: the service trusts whatever origin asks.
return True
Anche il preflight è altrettanto permissivo, e riflette anche gli header richiesti:
def do_OPTIONS(self):
...
extra = {
"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
"Access-Control-Allow-Headers": self.headers.get(
"Access-Control-Request-Headers", "Content-Type, Authorization"),
"Access-Control-Max-Age": "86400",
}
L'operazione privilegiata stessa non esegue alcuna autorizzazione — nella modalità vuln
action_allowed() restituisce True incondizionatamente — quindi la richiesta che arriva con un
origin falsificato o assente viene eseguita con i privilegi del servizio:
def action_allowed(headers):
if MODE in ("vuln", "fixed-cors"):
return True
Una correzione deve decidere sul server se il chiamante è un componente locale
affidabile. Il modello fixed-strict lo fa prima che l'azione venga eseguita:
def action_allowed(headers):
...
origin = headers.get("Origin")
token = headers.get(TOKEN_HEADER)
if token != TOKEN:
return False
if origin is None:
return True # the native local agent sends no Origin
return origin in ALLOWED_ORIGINS
L'ordine è importante: il controllo avviene prima dell'esecuzione del comando, quindi una richiesta non attendibile non raggiunge mai il sink.