Redes para Cibersegurança — Guia Completo

0. A mentalidade certa antes de começar

A maioria das pessoas estuda rede decorando portas ("80 é HTTP, 443 é HTTPS") e para por aí. Isso te faz decorar um dicionário, não entender uma língua. O que separa quem trabalha com cyber de quem só passou numa prova é conseguir responder três perguntas sobre qualquer tráfego que aparecer na tela:

1. Quem está falando com quem? (origem, destino, direção)
2. Como essa conversa começou e como ela está sendo mantida? (handshake, estado da conexão)
3. Isso faz sentido para este ambiente? (o desvio do normal é o que denuncia o ataque)

Todo o resto (OSI, subnetting, DNS) existe para você conseguir responder essas três perguntas com precisão.

1. Modelo OSI e TCP/IP — o "mapa" da comunicação

A analogia da carta. Imagine mandar uma carta física: você escreve o conteúdo, coloca num envelope com endereço, o carteiro decide a rota e o entregador local bate na porta certa. Cada um só se preocupa com a sua parte — o carteiro não lê a carta, só olha o envelope. É assim que uma rede funciona: camadas, cada uma com uma responsabilidade, cada uma "envelopando" a de cima.

O modelo OSI (7 camadas) — o vocabulário do mercado

Mnemônico (de baixo para cima): "Fala EnRola Tudo Sem Acabar Assunto" → Física, Enlace, Rede, Transporte, Sessão, Apresentação, Aplicação.

O modelo TCP/IP (4 camadas) — o que a internet realmente usa

* Tecnicamente o ARP fica "entre" camadas; guarde que ele resolve MAC↔IP.

Encapsulamento — o coração de tudo

[ HTTP GET /login ]                        ← Aplicação: seu pedido
[ TCP | porta origem/destino | HTTP GET ]  ← Transporte: envelopa com portas
[ IP  | IP origem/destino | TCP... ]       ← Rede: envelopa com IPs
[ ETH | MAC origem/destino | IP... ]       ← Enlace: envelopa com MACs
1010101110101... (vira sinal no fio)       ← Física

Do outro lado, o processo é inverso (desencapsulamento): cada camada abre seu envelope e entrega o conteúdo para a de cima.

2. Endereçamento IPv4

A analogia do endereço postal. Um IP é como rua + número da casa. A "rua" é a rede; o "número" é o host. A máscara de sub-rede diz onde termina a rua e começa o número. Um IPv4 tem 32 bits, em 4 octetos (0–255):

192.168.0.10
11000000.10101000.00000000.00001010  =  192.168.0.10
   8   .   8    .   8    .   8   bits  =  32 bits

Faixas privadas (RFC 1918) — decore estas

Outras faixas: 127.0.0.0/8 loopback (127.0.0.1 = localhost); 169.254.0.0/16 APIPA (o host não conseguiu IP do DHCP, sinal de problema); 0.0.0.0 "qualquer/rota padrão".

3. Subnetting — a habilidade que separa amador de profissional

A ideia é simples: dividir uma rede grande em pedaços menores e controláveis. Imagine um prédio onde qualquer pessoa entra em qualquer sala; subnetting é colocar paredes e portas (RH numa sub-rede, financeiro em outra, servidores em outra). Melhora organização, desempenho e, crucial para cyber, contenção: se um invasor cai numa sub-rede, não alcança as outras automaticamente.

CIDR: a notação "/"

Em vez da máscara 255.255.255.0, escrevemos /24. O número após a barra é quantos bits, da esquerda para a direita, pertencem à rede; o resto é dos hosts.

/24  →  11111111.11111111.11111111.00000000  →  255.255.255.0
        \___________ rede __________/ \_host_/

Tabela mestra (a que você usa todo dia)

Fórmula dos hosts: 2^(bits de host) − 2. Os "−2" são o endereço de rede (o primeiro) e o broadcast (o último); nenhum pode ser dado a uma máquina.

Exemplo prático passo a passo

Em qual sub-rede está o host 192.168.1.100/26?

