C:\>aula_ □ ×

Redes para CTF: o mapa antes do Nmap

Antes de rodar ferramenta, precisamos saber o que estamos olhando. IP, porta, rota, DNS e protocolo não são teoria solta. São o mapa do alvo.

Host

Quem existe na rede.

Serviço

O que está escutando.

Protocolo

Como conversar com aquilo.

Evidência

O que prova o próximo passo.

Em CTF, muita gente pula direto para nmap -A, copia a saída e fica esperando que a exploração apareça sozinha. Às vezes funciona. Na maioria das vezes, vira ruído.

Esta aula é o caminho anterior: entender o básico de redes o suficiente para ler uma máquina. A base segue o jeito clássico de redes apresentado em livros como o Kurose: aplicação, transporte, rede, enlace, pacotes, atraso, perda e serviços rodando na borda da rede. Aqui a tradução é prática: o que isso muda quando você recebe um IP na VPN.

1. O modelo mental
C:\>modelo_ □ ×

Rede é processo falando com processo

Cliente

Abre conexão e envia uma requisição.

Servidor

Escuta em uma porta e responde.

Protocolo

Define o formato da conversa.

Estado

Alguns protocolos guardam sessão, outros não.

No fim, a maior parte do que fazemos em enumeração é responder a uma pergunta simples: qual processo está aceitando conversa nesse alvo?

Um navegador conversando com HTTP, um cliente SSH tentando login, um cliente FTP pedindo listagem, um resolver consultando DNS. São programas trocando mensagens. A rede só transporta essas mensagens em pedaços.

Isso ajuda a parar de pensar em porta como número aleatório. Porta é ponto de entrada para um processo. Se a porta está aberta, algo está escutando. Se algo está escutando, existe um protocolo. Se existe um protocolo, dá para conversar, pedir banner, mandar requisição, errar de propósito e observar a resposta.

raciocínio básico_ □ ×
IP encontrado
└── quais portas respondem?
  └── qual serviço aparece?
      └── qual protocolo ele fala?
          └── que informação ele vaza?
              └── qual próximo teste faz sentido?
2. Host, IP e rede
C:\>ip_ □ ×

IP aponta para uma interface, não para uma pessoa

Host

Máquina, container, VM ou equipamento.

Interface

Ponto de conexão com a rede.

IP

Endereço usado para entregar pacotes.

Rede

Conjunto de IPs alcançáveis dentro de um prefixo.

Em laboratório, o alvo costuma aparecer como 10.30.0.18, 172.16.1.20 ou algo parecido. Esse endereço não diz “quem” é o alvo. Ele diz para onde o pacote deve ser enviado.

Uma mesma máquina pode ter mais de um IP. Um container pode ter IP em uma rede Docker. Sua máquina pode ter IP no Wi-Fi e outro na VPN. Por isso, quando algo não responde, a primeira pergunta não é “qual exploit eu uso?”. É: eu chego nesse endereço pela interface certa?

ver seu lado da rede_ □ ×
ip addr
ip route

# interface da VPN, se existir
ip addr show tun0
ip addr show wg0

Se você está fora da VPN, o alvo privado não existe para você. O pacote nem chega perto dele.

4. Rota, gateway e VPN
C:\>rota_ □ ×

Seu sistema escolhe uma saída para cada destino

Rota

Regra que diz por onde mandar o pacote.

Gateway

Próximo salto quando o destino não está direto na rede.

VPN

Cria uma rota para redes privadas do lab.

Default route

Caminho usado quando nada mais específico bate.

Quando você roda curl http://10.30.0.18, o sistema consulta a tabela de rotas. Ele não “tenta tudo”. Ele escolhe uma interface.

Se a rota para 10.30.0.0/24 aponta para a VPN, o pacote sai pelo túnel. Se não existe rota, ele tenta sair pelo gateway padrão da sua rede normal. Aí o alvo privado não responde.

Esse é um dos bugs mais comuns em laboratório: a pessoa está logada no site, mas não está conectada na VPN certa. O alvo parece morto, mas o problema está do lado do atacante.

debug de rota_ □ ×
ip route
ip route get 10.30.0.18

# teste simples de alcance
ping -c 3 10.30.0.18

# caminho até o alvo, quando ICMP/traceroute ajudam
traceroute 10.30.0.18
5. MAC e ARP
C:\>arp_ □ ×

Na rede local, IP precisa virar MAC

IP

Endereço lógico usado para roteamento.

MAC

Endereço da interface no enlace local.

ARP

Resolve IP para MAC em redes IPv4 locais.

Limite

ARP não atravessa roteador.

ARP aparece pouco em CTF iniciante, mas explica muita coisa quando estamos em redes internas.

Se o destino está na mesma rede local, sua máquina pergunta: “quem tem este IP?”. O host dono responde com o MAC. Se o destino está em outra rede, sua máquina não procura o MAC do destino final. Ela procura o MAC do gateway.

