1. Qu'est-ce que le SSRF ?

Le SSRF (Server-Side Request Forgery) est une vulnérabilité dans laquelle un attaquant manipule le serveur pour qu'il effectue des requêtes HTTP vers des destinations arbitraires. L'objectif est souvent d'accéder à des systèmes internes qui ne sont pas directement accessibles depuis l'extérieur, mais que le serveur peut joindre. De nombreuses applications Web proposent des fonctionnalités de récupération de données depuis d'autres serveurs (par exemple, charger une image distante). Si cette fonctionnalité est mal sécurisée, un attaquant peut l'utiliser comme proxy pour attaquer des serveurs locaux ou distants.

Le flux : Attaquant → Serveur vulnérable → Cible interne.

2. Mécanismes du SSRF

Le SSRF survient généralement lorsque le serveur permet de récupérer du contenu depuis une URL fournie par l'utilisateur, sans filtrer correctement la destination. Par exemple, un script pourrait accepter un paramètre url et utiliser file_get_contents() ou curl_exec() pour récupérer la ressource. L'attaquant peut alors modifier l'URL pour pointer vers des adresses internes (comme 192.168.1.1 ou 127.0.0.1) afin de sonder le réseau interne ou de lire des fichiers locaux.

Exemple de scénario :

• Un site public A (accessible à tous) peut être utilisé comme passerelle pour atteindre un site interne B (réservé au réseau local).
• L'attaquant envoie une requête à A en modifiant le paramètre d'URL pour qu'il pointe vers B.
• Le serveur A exécute la requête et renvoie la réponse à l'attaquant, révélant des informations protégées.

Les principales attaques possibles :

• Scan de ports sur le réseau interne ou local
• Attaques contre des applications internes (ex : Redis non protégé)
• Fingerprinting de services internes
• Exploitation de vulnérabilités via GET (ex : Struts2, injections SQL basiques)
• Lecture de fichiers via le protocole file://

3. Exploitation du SSRF

3.1 Protocoles courants

Les protocoles fréquemment utilisés dans les attaques SSRF :

• http:// et https://
• file://
• dict://
• gopher://

Avec l'outil curl, on peut exploiter ces protocoles. Par exemple :

# Lecture de fichier local
curl -v file:///etc/passwd

# Test de connexion FTP
curl -v "ftp://127.0.0.1:21/info"

# Requête dict
curl -v "dict://127.0.0.1:6379/info"

# Gopher
curl -v "gopher://127.0.0.1:6379/_SET key value"

Paramètre important : -v permet d'afficher les détails de la communication.

3.2 Adresses IP internes classiques

Les plages d'adresses privées :

• Classe C : 192.168.0.0 - 192.168.255.255
• Classe B : 172.16.0.0 - 172.31.255.255
• Classe A : 10.0.0.0 - 10.255.255.255

Exemple typique : 192.168.0.1 est souvent la passerelle.

3.3 Étapes d'exploitation typiques

1. Scan de ports et d'IP internes via HTTP
2. Lecture de fichiers locaux via file://
3. Exploitation de services internes (ex : Redis) via gopher:// ou dict://

3.4 Exemple avec PHP

En PHP, les fonctions suivantes peuvent être sources de SSRF :

• file_get_contents()
• fsockopen()
• curl_exec() (la plus puissante)

Code vulnérable avec cURL :

<?php
// ssrf.php
$url = isset($_GET['target']) ? $_GET['target'] : '';
if ($url) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // ignore SSL
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
    $result = curl_exec($ch);
    curl_close($ch);
}
?>

Exemple d'utilisation : Appeler ssrf.php?target=http://localhost/info.php lira le phpinfo() local.

On peut aussi scanner un port : ssrf.php?target=http://127.0.0.1:3306 et observer la réponse.

Avec le protocole dict://, on peut récupérer des bannières de services comme Redis : dict://127.0.0.1:6379/info.

4. Défense contre le SSRF

1. Valider la réponse : Vérifier que le contenu retourné correspond au type atendu (ex : image, JSON).
2. Messages d'erreur uniformes : Éviter de donner des indices sur l'existence d'un service interne.
3. Restreindre les ports : Autoriser uniquement les ports HTTP/HTTPS standards (80, 443, 8080, etc.).
4. Filtrer les adresses IP inetrnes : Bloquer les plages privées (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16).
5. Limiter les protocoles : N'autoriser que HTTP et HTTPS, interdire file://, gopher://, dict://, ftp://, etc.