
Autorizzazione mancante sull'endpoint sglang /load_lora_adapter_from_tensors (CVE-2026-127222)
/load_lora_adapter_from_tensors di sglangInteressato: sglang 0.5.8 fino a 0.5.21 (incluso)
Corretto in: 0.5.22
CWE: CWE-862 (Autorizzazione mancante)
Componente: sglang.srt.entrypoints.http_server → POST /load_lora_adapter_from_tensors
Segnalato da: Rahul Karne
CNA: VulnCheck
Il server HTTP di sglang protegge i propri endpoint amministrativi con un decoratore
di autorizzazione per rotta, @auth_level(AuthLevel.ADMIN_OPTIONAL), applicato da un
middleware ASGI.
L'endpoint POST /load_lora_adapter_from_tensors manca di quel decoratore,
mentre entrambi i suoi endpoint LoRA fratelli (/load_lora_adapter e
/unload_lora_adapter) lo possiedono.
Poiché una rotta non decorata viene risolta al valore predefinito AuthLevel.NORMAL,
l'endpoint non riceve lo stesso trattamento di autorizzazione degli altri endpoint
amministrativi LoRA. In determinate configurazioni di chiavi interessate, ciò consente
di invocare un'azione amministrativa senza la credenziale prevista.
Si è trattato di un difetto presente fin dal primo giorno: l'endpoint e il sistema
@auth_level sono stati entrambi introdotti in 0.5.8, e questo endpoint è stata
l'unica rotta amministrativa rilasciata senza il decoratore.
/load_lora_adapter_from_tensors è un endpoint amministrativo che carica un adattatore
LoRA nel modello in esecuzione a partire da dati forniti dal chiamante. Invocarlo senza
autorizzazione consente a un chiamante non autorizzato di:
Il difetto di autorizzazione è indipendente da, e amplifica, qualsiasi debolezza nel codice downstream di gestione del payload: un endpoint che dovrebbe richiedere una credenziale amministrativa non dovrebbe mai essere raggiungibile senza di essa.
L'effetto pratico del decoratore mancante dipende da come sono configurate le chiavi API del server. Questo report è deliberatamente preciso al riguardo, perché il problema non è "sempre non autenticato per tutti".
| Configurazione del server | /load_lora_adapter (fratello) | /load_lora_adapter_from_tensors (questo bug) | Effetto |
|---|---|---|---|
solo --admin-api-key | richiede la chiave admin | raggiungibile SENZA alcuna credenziale | Accesso non autenticato a un'azione amministrativa |
sia --api-key che --admin-api-key | richiede la chiave admin | raggiungibile con la --api-key a bassi privilegi | Riduzione dei privilegi (una chiave normale sblocca un'azione riservata agli admin) |
solo --api-key | richiede la chiave api | richiede la chiave api | Nessun bypass in questa configurazione |
| nessuna chiave configurata | aperto | aperto | Il middleware di autenticazione non è installato affatto; non correlato a questo bug |
Il caso principale è la prima riga: con --admin-api-key impostata, l'endpoint è
raggiungibile senza alcuna credenziale.
Raggiungere il codice LoRA richiede inoltre che il server sia avviato con
--enable-lora. Si noti anche che sglang si associa a 127.0.0.1 per impostazione
predefinita; l'esposizione in rete dipende dal deployment (--host 0.0.0.0, mappatura
delle porte del container, ecc.).
sglang autorizza le rotte amministrative con un decoratore definito in
sglang/srt/utils/auth.py:
def auth_level(level: AuthLevel):
"""Mark endpoint with auth level (stored in endpoint metadata)."""
def decorator(func):
func._auth_level = level
return func
return decorator
Un middleware ASGI (add_api_key_middleware → _ApiKeyASGIMiddleware) risolve
ogni richiesta alla sua route, legge l'_auth_level di quella route e chiama
decide_request_auth(). Una route senza decoratore @auth_level viene risolta al
valore predefinito:
# _get_auth_level_from_app_and_scope(...)
level = getattr(endpoint, "_auth_level", None)
return level if isinstance(level, AuthLevel) else AuthLevel.NORMAL
E per AuthLevel.NORMAL, quando non è configurata una semplice api_key, decide_request_auth() restituisce consentito:
# decide_request_auth(..., auth_level=AuthLevel.NORMAL)
if api_key:
return AuthDecision(allowed=_check_bearer_token(authorization_header, api_key))
return AuthDecision(allowed=True) # <-- no api_key configured => allowed
Nelle versioni vulnerabili, http_server.py decora i sibling ma non il
target:
@app.api_route("/load_lora_adapter", methods=["POST"])
@auth_level(AuthLevel.ADMIN_OPTIONAL) # protected
async def load_lora_adapter(...):
...
@app.api_route("/load_lora_adapter_from_tensors", methods=["POST"])
# <-- NO @auth_level decorator : the bug
async def load_lora_adapter_from_tensors(...):
...
@app.api_route("/unload_lora_adapter", methods=["POST"])
@auth_level(AuthLevel.ADMIN_OPTIONAL) # protected
async def unload_lora_adapter(...):
...
Quando quindi il server viene avviato con --admin-api-key (e senza un semplice --api-key),
i due sibling richiedono il token bearer admin, mentre
/load_lora_adapter_from_tensors viene risolto come NORMAL e consentito
senza credenziali.
Una singola route amministrativa è stata aggiunta senza il decoratore @auth_level che
ogni altra route amministrativa possiede. Il modello di autorizzazione è
decorator-opt-in: una route che dimentica il decoratore ricade silenziosamente sul
livello meno restrittivo NORMAL invece di fallire in modo sicuro.
poc_sglang_missing_auth.py dimostra il problema
usando il codice proprio di sglang, in due modi indipendenti, con nessuna GPU, nessun modello e nessun
payload RCE:
PARTE 1 — statica, contro il vero http_server.py: esegue il parsing AST del
reale srt/entrypoints/http_server.py di sglang a un tag di release fissato e stampa i
tre endpoint LoRA con i loro decoratori, mostrando che
/load_lora_adapter_from_tensors è l'unica route LoRA amministrativa priva di
@auth_level.
PARTE 2 — dinamica, contro il vero auth.py: carica il genuino
srt/utils/auth.py di sglang (il vero decoratore @auth_level, il vero resolver
a livello di route, la vera decide_request_auth e il vero middleware ASGI
add_api_key_middleware), monta due endpoint la cui decorazione è guidata da ciò che la PARTE 1
ha trovato nel codice sorgente reale, avvia il server come --admin-api-key ... e invia
richieste senza credenziali. Il sibling protetto restituisce 401; l'endpoint
vulnerabile restituisce 200 (il suo handler viene raggiunto).
L'handler stub che restituisce 200 è intenzionale e sufficiente: la
vulnerabilità risiede interamente nel livello di autorizzazione che viene eseguito prima
dell'handler di caricamento del modello, quindi una richiesta senza credenziali che raggiunge l'handler è
di per sé la prova che l'autorizzazione è stata aggirata.
La dimostrazione utilizza il modulo di autorizzazione reale di sglang anziché un'imitazione scritta a mano. L'unica cosa non eseguita è il corpo dell'handler di caricamento del modello, che è pesante (richiede torch/CUDA), ed è esattamente il codice che l'autorizzazione dovrebbe proteggere.
Il PoC necessita solo di pochi pacchetti Python puri:
pip install fastapi starlette httpx