
Absence d'autorisation sur le point de terminaison /load_lora_adapter_from_tensors de sglang (CVE-2026-127222)
/load_lora_adapter_from_tensors de sglangAffecté : sglang 0.5.8 à 0.5.21 (inclus)
Corrigé dans : 0.5.22
CWE : CWE-862 (Autorisation manquante)
Composant : sglang.srt.entrypoints.http_server → POST /load_lora_adapter_from_tensors
Signalé par : Rahul Karne
CNA : VulnCheck
Le serveur HTTP de sglang protège ses points de terminaison administratifs avec un
décorateur d'autorisation par route, @auth_level(AuthLevel.ADMIN_OPTIONAL), appliqué par un
middleware ASGI.
Le point de terminaison POST /load_lora_adapter_from_tensors ne possède pas ce décorateur,
alors que ses deux points de terminaison LoRA frères (/load_lora_adapter et
/unload_lora_adapter) le possèdent.
Étant donné qu'une route non décorée est résolue vers le AuthLevel.NORMAL par défaut, le
point de terminaison ne reçoit pas le même traitement d'autorisation que les autres points de
terminaison administratifs LoRA. Dans les configurations clés affectées, cela permet d'invoquer une
action administrative sans les identifiants attendus.
Il s'agissait d'un défaut présent dès le premier jour : le point de terminaison et le système
@auth_level ont tous deux été introduits dans 0.5.8, et ce point de terminaison était la seule route administrative
livrée sans le décorateur.
/load_lora_adapter_from_tensors est un point de terminaison administratif qui charge un adaptateur LoRA
dans le modèle en cours d'exécution à partir de données fournies par l'appelant. L'invoquer sans
autorisation permet à un appelant non autorisé de :
Le défaut d'autorisation est indépendant de toute faiblesse dans le code de traitement de la charge utile en aval, et l'aggrave : un point de terminaison censé exiger un identifiant administrateur ne devrait jamais être accessible sans celui-ci.
L'effet pratique du décorateur manquant dépend de la façon dont les clés d'API du serveur sont configurées. Ce rapport est délibérément précis à ce sujet, car le problème n'est pas « toujours non authentifié pour tout le monde ».
| Configuration du serveur | /load_lora_adapter (frère) | /load_lora_adapter_from_tensors (ce bug) | Effet |
|---|---|---|---|
--admin-api-key uniquement | exige la clé admin | accessible SANS AUCUN identifiant | Accès non authentifié à une action admin |
à la fois --api-key et --admin-api-key | exige la clé admin | accessible avec la --api-key à faibles privilèges | Rétrogradation de privilèges (une clé normale déverrouille une action réservée aux admins) |
--api-key uniquement | exige la clé api | exige la clé api | Aucun contournement dans cette configuration |
| aucune clé configurée | ouvert | ouvert | Le middleware d'authentification n'est pas installé du tout ; sans rapport avec ce bug |
Le cas principal est la première ligne : avec --admin-api-key défini, le point de terminaison est
accessible sans aucun identifiant.
Atteindre le code LoRA nécessite en outre que le serveur soit démarré avec
--enable-lora. Notez également que sglang se lie à 127.0.0.1 par défaut ; l'exposition
réseau dépend du déploiement (--host 0.0.0.0, mappage de ports de conteneur, etc.).
sglang autorise les routes administratives avec un décorateur défini dans
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) résout
chaque requête vers sa route, lit le _auth_level de cette route, et appelle
decide_request_auth(). Une route sans décorateur @auth_level est résolue vers
la valeur par défaut :
# _get_auth_level_from_app_and_scope(...)
level = getattr(endpoint, "_auth_level", None)
return level if isinstance(level, AuthLevel) else AuthLevel.NORMAL
Et pour AuthLevel.NORMAL, lorsqu'aucune api_key simple n'est configurée,
decide_request_auth() renvoie autorisé :
# 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
Dans les versions vulnérables, http_server.py décore les fonctions sœurs mais pas la cible :
@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(...):
...
Ainsi, lorsque le serveur est lancé avec --admin-api-key (et sans simple --api-key),
les deux routes sœurs exigent le jeton bearer d'administration, tandis que
/load_lora_adapter_from_tensors est résolue en NORMAL et est autorisée à passer
sans aucun identifiant.
Une seule route administrative a été ajoutée sans le décorateur @auth_level que
porte toutes les autres routes administratives. Le modèle d'autorisation est
à opt-in par décorateur : une route qui oublie le décorateur retombe silencieusement
au niveau NORMAL le moins restrictif au lieu d'échouer en mode fermé.
poc_sglang_missing_auth.py démontre le problème
en utilisant le code propre de sglang, de deux manières indépendantes, avec aucun GPU, aucun modèle et aucune charge utile RCE :
PARTIE 1 — statique, contre le véritable http_server.py : elle analyse par AST le
véritable srt/entrypoints/http_server.py de sglang à un tag de version épinglé et affiche les
trois points de terminaison LoRA avec leurs décorateurs, montrant que
/load_lora_adapter_from_tensors est la seule route LoRA administrative dépourvue de
@auth_level.
PARTIE 2 — dynamique, contre le véritable auth.py : elle charge le véritable
srt/utils/auth.py de sglang (le vrai décorateur @auth_level, le vrai résolveur au niveau des routes, le vrai decide_request_auth, et le vrai middleware ASGI add_api_key_middleware), monte deux points de terminaison dont la décoration est pilotée par ce que la PARTIE 1 a trouvé dans le code source réel, démarre le serveur avec --admin-api-key ..., et envoie des requêtes sans identifiant. La route sœur protégée renvoie 401 ; le point de terminaison vulnérable renvoie 200 (son gestionnaire est atteint).
Le gestionnaire simulé renvoyant 200 est intentionnel et suffisant : la
vulnérabilité réside entièrement dans la couche d'autorisation qui s'exécute avant
le gestionnaire de chargement de modèle, donc une requête sans identifiant atteignant le gestionnaire est en soi la preuve que l'autorisation a été contournée.