Injection de chemin absolu

Qu'est-ce que l'injection de chemin absolu#

L'injection de chemin absolu (CWE-36, un enfant de CWE-22) exploite une propriété comportementale des fonctions de jointure de chemin dans plusieurs langages : quand l'entrée utilisateur commence par un indicateur de chemin absolu (/ sur Unix, C:\ sur Windows), le langage abandonne tout répertoire de base précédemment spécifié et traite l'entrée utilisateur comme le chemin complet.

L'attaque ne nécessite aucune séquence ../. Un filtre qui bloque avec succès toutes les formes de traversée relative — y compris toutes les variantes d'encodage — reste entièrement exposé s'il permet à l'entrée utilisateur de commencer par /. Du point de vue de l'attaquant, c'est le payload le plus simple possible : ?file=/etc/passwd. Du point de vue du défenseur, c'est la variante la plus fréquemment manquée parce que les développeurs supposent qu'un chemin ne contenant pas .. est sûr.

Sous OWASP A01:2021, c'est un échec de contrôle d'accès rompu au niveau de la construction du chemin. Elle se distingue du path traversal de base (CWE-22) par sa cause racine : la traversée relative exploite une canonicalisation insuffisante, tandis que l'injection absolue exploite la sémantique documentée mais surprenante de la jointure de chemin du runtime du langage.

Mécanisme#

Le comportement de os.path.join en Python est l'exemple canonique de cette classe :

import os
 
# Intention du développeur : restreindre l'accès aux fichiers au répertoire /uploads/
BASE = "/var/www/uploads"
 
def vulnerable_open(user_input):
    # VULNÉRABLE : os.path.join abandonne BASE quand user_input commence par /
    path = os.path.join(BASE, user_input)
    return open(path, "rb")
 
# Résultat de os.path.join("/var/www/uploads", "/etc/passwd")
# → "/etc/passwd"   (BASE est complètement abandonné)
print(os.path.join("/var/www/uploads", "/etc/passwd"))
# /etc/passwd

# Même comportement avec pathlib de Python
from pathlib import Path
base = Path("/var/www/uploads")
result = base / "/etc/passwd"
print(result)
# /etc/passwd

path.resolve de Node.js a un comportement équivalent :

const path = require('path');
// path.resolve abandonne tous les arguments précédents quand un chemin absolu est rencontré
console.log(path.resolve('/var/www/uploads', '/etc/passwd'));
// /etc/passwd
 
// path.join NE se comporte PAS ainsi — il normalise la chaîne complète
console.log(path.join('/var/www/uploads', '/etc/passwd'));
// /var/www/uploads/etc/passwd  (note : toujours dangereux si non validé)

urllib.parse.urljoin expose la même classe de vulnérabilité dans la construction d'URLs :

from urllib.parse import urljoin
 
# Quand le second argument commence par /, le chemin du premier URL est remplacé
print(urljoin("https://api.internal/v1/reports/", "/etc/passwd"))
# https://api.internal/etc/passwd
 
# Attaque dans un contexte de proxy microservice
base_url = "https://internal-api.corp/api/v2/"
user_path = "/admin/users"
# Résultat : https://internal-api.corp/admin/users
# Le préfixe /api/v2/ est silencieusement abandonné

GET /proxy?path=/admin/users HTTP/1.1
Host: app.example.com
 
HTTP/1.1 200 OK
Content-Type: application/json
 
{"users": [...tous les utilisateurs incluant les admins...]}

Variantes d'attaque#

Cibles de chemin absolu à haute valeur#

Sous Linux, les cibles les plus impactantes accessibles via un chemin absolu sans nécessiter des privilèges élevés :

/etc/passwd                         → énumération d'utilisateurs
/proc/self/environ                  → secrets d'exécution (clés cloud, URLs DB, tokens API)
/proc/self/cmdline                  → identification du processus en cours
/proc/version                       → version du noyau pour sélection d'exploit
/app/.env                           → tous les secrets de l'application en un seul fichier
/home/ubuntu/.ssh/id_rsa            → clé privée SSH
/home/ubuntu/.aws/credentials       → fichier de credentials AWS
/var/run/secrets/kubernetes.io/serviceaccount/token  → JWT Kubernetes

Sous Windows, quand l'application tourne sous IIS :

C:\Windows\win.ini                  → marqueur de confirmation d'accès au FS ([fonts])
C:\inetpub\wwwroot\web.config       → chaînes de connexion ASP.NET, clés secrètes
C:\Windows\System32\drivers\etc\hosts  → noms d'hôtes internes

Exemples réels#

CVE-2026-32871 — FastMCP OpenAPIProvider (CVSS 9.8) : le fournisseur OpenAPI de FastMCP utilisait urllib.parse.urljoin(base_url, user_path) pour construire des URLs pour le proxying d'API interne. Quand le chemin fourni par l'utilisateur commençait par /, urljoin abandonnait le composant de chemin de l'URL de base. Un attaquant authentifié envoyait des requêtes avec des chemins commençant par / pour rediriger les requêtes HTTP sortantes du serveur vers des endpoints internes arbitraires — combinant injection de chemin absolu et SSRF. Les requêtes transférées incluaient les en-têtes d'authentification de la requête originale, accordant l'accès aux services internes protégés.

