# VULNÉRABLE : l'application récupère une image depuis une URL fournie par l'utilisateur
import httpx
from fastapi import FastAPI

app = FastAPI()

@app.post("/import-avatar")
async def import_avatar_vulnerable(image_url: str):
    async with httpx.AsyncClient() as client:
        response = await client.get(image_url)  # aucune restriction sur la destination
    return {"size": len(response.content)}

# Payloads de démonstration en lab autorisé, exploitant la confiance du serveur :
# image_url = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"  # métadonnées cloud AWS
# image_url = "http://localhost:6379/"                                             # Redis interne
# image_url = "http://internal-admin-panel.local:8080/delete-all"                  # service interne non exposé
# image_url = "file:///etc/passwd"                                                  # lecture de fichier local

# CORRECT : liste blanche stricte de domaines/IP autorisés + résolution DNS vérifiée
import ipaddress
import socket
from urllib.parse import urlparse

ALLOWED_HOSTS = {"images.trusted-cdn.com", "assets.technologik.local"}

def is_private_ip(ip: str) -> bool:
    addr = ipaddress.ip_address(ip)
    return addr.is_private or addr.is_loopback or addr.is_link_local or addr.is_reserved

def validate_outbound_url(url: str) -> str:
    parsed = urlparse(url)
    if parsed.scheme not in ("http", "https"):
        raise ValueError("schéma non autorisé")
    if parsed.hostname not in ALLOWED_HOSTS:
        raise ValueError("hôte non autorisé (liste blanche)")

    # Résoudre le DNS et vérifier que l'IP réelle n'est pas privée (contre le DNS rebinding)
    resolved_ip = socket.gethostbyname(parsed.hostname)
    if is_private_ip(resolved_ip):
        raise ValueError("résolution vers une IP privée refusée")
    return url

@app.post("/import-avatar")
async def import_avatar_safe(image_url: str):
    validated = validate_outbound_url(image_url)
    async with httpx.AsyncClient(follow_redirects=False, timeout=5.0) as client:  # pas de redirects auto
        response = await client.get(validated)
    return {"size": len(response.content)}

# Vecteurs de contournement de filtre à connaître (pour bien défendre)
1. Redirection HTTP : URL initiale autorisée qui redirige (302) vers une IP interne -> désactiver follow_redirects
2. DNS rebinding : le domaine autorisé résout vers une IP publique au moment du check, puis interne au moment du fetch
3. Encodage alternatif d'IP : http://0x7f000001/ ou http://2130706433/ (équivalents de 127.0.0.1)
4. IPv6 : http://[::1]/ équivalent loopback en IPv6
5. URLs avec userinfo trompeur : http://trusted.com@169.254.169.254/ (le host réel est après le @)

# Défense supplémentaire : réseau (pas seulement applicatif) - bloquer l'accès aux métadonnées cloud
# via une règle de pare-feu sortant, indépendamment du code applicatif
# Exemple iptables sur l'hôte du service qui fait les requêtes sortantes
"""
iptables -A OUTPUT -d 169.254.169.254 -j DROP
"""

# Checklist défense SSRF
- Liste blanche de destinations (jamais liste noire, toujours contournable)
- Résolution DNS vérifiée juste avant la connexion (éviter le TOCTOU / DNS rebinding)
- Désactiver les redirections HTTP automatiques ou les revalider à chaque saut
- Timeout court + limite de taille de réponse (éviter l'exfiltration/déni de service)
- Isoler le service qui fait des requêtes sortantes dans un réseau sans accès aux ressources internes sensibles