Em VPN e Docker, esse detalhe ajuda a entender por que o alvo pode aparecer como IP privado e ainda assim estar isolado em uma rede controlada.

cache arp_ □ ×
ip neigh
arp -a
6. Portas e serviços
C:\>portas_ □ ×

Porta aberta é uma conversa possível

22/tcp

Geralmente SSH.

21/tcp

Geralmente FTP.

80/tcp

Geralmente HTTP.

31337/tcp

Pode ser qualquer coisa. Teste.

Porta não é vulnerabilidade. Porta é exposição. O que importa é o serviço por trás dela.

22/tcp open ssh diz que existe SSH. Ainda não diz que você tem credencial. 80/tcp open http diz que há aplicação web. Ainda não diz que tem SQLi. O trabalho de enumeração começa depois do “open”.

Também não confie cegamente na porta padrão. Um HTTP pode rodar em 8080. Um serviço customizado pode usar 31337. O Nmap tenta identificar versão, mas serviço estranho exige interação manual.

primeira leitura de portas_ □ ×
nmap -p- --min-rate 5000 TARGET_IP

# depois, nas portas encontradas
nmap -sC -sV -p 21,22,80,8080 TARGET_IP
7. TCP e UDP
C:\>transporte_ □ ×

TCP conversa com estado. UDP joga datagrama.

TCP

Conexão, ordem, retransmissão e stream.

UDP

Sem conexão. Envia e espera que alguém responda.

Scan TCP

Mais confiável para começo.

Scan UDP

Mais lento e ambíguo.

TCP tem handshake. Antes de trocar dados, cliente e servidor combinam a conexão. Isso torna o scan mais fácil de interpretar: aberto, fechado, filtrado.

UDP não tem handshake. Se você manda um pacote e nada volta, pode ser porque a porta está filtrada, porque o serviço ficou quieto ou porque o payload não fez sentido. Por isso, UDP demora mais e pede mais contexto.

Para CTF iniciante, comece por TCP. Só vá para UDP quando o enunciado, o scan ou a máquina indicarem algo nessa direção.

tcp vs udp_ □ ×
# TCP
nmap -sS -p- TARGET_IP

# UDP: mais lento; use com intenção
sudo nmap -sU --top-ports 20 TARGET_IP
8. Socket: IP + porta + protocolo
C:\>socket_ □ ×

10.30.0.18:80/tcp é um ponto de conversa

IP

Para qual host enviar.

Porta

Para qual processo entregar.

Protocolo

Como a conversa deve acontecer.

Cliente

Escolhe uma porta local temporária.

Quando você acessa http://10.30.0.18:80, sua máquina abre uma conexão de uma porta local aleatória para 10.30.0.18:80/tcp.

O servidor responde para essa conexão. Esse par de pontas permite que muitas conexões aconteçam ao mesmo tempo sem se misturar.

Em debug, isso importa quando você vê logs do tipo 10.30.0.2:54704. Esse número alto não é porta do serviço. É a porta temporária do cliente.

ver conexões locais_ □ ×
ss -tulpen
ss -tanp

# testar uma porta manualmente
nc -nv TARGET_IP 80
nc -nv TARGET_IP 31337
9. DNS e nomes
C:\>dns_ □ ×

Nome é só uma forma de chegar no IP

DNS

Resolve nome para endereço.

/etc/hosts

Mapa local antes ou junto da resolução DNS.

VHost

Mesmo IP, sites diferentes pelo cabeçalho Host.

Erro comum

Escanear IP e esquecer o domínio.

DNS não é só “internet”. Em CTF web, nome muda comportamento.

Um servidor pode responder uma página genérica quando acessado por IP e outra aplicação quando acessado por domínio. Isso acontece por virtual hosts. O IP é o mesmo, mas o cabeçalho Host muda.

Se o desafio der um domínio interno, adicione no /etc/hosts. Se o Nmap mostrar HTTP e a página parecer vazia, teste robots.txt, código fonte e vhosts antes de concluir que não tem nada.

nomes e vhosts_ □ ×
# resolver domínio
host exemplo.local
nslookup exemplo.local

# mapear manualmente no Linux
sudo sh -c 'echo "10.30.0.18 exemplo.local" >> /etc/hosts'

# testar Host header sem editar /etc/hosts
curl -H 'Host: exemplo.local' http://10.30.0.18/
10. HTTP para enumeração
C:\>http_ □ ×

HTTP é texto com método, caminho e cabeçalhos

Método

GET, POST, HEAD.

Path

/, /admin, /robots.txt.

Status

200, 301, 403, 404.

Headers

Servidor, cookies, redirects, tipo de conteúdo.

HTTP é onde enumeração começa a ficar visível. A resposta carrega status code, tamanho, headers, cookies, HTML, JS e comentários.

404 não é sempre inútil. 403 não é sempre bloqueio final. 301 e 302 podem mostrar caminhos. Um robots.txt pode entregar o próximo arquivo. Um HTML simples pode carregar um script com endpoint escondido.