1. /26 → o "salto" é 64. Blocos do último octeto: 0, 64, 128, 192
2. 100 cai entre 64 e 128 → bloco que começa em 64
3. Endereço de rede: 192.168.1.64
4. Broadcast:        192.168.1.127   (128 − 1)
5. Faixa utilizável: 192.168.1.65 até 192.168.1.126

Sem calculadora, no papel, em 30 segundos.

4. IPv6 — o futuro que já chegou

O IPv4 tem ~4,3 bilhões de endereços, que já acabaram. O IPv6 usa 128 bits: são 340 undecilhões de endereços. Notação: 8 grupos de 4 dígitos hexadecimais separados por dois-pontos.

2001:0db8:0000:0000:0000:ff00:0042:8329
Encurtando (zeros à esquerda somem; sequência zerada vira :: uma vez):
2001:db8::ff00:42:8329
Loopback IPv6 = ::1   (equivale ao 127.0.0.1)

5. ARP — a "cola" entre IP e MAC

Você sabe o nome da pessoa (IP), mas para entregar algo na mão dela precisa saber em que mesa ela está sentada (o MAC físico da placa). ARP é gritar na sala: "Quem tem o IP 192.168.0.1? Me passa seu endereço físico!" Opera na rede local (mesma sub-rede), camada 2: um host manda um ARP Request em broadcast, o dono responde com ARP Reply, e o resultado fica na tabela ARP (cache).

arp -a       # Windows e Linux
ip neigh     # Linux moderno

6. DHCP — quem distribui os IPs

Chegou num hotel (a rede): na recepção (servidor DHCP) você recebe número do quarto (IP), planta (gateway e máscara), lista telefônica (DNS) e por quanto tempo pode ficar (lease). O processo DORA:

1. Discover     cliente grita: "tem algum servidor DHCP aí?"
2. Offer        servidor: "tenho, pega esse IP 192.168.0.50"
3. Request      cliente: "aceito esse IP"
4. Acknowledge  servidor: "confirmado, é seu por X horas (lease)"

7. DNS — a agenda de contatos da internet

Você não decora o telefone de todo mundo; tem os nomes na agenda e o celular traduz na hora. DNS traduz google.com em 142.250.x.x. A resolução recursiva: seu PC pergunta ao resolver (ex.: 8.8.8.8); se ele não souber, pergunta aos servidores raiz → TLD (.br) → autoritativo; a resposta volta e fica em cache por um tempo (TTL).

dig google.com A         # registro A
dig google.com MX        # servidores de e-mail
dig -x 8.8.8.8           # reverso: IP → nome
nslookup google.com      # alternativa (Windows/Linux)

8. NAT — uma rede inteira sai com um IP só

Um prédio comercial tem um único endereço na rua (IP público), mas dezenas de salas (IPs privados). A recepção (roteador com NAT) anota "a resposta do pedido nº 4521 é da sala 305". No PAT (o NAT de casa), o roteador troca o IP de origem pelo público e anota a tradução numa tabela, usando a porta para diferenciar cada conexão. Por isso a casa inteira navega com um IP público só.

9. Roteamento — como o pacote acha o caminho

Você viaja sem GPS: em cada cruzamento (roteador) há uma placa "para tal destino, siga por aqui". Cada roteador só conhece o próximo passo (hop by hop). Conceitos: tabela de roteamento (lista de "para chegar em tal rede, mande por tal caminho"); gateway padrão (a rota 0.0.0.0/0); roteamento estático (na mão) e dinâmico (OSPF, BGP, EIGRP).

ip route          # Linux         traceroute google.com  # Linux/Mac
route print       # Windows       tracert google.com     # Windows
netstat -rn       # ambos

Cada linha do traceroute é um roteador (hop) no caminho.

10. VLANs — segmentação lógica

Um switch é um andar aberto com várias mesas; uma VLAN é colocar divisórias invisíveis: mesmo no mesmo móvel físico, o RH só "enxerga" o RH. Como funciona (802.1Q): cada VLAN tem um número (VLAN ID, 1 a 4094); ao atravessar entre switches, o quadro ganha uma etiqueta (tag) com o VLAN ID. Portas access pertencem a uma VLAN só; portas trunk carregam várias.

