
Falta de autorización en el endpoint /load_lora_adapter_from_tensors de sglang (CVE-2026-127222)
/load_lora_adapter_from_tensors de sglangAfecta a: sglang 0.5.8 hasta 0.5.21 (inclusive)
Corregido en: 0.5.22
CWE: CWE-862 (Falta de autorización)
Componente: sglang.srt.entrypoints.http_server → POST /load_lora_adapter_from_tensors
Reportado por: Rahul Karne
CNA: VulnCheck
El servidor HTTP de sglang protege sus endpoints administrativos con un decorador
de autorización por ruta, @auth_level(AuthLevel.ADMIN_OPTIONAL), aplicado por un
middleware ASGI.
El endpoint POST /load_lora_adapter_from_tensors carece de ese decorador,
mientras que sus dos endpoints LoRA hermanos (/load_lora_adapter y
/unload_lora_adapter) sí lo tienen.
Dado que una ruta sin decorador se resuelve al AuthLevel.NORMAL predeterminado,
el endpoint no recibe el mismo tratamiento de autorización que los demás endpoints
administrativos de LoRA. En las configuraciones de claves afectadas, esto permite
invocar una acción administrativa sin la credencial esperada.
Se trató de un defecto presente desde el primer día: tanto el endpoint como el
sistema @auth_level se introdujeron en 0.5.8, y este endpoint fue la única ruta
administrativa que se publicó sin el decorador.
/load_lora_adapter_from_tensors es un endpoint administrativo que carga un
adaptador LoRA en el modelo en ejecución a partir de datos proporcionados por el
llamador. Invocarlo sin autorización permite a un llamador no autorizado:
El defecto de autorización es independiente de cualquier debilidad en el código de manejo de la carga útil posterior, y la agrava: un endpoint que se supone que requiere una credencial de administrador nunca debería ser accesible sin una.
El efecto práctico del decorador ausente depende de cómo estén configuradas las claves de API del servidor. Este informe es deliberadamente preciso al respecto, porque el problema no consiste en que "siempre esté sin autenticación para todos".
| Configuración del servidor | /load_lora_adapter (hermano) | /load_lora_adapter_from_tensors (este fallo) | Efecto |
|---|---|---|---|
solo --admin-api-key | requiere clave de administrador | accesible SIN credencial | Acceso no autenticado a una acción administrativa |
tanto --api-key como --admin-api-key | requiere clave de administrador | accesible con la --api-key de bajo privilegio | Degradación de privilegios (una clave normal desbloquea una acción solo para administradores) |
solo --api-key | requiere clave de API | requiere clave de API | Sin omisión en esta configuración |
| sin claves configuradas | abierto | abierto | El middleware de autenticación no está instalado en absoluto; no está relacionado con este fallo |
El caso principal es la primera fila: con --admin-api-key establecida, el
endpoint es accesible sin ninguna credencial.
Alcanzar el código de LoRA requiere además que el servidor se inicie con
--enable-lora. Nótese también que sglang se enlaza a 127.0.0.1 de forma
predeterminada; la exposición en red depende del despliegue (--host 0.0.0.0,
mapeo de puertos del contenedor, etc.).
sglang autoriza las rutas administrativas con un decorador definido en
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) resuelve
cada solicitud a su ruta, lee el _auth_level de esa ruta y llama a
decide_request_auth(). Una ruta sin el decorador @auth_level se resuelve al
valor predeterminado:
# _get_auth_level_from_app_and_scope(...)
level = getattr(endpoint, "_auth_level", None)
return level if isinstance(level, AuthLevel) else AuthLevel.NORMAL
Y para AuthLevel.NORMAL, cuando no hay una api_key simple configurada,
decide_request_auth() devuelve 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
En las versiones vulnerables, http_server.py decora a los hermanos pero no al objetivo:
@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(...):
...
Cuando el servidor se inicia con --admin-api-key (y sin un --api-key simple),
los dos hermanos requieren el token bearer de administrador, mientras que
/load_lora_adapter_from_tensors se resuelve como NORMAL y se permite el paso
sin credencial.
Se añadió una única ruta administrativa sin el decorador @auth_level que
toda las demás rutas administrativas llevan. El modelo de autorización es
decorador opt-in: una ruta que olvida el decorador recurre silenciosamente al
nivel NORMAL menos restrictivo en lugar de fallar de forma segura.
poc_sglang_missing_auth.py demuestra el problema
usando el código propio de sglang, de dos formas independientes, sin GPU, sin modelo y sin
payload de RCE:
PARTE 1 — estática, contra el http_server.py real: analiza mediante AST el
srt/entrypoints/http_server.py real de sglang en una etiqueta de versión fijada e imprime los
tres endpoints de LoRA con sus decoradores, mostrando que
/load_lora_adapter_from_tensors es la única ruta administrativa de LoRA a la que le falta
@auth_level.
PARTE 2 — dinámica, contra el auth.py real: carga el
srt/utils/auth.py genuino de sglang (el @auth_level real, el
resolvedor real a nivel de ruta, el decide_request_auth real y el middleware ASGI
add_api_key_middleware real), monta dos endpoints cuya decoración está determinada por lo que la PARTE 1
encontró en el código fuente real, inicia el servidor como --admin-api-key ... y envía
solicitudes sin credenciales. El hermano protegido devuelve 401; el endpoint
vulnerable devuelve 200 (se alcanza su handler).
El handler simulado que devuelve 200 es intencional y suficiente: la
vulnerabilidad reside enteramente en la capa de autorización que se ejecuta antes del
handler de carga del modelo, por lo que una solicitud sin credenciales que llega al handler es,
en sí misma, la prueba de que la autorización fue eludida.
La demostración ejecuta el módulo de autorización real de sglang en lugar de una imitación escrita a mano. Lo único que no se ejecuta es el cuerpo del handler de carga del modelo, que es pesado (requiere torch/CUDA), que es exactamente el código que se supone que la autorización debe proteger.
El PoC solo necesita unos pocos paquetes de Python puro:
pip install fastapi starlette httpx