
Falta de autorização no endpoint /load_lora_adapter_from_tensors do sglang (CVE-2026-127222)
/load_lora_adapter_from_tensors do sglangAfetado: sglang 0.5.8 até 0.5.21 (inclusive)
Corrigido em: 0.5.22
CWE: CWE-862 (Autorização Ausente)
Componente: sglang.srt.entrypoints.http_server → POST /load_lora_adapter_from_tensors
Reportado por: Rahul Karne
CNA: VulnCheck
O servidor HTTP do sglang protege seus endpoints administrativos com um decorador
de autorização por rota, @auth_level(AuthLevel.ADMIN_OPTIONAL), aplicado por um
middleware ASGI.
O endpoint POST /load_lora_adapter_from_tensors não possui esse decorador,
enquanto ambos os seus endpoints LoRA irmãos (/load_lora_adapter e
/unload_lora_adapter) o possuem.
Como uma rota sem decorador é resolvida para o AuthLevel.NORMAL padrão, o
endpoint não recebe o mesmo tratamento de autorização que os outros endpoints
administrativos de LoRA. Em configurações de chave afetadas, isso permite que uma
ação administrativa seja invocada sem a credencial esperada.
Este foi um defeito presente desde o primeiro dia: o endpoint e o sistema
@auth_level foram ambos introduzidos na 0.5.8, e este endpoint foi a única rota
administrativa que foi lançada sem o decorador.
/load_lora_adapter_from_tensors é um endpoint administrativo que carrega um
adaptador LoRA no modelo em execução a partir de dados fornecidos pelo chamador.
Invocá-lo sem autorização permite que um chamador não autorizado:
O defeito de autorização é independente de, e agrava, qualquer fraqueza no código de tratamento de payload a jusante: um endpoint que deveria exigir uma credencial de administrador nunca deveria ser acessível sem uma.
O efeito prático do decorador ausente depende de como as chaves de API do servidor estão configuradas. Este relatório é deliberadamente preciso quanto a isso, porque o problema não é "sempre não autenticado para todos."
| Configuração do servidor | /load_lora_adapter (irmão) | /load_lora_adapter_from_tensors (este bug) | Efeito |
|---|---|---|---|
apenas --admin-api-key | exige chave de admin | acessível SEM NENHUMA credencial | Acesso não autenticado a uma ação administrativa |
ambos --api-key e --admin-api-key | exige chave de admin | acessível com a --api-key de baixo privilégio | Rebaixamento de privilégio (chave normal desbloqueia uma ação exclusiva de admin) |
apenas --api-key | exige chave de api | exige chave de api | Sem bypass nesta configuração |
| nenhuma chave configurada | aberto | aberto | O middleware de autenticação não está instalado; não relacionado a este bug |
O caso principal é a primeira linha: com --admin-api-key definida, o endpoint é
acessível sem nenhuma credencial.
Alcançar o código LoRA também exige que o servidor seja iniciado com
--enable-lora. Observe também que o sglang se vincula a 127.0.0.1 por padrão; a
exposição de rede depende da implantação (--host 0.0.0.0, mapeamento de portas do
contêiner, etc.).
O sglang autoriza rotas administrativas com um decorador definido em
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
Um middleware ASGI (add_api_key_middleware → _ApiKeyASGIMiddleware) resolve
cada requisição para sua rota, lê o _auth_level dessa rota e chama
decide_request_auth(). Uma rota sem o decorador @auth_level é resolvida para o
padrão:
# _get_auth_level_from_app_and_scope(...)
level = getattr(endpoint, "_auth_level", None)
return level if isinstance(level, AuthLevel) else AuthLevel.NORMAL
E para AuthLevel.NORMAL, quando nenhum api_key simples está configurado,
decide_request_auth() retorna permitido:
# 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
Nas versões vulneráveis, http_server.py decora os irmãos, mas não o alvo:
@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 o servidor é iniciado com --admin-api-key (e sem um --api-key simples),
os dois irmãos exigem o token de portador de administrador, enquanto
/load_lora_adapter_from_tensors resolve para NORMAL e é permitido passar sem
nenhuma credencial.
Uma única rota administrativa foi adicionada sem o decorador @auth_level que
todas as outras rotas administrativas possuem. O modelo de autorização é
opt-in por decorador: uma rota que esquece o decorador recai silenciosamente para o
nível menos restritivo NORMAL em vez de falhar de forma segura.
poc_sglang_missing_auth.py demonstra o problema
usando o próprio código do sglang, de duas formas independentes, com sem GPU, sem modelo e sem
payload de RCE:
PARTE 1 — estática, contra o http_server.py real: ele faz parsing AST do
srt/entrypoints/http_server.py real do sglang em uma tag de release fixada e imprime os
três endpoints LoRA com seus decoradores, mostrando que
/load_lora_adapter_from_tensors é a única rota administrativa LoRA sem
@auth_level.
PARTE 2 — dinâmica, contra o auth.py real: ele carrega o srt/utils/auth.py genuíno do sglang
(o decorador @auth_level real, o resolvedor real em nível de rota,
o decide_request_auth real e o middleware ASGI add_api_key_middleware real),
monta dois endpoints cuja decoração é determinada pelo que a PARTE 1
encontrou no código-fonte real, inicia o servidor como --admin-api-key ... e envia
requisições sem credenciais. O irmão protegido retorna 401; o
endpoint vulnerável retorna 200 (seu handler é alcançado).
O handler stub que retorna 200 é intencional e suficiente: a
vulnerabilidade reside inteiramente na camada de autorização que é executada antes do
handler de carregamento de modelo, portanto uma requisição sem credenciais que chega ao handler já é,
por si só, a prova de que a autorização foi contornada.
A demonstração utiliza o módulo de autorização real do sglang em vez de uma imitação escrita à mão. A única coisa não executada é o corpo pesado do handler de carregamento de modelo (que requer torch/CUDA), que é exatamente o código que a autorização deveria proteger.
O PoC precisa apenas de alguns pacotes Python puros:
pip install fastapi starlette httpx
Ele busca os dois arquivos-fonte do sglang que analisa diretamente da tag de release fixada no GitHub (sem instalação do sglang, sem GPU). Para executar totalmente offline, aponte-o para uma árvore de código-fonte do sglang extraída localmente com --source/--sglang-src.
Contra a tag vulnerável padrão (v0.5.13.post1):