11. Camada de Transporte — TCP vs UDP

É a camada onde vivem as portas e onde a maioria das ferramentas de scan atua.

O Three-Way Handshake do TCP (memorize)

Cliente                          Servidor
   | ---- SYN --------------------> |   "quero conectar" (seq x)
   | <--- SYN + ACK --------------- |   "ok, e eu também" (confirma x, envia y)
   | ---- ACK --------------------> |   "confirmado" (confirma y)
   |                                |
   |  == conexão estabelecida ==    |

O encerramento usa FIN/ACK (four-way).

As flags TCP (os "sinais" dentro do pacote)

Portas — o "número da sala" dentro do host

O IP leva o pacote até a máquina; a porta leva até o serviço certo. Faixas: 0–1023 well-known (22 SSH, 25 SMTP, 53 DNS, 80 HTTP, 443 HTTPS, 3389 RDP); 1024–49151 registradas; 49152–65535 dinâmicas/efêmeras.

ss -tulpn       # Linux (t=tcp, u=udp, l=listening, p=processo, n=numérico)
netstat -tulpn  # clássico
netstat -ano    # Windows (mostra PID)

Como isso vira scan de porta (Nmap)

SYN Scan (-sS): manda SYN e vê a resposta. SYN+ACK = aberta; RST = fechada. Não completa o handshake (não manda o ACK final): é o "half-open", mais furtivo. Connect Scan (-sT): completa o handshake inteiro (mais barulhento, mais logado). UDP Scan (-sU): mais lento e incerto, porque UDP não responde de forma confiável.

12. HTTP e HTTPS — a camada de aplicação mais atacada

HTTP é texto puro, pergunta-e-resposta: o cliente manda um request, o servidor devolve um response.

Cabeçalhos carregam informação extra: User-Agent (navegador), Cookie (sessão), Authorization (credenciais), Host (qual site), Content-Type (formato). No HTTP puro tudo trafega em texto claro: num MITM, qualquer um lê senhas e cookies. HTTPS = HTTP + TLS: o conteúdo continua HTTP, mas ninguém no meio consegue ler.

13. TLS — como a criptografia da web funciona

Você e um amigo querem trocar mensagens secretas num café cheio: primeiro combinam uma chave em segredo, depois conversam nessa "língua cifrada". TLS resolve o problema difícil: combinar a chave secreta na frente de todo mundo, sem que ninguém no meio a descubra.

1. ClientHello      "olá, suporto estas versões e cifras"
2. ServerHello + Certificado   servidor escolhe a cifra e envia o
   certificado (chave pública assinada por uma CA)
3. Validação        cliente confere se a CA é confiável e o cert é válido
4. Troca de chaves  os dois combinam uma chave de sessão simétrica
5. Conversa criptografada com essa chave rápida (simétrica)

