Redirection par Paramètre URL

// VULNÉRABLE — passe l'entrée utilisateur directement à redirect
app.get("/login", (req, res) => {
  // Logique d'authentification...
  const next = req.query.next || "/dashboard";
  res.redirect(next);  // Pas de validation d'hôte — redirection ouverte
});

GET /login?next=https://attacker.com/capture HTTP/1.1
Host: app-de-confiance.com
 
HTTP/1.1 302 Found
Location: https://attacker.com/capture
Set-Cookie: session=...

https://app-de-confiance.com/login?next=https://attacker.com
https://app-de-confiance.com/logout?redirect=https://attacker.com
https://app-de-confiance.com/auth/callback?return=https://attacker.com

# Ces payloads exploitent l'écart entre validation Python et parsing navigateur
from urllib.parse import urlparse
 
urlparse("\\evil.com").netloc      # '' — Python voit chemin relatif, navigateur voit evil.com
urlparse("%09https://evil.com").netloc  # '' — tab supprimé, schéma vide pour Python
 
# Mais WHATWG normalise : \\evil.com → https://evil.com, %09 supprimé → https://evil.com

# Protocol-relative (navigateur résout en https://attacker.com)
?next=//attacker.com
 
# Normalisation antislash (WHATWG normalise \\ en /)
?next=\attacker.com
 
# Préfixe caractère de contrôle
?next=%09https://attacker.com
 
# Abus userinfo (trusted-app.com est le nom d'utilisateur, attacker.com est l'hôte)
?next=https://trusted-app.com@attacker.com
?next=https://trusted-app.com%40attacker.com
 
# Abus de suffixe (passe la vérification endsWith, mais l'hôte est attacker.com)
?next=https://trusted-app.com.attacker.com
 
# Double encodage
?next=%2540attacker.com
 
# Null byte
?next=https://attacker.com%00.trusted-app.com

# OpenRedireX — fuzzer async avec 50+ payloads de bypass
cat urls.txt | openredirex -p /opt/open-redirect-payloads.txt
 
# nuclei — templates CVE + fuzzing de paramètres
nuclei -l targets.txt -t fuzzing/redirect-params.yaml
nuclei -l targets.txt -t cves/2025/CVE-2025-69725.yaml
 
# dalfox v3+ mode open-redirect
dalfox url "https://target.com/login?next=1" --open-redirect
 
# gf + waybackurls pour la découverte de paramètres
waybackurls target.com | gf redirect | sort -u

# Flask — BONNE PRATIQUE
from urllib.parse import urlparse
 
ALLOWED_HOSTS = frozenset({"app.example.com", "dashboard.example.com"})
 
def _safe_redirect(url: str, fallback: str = "/dashboard") -> str:
    if not url:
        return fallback
    # Rejeter les caractères de contrôle
    if any(c in url for c in ["\r", "\n", "\t", "\x00"]):
        return fallback
    # Rejeter l'antislash (WHATWG normalise en /, Python ne le fait pas)
    if "\\" in url:
        return fallback
    parsed = urlparse(url)
    # Autoriser les URLs relatives commençant par /
    if not parsed.netloc and url.startswith("/") and not url.startswith("//"):
        return url
    # Les URLs externes doivent être sur l'allowlist
    if parsed.netloc not in ALLOWED_HOSTS:
        return fallback
    return url
 
@app.route("/login")
def login():
    next_url = request.args.get("next", "/dashboard")
    return redirect(_safe_redirect(next_url))

// Express.js — BONNE PRATIQUE
const ALLOWED_HOSTS = new Set(["app.example.com", "dashboard.example.com"]);
 
function isSafeRedirect(url) {
  if (!url) return false;
  if (url.startsWith("/") && !url.startsWith("//")) return true;
  try {
    // Constructeur WHATWG URL — normalise de la même façon que les navigateurs
    const parsed = new URL(url);
    return ALLOWED_HOSTS.has(parsed.hostname);
  } catch {
    return false;
  }
}
 
app.get("/login", (req, res) => {
  const next = req.query.next;
  const destination = isSafeRedirect(next) ? next : "/dashboard";
  res.redirect(destination);
});

# Stocker la destination avant la redirection — aucune URL dans le paramètre
import secrets
import redis
 
redis_client = redis.Redis()
 
@app.route("/pre-login")
def pre_login():
    state = secrets.token_urlsafe(32)
    redis_client.set(f"redirect:{state}", "/user/dashboard", ex=300)
    return redirect(f"/login?state={state}")
 
@app.route("/post-login")
def post_login():
    state = request.args.get("state", "")
    raw = redis_client.get(f"redirect:{state}")
    destination = raw.decode() if raw else "/dashboard"
    redis_client.delete(f"redirect:{state}")
    return redirect(destination)