CVE-2023-50164 — Apache Struts2 File Upload (CVSS 9.8) : les versions Apache Struts2 2.0.0 à 6.3.0 étaient vulnérables au path traversal dans les paramètres d'action d'upload de fichier. Les attaquants manipulaient la casse du paramètre de chemin d'upload pour réaliser une écriture de fichier absolue effective — écrivant des webshells JSP en dehors du répertoire d'upload prévu. L'exploitation non authentifiée réalisait une exécution de code à distance. La vulnérabilité affectait toute application Struts2 utilisant la fonctionnalité d'upload de fichier.

CVE-2023-34362 — MOVEit Transfer (CVSS 9.8) : l'exploitation massive de MOVEit Transfer par le groupe ransomware Cl0p combinait une injection SQL avec un composant de path traversal qui permettait une lecture de fichier arbitraire. L'élément de path traversal utilisait des spécifications de chemin absolu pour cibler des fichiers de configuration en dehors du webroot de l'application, permettant un vol massif de données affectant des centaines d'organisations incluant des agences gouvernementales et des institutions financières.

Détection#

Tests manuels#

1. Pour chaque paramètre référençant des fichiers, soumettre /etc/passwd directement — sans séquences de traversée — et vérifier la présence de root:x:0:0: dans le corps de la réponse.
2. Si l'application semble filtrer ../, ce test révèle spécifiquement si l'entrée de chemin absolu est également filtrée.
3. Sur les applications Windows, tester C:\Windows\win.ini et rechercher [fonts] dans la réponse.
4. Pour les applications qui proxient des requêtes vers des services internes (API gateways, couches BFF, proxies internes), tester si le paramètre de chemin peut commencer par / pour remplacer le chemin cible.
5. Tester la cible du token Kubernetes /var/run/secrets/kubernetes.io/serviceaccount/token — si retourné, l'application tourne dans un pod Kubernetes avec injection de token de compte de service, et le JWT fournit un accès à l'API du cluster.
6. Tester le comportement de pathlib Python : essayer des valeurs de chemin commençant par / et comparer les tailles de réponse avec des valeurs de test qui ne commencent pas par /.

Détection automatisée#

BreachVex inclut "/{file}" comme variante de payload dédiée à l'absolu dans son jeu de payloads de traversée, spécifiquement pour tester l'injection de chemin absolu séparément de la traversée relative. La validation par porte de contenu applique la même vérification à trois critères : HTTP 200, longueur du corps ≥ 10 octets, et correspondance regex du marqueur spécifique au fichier.

Prévention#

Valider la sortie résolue, pas l'entrée#

import os
 
BASE_DIR = os.path.realpath("/var/www/app/uploads")
 
def safe_open(user_input: str) -> bytes:
    # Join d'abord, puis résolution — neutralise à la fois l'injection relative et absolue
    full_path = os.path.join(BASE_DIR, user_input)
    resolved = os.path.realpath(full_path)
    
    # os.path.realpath sur os.path.join("/uploads", "/etc/passwd")
    # → full_path = "/etc/passwd" (join abandonne la base)
    # → resolved = "/etc/passwd"
    # → la vérification startsWith ÉCHOUE → exception levée
    if not resolved.startswith(BASE_DIR + os.sep):
        raise PermissionError("Injection de chemin absolu bloquée")
    
    with open(resolved, "rb") as f:
        return f.read()

// Node.js — path.resolve puis valider
const path = require('path');
const fs = require('fs');
const BASE = fs.realpathSync('/var/www/uploads');
 
function safeRead(userInput) {
    // path.resolve gère à la fois les composants absolus et les séquences ..
    const resolved = path.resolve(BASE, userInput);
    const real = fs.realpathSync(resolved);
    if (!real.startsWith(BASE + path.sep)) {
        throw new Error('Accès refusé : tentative d\'injection de chemin absolu');
    }
    return fs.readFileSync(real);
}

Construction d'URL sécurisée dans le code proxy#

from urllib.parse import urljoin, urlparse
 
INTERNAL_BASE = "https://internal-api.corp/api/v2/"
 
def safe_proxy(user_path: str) -> str:
    # Rejeter les chemins commençant par / pour éviter le remplacement de base urljoin
    if user_path.startswith("/"):
        raise ValueError("Chemin absolu non autorisé dans le paramètre proxy")
    # De plus : liste blanche des préfixes de chemin
    allowed_prefixes = ["reports/", "documents/", "exports/"]
    if not any(user_path.startswith(p) for p in allowed_prefixes):
        raise ValueError("Chemin absent de la liste des préfixes autorisés")
    return urljoin(INTERNAL_BASE, user_path)

Utiliser l'indirection par UUID#

Remplacer les paramètres de chemin contrôlés par l'utilisateur par des identifiants opaques qui mappent vers des chemins côté serveur :

import uuid
from typing import Optional
 
# Registre de fichiers : UUID → chemin réel
FILE_REGISTRY: dict[str, str] = {}
 
def register_file(real_path: str) -> str:
    file_id = str(uuid.uuid4())
    FILE_REGISTRY[file_id] = real_path
    return file_id
 
def get_file(file_id: str) -> Optional[bytes]:
    path = FILE_REGISTRY.get(file_id)
    if path is None:
        return None
    with open(path, "rb") as f:
        return f.read()

Ressources#

• Path Traversal — Vue d'ensemble pillar
• OWASP Path Traversal
• CWE-36 : Absolute Path Traversal
• NVD CVE-2023-50164 — Apache Struts2