Cadeia de confiança: uma CA (Let's Encrypt, DigiCert) assina o certificado; seu SO/navegador já confia nessas CAs. Você confia na CA → a CA garante o site.

14. VPN — o túnel seguro

Transportar documentos sigilosos por uma estrada pública cheia de bandidos: a VPN é um túnel blindado sobre essa estrada. O mundo vê que "algo" passa, mas não abre. O que ela faz: criptografa o tráfego, encapsula (tunneling) seus pacotes dentro de outros e faz parecer que você está na rede do outro lado.

15. Firewalls — o porteiro da rede

Um porteiro com uma lista de regras: "quem pode entrar, quem pode sair, para onde". Do mais simples ao mais esperto:

1. Packet Filter (stateless): olha cada pacote isoladamente (IP, porta, protocolo). Rápido, mas "burro", não lembra o contexto.
2. Stateful: mantém tabela de estados; sabe que "esse pacote de resposta pertence a uma conexão que EU deixei sair". Muito mais seguro.
3. Application Layer / Proxy: entende o protocolo (HTTP, DNS) e inspeciona o conteúdo.
4. Next-Generation (NGFW): stateful + DPI + identificação de aplicação + IPS + inspeção TLS. Padrão corporativo (FortiGate, Palo Alto).

Permitir  LAN (192.168.1.0/24) → qualquer : 443/TCP   (sair HTTPS)
Permitir  qualquer → DMZ_Web (10.0.0.5)   : 80,443    (acessar o site)
Negar     qualquer → qualquer             : qualquer  ← implicit deny

Regra de ouro: a última regra deve ser negar tudo. Permite-se explicitamente só o necessário; o resto é barrado. Menor privilégio aplicado à rede.

16. Caixa de ferramentas — os comandos que você vai usar

ping — "você está vivo?" (usa ICMP para testar conectividade e latência):

ping google.com
ping -c 4 8.8.8.8   # Linux: 4 pacotes só

Cuidado: muitos firewalls bloqueiam ICMP, então "não responde" ≠ "está desligado".

traceroute / tracert — "por onde eu passo?":

traceroute google.com   # Linux
tracert google.com      # Windows

dig / nslookup — "resolve esse nome para mim":

dig google.com A
dig google.com MX +short
dig -x 8.8.8.8          # reverso
nslookup google.com     # alternativa

netstat / ss — "quem está conectado nesta máquina?" (comando de ouro para investigação local):

ss -tulpn       # Linux (t/u tcp/udp, l listening, p processo, n numérico)
netstat -tulpn  # clássico
netstat -ano    # Windows (com PID)

Uma porta escutando que não deveria estar ali pode ser backdoor.

nmap — o canivete suíço do reconhecimento (descobre hosts, portas, serviços, versões e até o SO):

nmap 192.168.1.0/24          # hosts vivos na sub-rede
nmap -sS -p- 192.168.1.10    # SYN scan em todas as portas
nmap -sV 192.168.1.10        # detecta versão dos serviços
nmap -A 192.168.1.10         # agressivo: SO + versões + scripts
nmap -sU --top-ports 20 alvo # top 20 portas UDP

tcpdump — captura de pacotes na linha de comando (ideal para servidores sem interface):

tcpdump -i eth0                     # captura na interface eth0
tcpdump -i eth0 port 53             # só DNS
tcpdump -i eth0 host 192.168.1.10   # só de/para esse host
tcpdump -i eth0 -w captura.pcap     # salva para abrir no Wireshark
tcpdump -i eth0 'tcp[tcpflags] & tcp-syn != 0'   # só pacotes com flag SYN

Wireshark — o microscópio de pacotes. Filtros de exibição essenciais:

ip.addr == 192.168.1.10                    # tráfego de/para esse IP
tcp.port == 443                            # porta 443
http                                       # só HTTP
dns                                        # só DNS
tcp.flags.syn == 1 && tcp.flags.ack == 0   # só SYNs (achar scans)
tcp.analysis.retransmission                # retransmissões
ip.addr == 10.0.0.5 && dns                 # DNS daquele host (tunneling/C2)

Recurso matador: botão direito num pacote → "Follow → TCP Stream" remonta a conversa inteira (request e response completos, como um chat).

17. Fechando o ciclo — identificando comunicação suspeita

Ao olhar tráfego, um analista treina o olho para desvios do normal. Sinais clássicos de comunicação maliciosa:

• Beaconing: uma máquina interna fala com o mesmo IP externo em intervalos regulares (a cada 60s). Malware "batendo ponto" no C2.
• Exfiltração: volume grande de dados saindo para um destino incomum, especialmente fora do horário comercial.
• DNS anômalo: consultas a domínios aleatórios/recém-criados, ou subdomínios gigantes (tunneling).
• Portas não usuais: serviço escutando numa porta alta e estranha; conexão de saída para porta atípica.
• Handshakes que não fecham: enxurrada de SYN sem SYN+ACK (scan ou SYN flood).
• ARP inconsistente: MAC do gateway mudou, ou dois IPs com o mesmo MAC (MITM).
• Tráfego lateral inesperado: uma estação tentando se conectar a muitas outras (movimento lateral).

O fio condutor: você só reconhece o anormal se conhece o normal. O primeiro trabalho de quem defende uma rede é entender a linha de base (baseline) do tráfego dela.