SSRF basique

Qu'est-ce que le SSRF basique ?#

Le SSRF basique (en bande) est la forme la plus simple et la plus immédiatement impactante de CWE-918. Une application accepte une URL depuis une entrée utilisateur, effectue une requête HTTP côté serveur vers cette URL, et retourne la réponse — ou une portion de celle-ci — directement dans la réponse HTTP. L'attaquant voit la réponse de la cible interne comme si le serveur était un proxy transparent.

La caractéristique distinctive est la visibilité : contrairement au SSRF aveugle, où la réponse est supprimée, le SSRF basique retourne le contenu récupéré. Cela le rend trivialement exploitable pour le vol de credentials cloud et la reconnaissance interne sans nécessiter d'infrastructure hors-bande. OWASP A10:2021 identifie ce pattern comme l'une des vulnérabilités web à l'impact le plus élevé précisément parce que l'endpoint de métadonnées cloud (169.254.169.254) est accessible par défaut depuis toute instance AWS, GCP ou Azure.

Mécanisme#

Le serveur accepte une entrée utilisateur contenant une URL, construit une requête HTTP, et reflète la réponse. L'attaque tire parti de la position réseau de confiance du serveur : les services internes qui retourneraient 403 Forbidden ou seraient inaccessibles depuis internet répondent normalement aux requêtes provenant de l'IP du serveur.

La chaîne d'attaque :