Não use só navegador. Use curl. Ele mostra o que o navegador esconde.

http manual_ □ ×
curl -i http://TARGET_IP/
curl -i http://TARGET_IP/robots.txt
curl -s http://TARGET_IP/ | sed -n '1,80p'

# seguir redirect
curl -L -i http://TARGET_IP/
11. Camadas sem decorar tabela
C:\>camadas_ □ ×

Cada camada responde uma pergunta diferente

Aplicação

Qual protocolo estou falando?

Transporte

TCP ou UDP? Qual porta?

Rede

Qual IP? Qual rota?

Enlace

Estou no mesmo segmento? Preciso de gateway?

Não precisa decorar o modelo OSI para resolver CTF. Precisa saber separar problemas.

Se ping não responde, pode ser bloqueio de ICMP. Não prova que o host está morto. Se TCP não conecta, pode ser porta fechada, firewall, rota errada ou serviço parado. Se HTTP responde, mas o site está “vazio”, a rede está funcionando; o problema agora é enumeração de aplicação.

Essa separação evita perder tempo no lugar errado.

SintomaPergunta certaTeste útil
No route to hostTenho rota para essa rede?ip route get IP
Connection refusedA porta está fechada?nmap -p PORTA IP
Connection timed outFiltro, rota ou serviço mudo?nmap -Pn -p PORTA IP
HTTP 403Existe recurso, mas estou bloqueado?curl -i URL
12. Como isso vira Nmap
C:\>nmap_ □ ×

Nmap não resolve a máquina. Ele organiza a primeira evidência.

Host discovery

O alvo parece vivo?

Port scan

Quais portas aceitam conexão?

Version scan

Qual software parece estar atrás?

Scripts

Que checagens padrão fazem sentido?

O fluxo que funciona bem em CTF é em duas etapas.

Primeiro, ache portas. Depois, aprofunde só nelas. Rodar tudo em todas as portas desde o começo é lento e bagunça a leitura.

fluxo limpo_ □ ×
# 1. achar portas TCP
nmap -p- --min-rate 5000 TARGET_IP

# 2. aprofundar nas portas encontradas
nmap -sC -sV -p 21,22,80,8080 TARGET_IP

# 3. salvar saída
nmap -sC -sV -p 21,22,80,8080 TARGET_IP -oN nmap.txt

Depois do scan, escreva um mapa pequeno. Não precisa bonito. Precisa ser útil.

anotação mínima_ □ ×
TARGET=10.30.0.18
21/tcp  ftp     vsftpd      aceita anonymous?
22/tcp  ssh     OpenSSH     precisa credencial
80/tcp  http    Python      verificar /, /robots.txt, código fonte
13. Lendo evidência
C:\>método_ □ ×

Saída de ferramenta não é conclusão

Aberto

Existe um serviço. Converse com ele.

Versão

Pesquise, mas valide no alvo.

Banner

Pode mentir, mas ainda é pista.

Arquivo

Nome, path e conteúdo importam.

A diferença entre enumeração e tentativa aleatória é evidência.

Se o FTP aceita anonymous, liste. Se listou arquivos, baixe. Se o arquivo parece backup, leia offline. Se apareceu usuário, procure serviço que aceite usuário. Se apareceu HTTP, veja headers, paths e comportamento. Cada passo precisa ter um motivo.

Esse é o ponto onde esta aula encaixa com a aula de Enumeração e Fuzzing: redes te dizem como chegar e com o que conversar; enumeração web te ajuda a descobrir o que está escondido depois que HTTP aparece.

sequência sem chute_ □ ×
nmap -> portas
porta -> serviço
serviço -> protocolo
protocolo -> enumeração específica
evidência -> próximo teste
14. Cheat Sheet
C:\>referência_ □ ×

Comandos que você realmente vai usar

Guarde estes comandos. Eles cobrem a maioria dos problemas de rede antes da exploração.

rede local e rota_ □ ×
ip addr
ip route
ip route get TARGET_IP
ip neigh
ping -c 3 TARGET_IP
portas e serviços_ □ ×
nmap -sn REDE/CIDR
nmap -p- --min-rate 5000 TARGET_IP
nmap -sC -sV -p PORTAS TARGET_IP
nc -nv TARGET_IP PORTA
dns e http_ □ ×
host dominio.local
sudo sh -c 'echo "TARGET_IP dominio.local" >> /etc/hosts'

curl -i http://TARGET_IP/
curl -i http://TARGET_IP/robots.txt
curl -H 'Host: dominio.local' http://TARGET_IP/

Quando isso estiver confortável, o próximo passo natural é enumeração específica: web fuzzing, FTP, SMB, SSH, bancos de dados, banners customizados e leitura de arquivos vazados.

A ordem continua a mesma: achar superfície, conversar com o serviço, registrar evidência, escolher o próximo teste.