1. L'attaquant identifie un paramètre acceptant des URLs (url, src, image, callback, webhook, redirect, import, etc.)
2. L'attaquant soumet une URL de cible interne (http://127.0.0.1/, http://169.254.169.254/, http://192.168.1.1:8080/admin/)
3. L'application effectue la requête côté serveur depuis sa propre IP (contourne toutes les règles de pare-feu externes)
4. Le service interne répond normalement (pas d'authentification requise pour les métadonnées, pas de restriction réseau)
5. L'application retourne la réponse — l'attaquant lit le contenu interne directement

Le pattern de code vulnérable en Python :

# VULNÉRABLE — récupération directe d'URL contrôlée par l'utilisateur
import requests
 
def fetch_preview(url: str) -> dict:
    # url = "http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE"
    resp = requests.get(url, timeout=10, allow_redirects=True)
    return {"content": resp.text, "status": resp.status_code}
    # L'attaquant reçoit les credentials IAM dans la réponse JSON

Variantes d'attaque#

Le dépliage de lien est une surface d'attaque masquée à haute valeur : les applications qui génèrent des aperçus d'URL (Slack, Discord, cartes d'aperçu CMS) effectuent toutes des requêtes côté serveur vers des URLs fournies par l'attaquant.

Exemples réels#

Capital One 2019 — La brèche SSRF canonique. Un produit WAF déployé sur une instance EC2 avait une mauvaise configuration permettant le SSRF. L'attaquant a soumis des requêtes HTTP contenant l'URL de métadonnées AWS IMDSv1. Le WAF a effectué la requête depuis son IP EC2 interne, retourné le nom du rôle IAM, puis l'attaquant a récupéré le JSON de credentials : {"AccessKeyId":"ASIAJWNJSXFH...","SecretAccessKey":"...","Token":"...","Expiration":"2019-03-18T12:54:10Z"}. Le rôle ISRM-WAF-Role sur-privilégié avait un accès GetObject sur 700+ buckets. Environ 30 Go de données ont été exfiltrés — 100 millions de dossiers américains et 6 millions de dossiers canadiens. À la divulgation (2024), seulement 32 % des instances EC2 avaient IMDSv2 appliqué.

CVE-2024-8977 — GitLab EE (CVSS 8.2, CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:N) — Le tableau de bord Product Analytics de GitLab effectuait des requêtes HTTP côté serveur vers des endpoints Cube API configurables. Tout utilisateur authentifié pouvait remplacer l'URL de l'endpoint Cube par http://169.254.169.254/latest/meta-data/ et le tableau de bord affichait la réponse interne brute. Corrigé dans GitLab 17.4.2, 17.3.5, 17.2.9 (octobre 2024). Signalé via HackerOne par joaxcar.

CVE-2025-68437 — Craft CMS — La mutation GraphQL saveAssets acceptait des URLs arbitraires dans _file { url } et les récupérait côté serveur. Le contenu récupéré était enregistré comme asset et téléchargeable via l'API du CMS — transformant une fonctionnalité d'upload standard en SSRF en bande à lecture complète. Les plateformes CMS qui permettent l'import d'assets depuis URL sont une surface d'attaque constamment sous-estimée.

Détection#

Tests manuels#

1. Énumérer tous les paramètres acceptant des URLs : chaînes de requête, champs JSON (url, src, href, callback, webhook, endpoint, redirect, image, avatar, import_url, feed, resource), et en-têtes HTTP (Host, X-Forwarded-Host, Referer).
2. Pour chaque candidat, soumettre http://127.0.0.1/ et comparer la réponse à une requête de contrôle avec une URL légitime. Une différence de contenu, longueur ou statut confirme que le serveur a effectué une requête sortante.
3. Soumettre http://169.254.169.254/latest/meta-data/ — si la réponse contient ami-id, instance-id, ou des données de rôle IAM, l'application est dans un environnement cloud et les credentials sont directement accessibles.
4. Tester le panel d'administration localhost : http://127.0.0.1:8080/admin/, http://localhost:3000/, http://127.0.0.1:9200/ (Elasticsearch).
5. Si une réponse d'erreur mentionne « connection refused » ou « timeout » différemment pour le port 80 vs le port 22, cela confirme le scan de ports internes via SSRF (utile même sans réflexion de réponse).

# Burp Repeater — test SSRF basique
GET /api/image-preview?url=http://169.254.169.254/latest/meta-data/ HTTP/1.1
Host: target.example.com
 
# Réponse vulnérable attendue :
# ami-id
# ami-launch-index
# hostname
# iam/
# ... (liste de métadonnées)

Détection automatisée#

Nuclei inclut des templates SSRF qui testent les noms de paramètres courants contre les endpoints de métadonnées cloud. SSRFmap automatise le fuzzing multi-paramètres avec des payloads cloud-spécifiques. Burp Scanner Pro identifie les paramètres acceptant des URLs et teste les callbacks OOB via Collaborator.

BreachVex analyse 80+ noms de paramètres SSRF canoniques plus la détection basée sur la valeur (tout paramètre dont la valeur correspond à https?:// ou IPv4 nu), lance des sondes de métadonnées cloud pour AWS/GCP/Azure, et mesure la réponse différentielle par rapport aux IPs de contrôle RFC 5737 (192.0.2.1) pour confirmer l'exécution des requêtes sans nécessiter de réflexion de réponse.

Prévention#

Validation stricte par liste d'autorisation#

import ipaddress
import socket
import urllib.parse
from typing import Optional
 
ALLOWED_HOSTS = frozenset({"api.stripe.com", "hooks.slack.com", "cdn.example.com"})
 
class SSRFError(ValueError):
    pass
 
def validate_and_fetch(url: str) -> str:
    parsed = urllib.parse.urlparse(url)
 
    # Liste d'autorisation de schémas — rejette gopher://, file://, dict://, ftp://
    if parsed.scheme not in ("http", "https"):
        raise SSRFError(f"Schéma non autorisé : {parsed.scheme}")
 
    host = (parsed.hostname or "").rstrip(".")  # supprimer le point FQDN final
    if not host:
        raise SSRFError("Hostname manquant")
 
    # Liste d'autorisation exacte de hosts — pas contains/startsWith
    if host not in ALLOWED_HOSTS:
        raise SSRFError(f"Host absent de la liste d'autorisation : {host}")
 
    # Résoudre DNS et valider TOUTES les adresses retournées (contrecarre les alias DNS + nip.io)
    try:
        results = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
        for (_, _, _, _, sockaddr) in results:
            ip = ipaddress.ip_address(sockaddr[0])
            if isinstance(ip, ipaddress.IPv6Address) and ip.ipv4_mapped:
                ip = ip.ipv4_mapped  # normaliser ::ffff:169.254.169.254
            if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved:
                raise SSRFError(f"Résolution vers une adresse bloquée : {ip}")
    except (socket.gaierror, ValueError) as e:
        raise SSRFError(f"Validation DNS échouée : {e}")
 
    import requests
    # Désactiver le suivi des redirections — valider l'en-tête Location séparément
    resp = requests.get(url, timeout=5, allow_redirects=False)
    if resp.is_redirect:
        raise SSRFError(f"Redirection vers une URL non validée : {resp.headers.get('location')}")
    return resp.text

Filtrage du contenu de la réponse#

Ne pas retourner les réponses internes brutes. Si la fonctionnalité n'a besoin que d'un titre ou d'une image, extraire le champ spécifique et rejeter le reste :

# VULNÉRABLE — retourne la réponse interne brute
return {"preview": requests.get(url).text}
 
# SÛR — extrait uniquement le champ nécessaire
from bs4 import BeautifulSoup
soup = BeautifulSoup(requests.get(validated_url, allow_redirects=False).text, "html.parser")
title = soup.find("title")
return {"preview_title": title.text[:200] if title else ""}

Ressources#

• Vue d'ensemble SSRF
• OWASP SSRF Prevention Cheat Sheet
• PortSwigger — Labs SSRF
• NVD — CVE-2024-8977