Ataque e defesa em redes, nas suas próprias máquinas.Network attack and defence, on your own machines.

Antes de começarBefore you start

Esta nota é um laboratório: cada seção ensina uma ferramenta e termina num exercício com um resultado esperado explícito, para você saber se funcionou. A ideia é 80/20: as ferramentas que cobrem a maior parte do que um desenvolvedor precisa de redes e segurança no dia a dia, sem tentar ser um curso de pentest.This note is a lab: each section teaches one tool and ends with an exercise that states an explicit expected result, so you know whether it worked. The idea is 80/20: the tools that cover most of what a developer needs from networking and security day to day, without trying to be a pentest course.

O que você precisaWhat you need

• Uma máquina Linux: uma VM (VirtualBox/UTM/Multipass), WSL2 no Windows, ou um servidor de estudo na nuvem (veja a nota de AWS).A Linux machine: a VM (VirtualBox/UTM/Multipass), WSL2 on Windows, or a cloud study server (see the AWS note).
• Docker, para a seção de laboratório local (opcional nas outras seções).Docker, for the local-lab section (optional in the other sections).
• Um segundo dispositivo na mesma rede (celular, outro notebook) ajuda a ver o tráfego "de fora" em alguns exercícios, mas não é obrigatório.A second device on the same network (phone, another laptop) helps see traffic "from outside" in some exercises, but is not required.

Mapa da notaMap of this note

Sessões: TCP com estado, UDP sem estadoSessions: stateful TCP, stateless UDP

Uma sessão é o estado que duas pontas guardam sobre uma conversa em andamento: quem é o outro lado, o que já foi enviado, o que falta confirmar. TCP é stateful (com estado): abre uma conexão, numera os bytes, reenvia o que se perde. UDP é stateless (sem estado): cada pacote (datagrama) é independente, sem conexão nem garantia de entrega.A session is the state both ends keep about an ongoing conversation: who the other side is, what has been sent, what is still unacknowledged. TCP is stateful: it opens a connection, numbers the bytes, and resends what gets lost. UDP is stateless: each packet (datagram) is independent, with no connection and no delivery guarantee.

Por que isso importa na práticaWhy this matters in practice

Exercício: ver as duas coisas ao vivoExercise: see both live

ss -tn state established        # conexões TCP com sessão aberta agora (seu navegador, SSH...)
ss -un                          # "conexões" UDP: na verdade sockets locais, sem sessão de verdade
dig example.com                 # uma consulta DNS: um datagrama de ida, um de voltaCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: ss -tn mostra pares Local Address:Port / Peer Address:Port com estado ESTAB — isso é uma sessão TCP de verdade. ss -un mostra só sockets locais, sem "estado" de conexão, porque UDP não tem sessão no protocolo.Expected result: ss -tn shows Local Address:Port / Peer Address:Port pairs with state ESTAB — that is a real TCP session. ss -un shows only local sockets, with no connection "state", because UDP has no session in the protocol.

nmap: o que existe na redenmap: what exists on the network

nmap (Network Mapper) responde a pergunta mais básica de rede: o que existe, e o que está aberto? Ele manda pacotes de teste para um alvo e lê as respostas para descobrir hosts vivos, portas abertas e, às vezes, até a versão do serviço rodando nelas. É a primeira ferramenta que qualquer time de segurança roda contra os próprios sistemas, para ver o que um atacante veria de fora.nmap (Network Mapper) answers the most basic network question: what exists, and what is open? It sends test packets to a target and reads the replies to find live hosts, open ports and sometimes even the service version running on them. It is the first tool any security team runs against its own systems, to see what an attacker would see from outside.

InstalarInstall

sudo apt install nmap     # Debian/Ubuntu
sudo dnf install nmap     # Fedora
brew install nmap         # macOSCopiarCopyCopiadoCopiedFalhouFailed

Anatomia de um scan de portasAnatomy of a port scan

Exercício 1: escaneie a sua própria máquinaExercise 1: scan your own machine

nmap localhost                       # scan básico das 1000 portas mais comuns
nmap -p- localhost                   # TODAS as 65535 portas (mais lento)
nmap -sV localhost                   # tenta identificar a VERSÃO de cada serviço
nmap -O localhost                    # tenta adivinhar o sistema operacional (precisa de sudo)
sudo nmap -sS -p 1-1000 localhost    # SYN scan "silencioso", não completa a conexãoCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: uma lista como 22/tcp open ssh, 631/tcp open ipp (se você tem impressão compartilhada), ou "0 portas abertas" numa máquina bem fechada. Compare com ss -tulpn (nota de Linux): toda porta que o nmap mostra como aberta deve aparecer também ali, do lado do servidor.Expected result: a list like 22/tcp open ssh, 631/tcp open ipp (if you have printer sharing), or "0 open ports" on a well-closed machine. Compare it with ss -tulpn (Linux note): every port nmap shows as open should also show up there, from the server side.

Exercício 2: escaneie um contêiner DockerExercise 2: scan a Docker container

docker run -d --name web -p 8080:80 nginx
nmap -p 8080 localhost               # a porta publicada
nmap localhost                       # as outras portas do HOST continuam aparecendo, a 80 do container nãoCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: só a porta 8080 aparece aberta (a publicada com -p); a 80 "de dentro" do contêiner não aparece, porque o nmap, rodando no host, só enxerga a interface do host, não a rede interna do Docker. A seção sobre Docker mais abaixo explica por quê.Expected result: only port 8080 shows as open (the one published with -p); the container's internal 80 does not show up, because nmap, running on the host, only sees the host's interface, not Docker's internal network. The Docker section below explains why.

Opções do dia a diaEveryday options

SSH como ferramenta de redeSSH as a network tool

A nota de Linux já cobre chaves e sshd_config. Aqui o foco é usar o SSH como ferramenta de rede: um túnel cifrado que você pode usar para alcançar serviços que, de outro jeito, não exporia.The Linux note already covers keys and sshd_config. Here the focus is using SSH as a network tool: an encrypted tunnel you can use to reach services that would otherwise not be exposed.

Exercício: um túnel de verdadeExercise: a real tunnel

# no "servidor" (pode ser uma segunda VM, ou um contêiner com sshd):
docker run -d --name srv -p 2222:22 -p 127.0.0.1:8081:80 linuxserver/openssh-server \
  -e PASSWORD_ACCESS=true -e USER_PASSWORD=estudo -e USER_NAME=ana
docker exec srv apk add --no-cache python3 2>/dev/null || true
docker exec -d srv python3 -m http.server 80

# no seu notebook: abra o túnel
ssh -p 2222 -L 9000:localhost:8081 ana@localhost   # senha: estudo

# numa SEGUNDA aba, com o túnel ainda aberto:
curl http://localhost:9000CopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o curl retorna a página servida por python3 -m http.server dentro do contêiner, mesmo que a porta 80 dele só esteja ligada ao localhost interno — porque o túnel SSH carrega o tráfego da sua porta 9000 até lá. Feche o SSH (Ctrl+C) e repita o curl: agora falha, porque o túnel não existe mais.Expected result: curl returns the page served by python3 -m http.server inside the container, even though its port 80 is only bound to its internal localhost — because the SSH tunnel carries the traffic from your port 9000 there. Close SSH (Ctrl+C) and repeat the curl: it now fails, because the tunnel no longer exists.

As três formas de encaminhamentoThe three kinds of forwarding

VPN e WireGuard: hospede a suaVPN and WireGuard: host your own

Uma VPN (Virtual Private Network) estende uma rede privada pela internet: o tráfego entra cifrado num ponto e sai do outro lado como se estivesse dentro da rede remota. WireGuard é a forma moderna de fazer isso: um protocolo enxuto (poucos milhares de linhas, contra centenas de milhares do OpenVPN/IPsec), baseado em criptografia de chave pública, que vira uma interface de rede comum (wg0). É simples o bastante para você hospedar a sua própria VPN em minutos.A VPN (Virtual Private Network) extends a private network across the internet: traffic goes in encrypted at one point and comes out the other side as if it were inside the remote network. WireGuard is the modern way to do this: a lean protocol (a few thousand lines, versus hundreds of thousands for OpenVPN/IPsec), based on public-key cryptography, that shows up as an ordinary network interface (wg0). It is simple enough that you can host your own VPN in minutes.

Exercício: hospede a sua própria VPNExercise: host your own VPN

No seu servidor (uma VM de estudo na nuvem, ou uma VM local — veja a nota de AWS para subir uma de graça/baixo custo):On your server (a cloud study VM, or a local VM — see the AWS note to spin one up cheaply):

# SERVIDOR
sudo apt install wireguard
umask 077   # garante que as chaves nasçam só legíveis pelo dono
wg genkey | tee server.key | wg pubkey > server.pub
cat server.key   # guarde: vai no [Interface] do servidor
cat server.pub   # guarde: vai no [Peer] do notebook

sudo sysctl -w net.ipv4.ip_forward=1    # deixa o servidor RETRANSMITIR pacotes (só até o reboot; o projeto abaixo grava em /etc/sysctl.d)CopiarCopyCopiadoCopiedFalhouFailed

Arquivo de configuração do servidor:The server’s configuration file:

# /etc/wireguard/wg0.conf  (servidor)
[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = <conteúdo de server.key>

[Peer]                      # um bloco [Peer] para cada cliente
PublicKey = <conteúdo de laptop.pub>
AllowedIPs = 10.8.0.2/32    # só este IP da VPN vem desse peerCopiarCopyCopiadoCopiedFalhouFailed

sudo wg-quick up wg0                    # sobe a interface
sudo systemctl enable wg-quick@wg0      # liga no boot
sudo wg show                            # confirma: peer, handshake, transferênciaCopiarCopyCopiadoCopiedFalhouFailed

No seu notebook (o cliente):On your laptop (the client):

# NOTEBOOK
wg genkey | tee laptop.key | wg pubkey > laptop.pub
# copie laptop.pub para o bloco [Peer] do servidor (acima) e reinicie: sudo wg-quick down wg0 && sudo wg-quick up wg0CopiarCopyCopiadoCopiedFalhouFailed

# /etc/wireguard/wg0.conf  (notebook)
[Interface]
Address = 10.8.0.2/24
PrivateKey = <conteúdo de laptop.key>

[Peer]
PublicKey = <conteúdo de server.pub>
Endpoint = SEU_IP_PUBLICO:51820
AllowedIPs = 10.8.0.0/24    # só a rede da VPN passa pelo túnel (não TUDO)
PersistentKeepalive = 25    # mantém o NAT "vivo" (lembra: UDP não tem sessão!)CopiarCopyCopiadoCopiedFalhouFailed

sudo wg-quick up wg0
ping 10.8.0.1                 # chega ao servidor pela VPN?
sudo wg show                  # "latest handshake" recente = funcionandoCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: ping 10.8.0.1 responde, e sudo wg show mostra um latest handshake de segundos atrás nos dois lados. Se não houver handshake, confira: porta 51820/UDP liberada no firewall e no grupo de segurança da nuvem, ip_forward ligado no servidor, e se as chaves públicas foram trocadas corretamente (a pública do notebook no servidor, e vice-versa).Expected result: ping 10.8.0.1 replies, and sudo wg show shows a latest handshake from seconds ago on both sides. If there is no handshake, check: port 51820/UDP open in the firewall and the cloud security group, ip_forward on at the server, and whether the public keys were exchanged correctly (the laptop’s public key on the server, and vice versa).

Para que serve de verdade: usar fora de casa, em Wi-Fi públicoWhat it is really for: using it away from home, on public Wi-Fi

Um Wi-Fi de aeroporto, cafeteria ou hotel é uma rede que você não controla: qualquer outro cliente nela pode tentar capturar seu tráfego (o mesmo tcpdump/Wireshark da seção anterior, só que operado por outra pessoa) ou criar um ponto de acesso falso com o mesmo nome ("evil twin"). Ligar a VPN antes de usar essa rede resolve isso: todo o seu tráfego sai cifrado do seu aparelho até o SEU servidor, então quem está no Wi-Fi local só vê bytes WireGuard sem sentido, exatamente como a captura da porta 443 na seção de Wireshark.Airport, coffee-shop or hotel Wi-Fi is a network you do not control: any other client on it can try to capture your traffic (the same tcpdump/Wireshark from the previous section, just run by someone else) or stand up a fake access point with the same name (an "evil twin"). Turning the VPN on before using that network fixes this: all your traffic leaves your device encrypted all the way to YOUR server, so whoever is on the local Wi-Fi only sees meaningless WireGuard bytes, exactly like the port-443 capture in the Wireshark section.

Configurar o celular (com QR code)Setting up your phone (with a QR code)

# no SERVIDOR: gere a config completa de um novo peer "celular" e mostre como QR code
sudo apt install qrencode
wg genkey | tee celular.key | wg pubkey > celular.pub

cat > celular.conf <<EOF
[Interface]
Address = 10.8.0.3/24
PrivateKey = $(cat celular.key)
DNS = 10.8.0.1                       # veja "sem vazar DNS" abaixo

[Peer]
PublicKey = $(cat server.pub)
Endpoint = SEU_IP_PUBLICO:51820
AllowedIPs = 0.0.0.0/0, ::/0          # TUNEL COMPLETO: todo o tráfego do celular
PersistentKeepalive = 25
EOF

qrencode -t ansiutf8 < celular.conf    # mostra o QR no próprio terminal
# adicione o peer no servidor (bloco [Peer] com celular.pub e AllowedIPs = 10.8.0.3/32) e recarregue o wg0CopiarCopyCopiadoCopiedFalhouFailed

Abra o app oficial WireGuard (Android/iOS), toque em "+", escaneie o QR do terminal, e pronto: um toque liga e desliga a VPN. Para o notebook, use AllowedIPs = 0.0.0.0/0 do mesmo jeito no lugar de 10.8.0.0/24 (o exemplo principal desta seção usava a faixa menor de propósito, para separar "túnel completo" de "só a rede da VPN").Open the official WireGuard app (Android/iOS), tap "+", scan the QR code from the terminal, and that's it: one tap turns the VPN on and off. For a laptop, use AllowedIPs = 0.0.0.0/0 the same way in place of 10.8.0.0/24 (this section's main example used the smaller range on purpose, to keep "full tunnel" separate from "just the VPN network").

Sem vazar DNSWithout leaking DNS

Se o AllowedIPs manda todo o TRÁFEGO pela VPN mas o aparelho continua perguntando o DNS do Wi-Fi local "qual o IP de banco.com?", o dono daquele Wi-Fi ainda vê quais sites você visita — isso é um vazamento de DNS. A linha DNS = 10.8.0.1 na config do cliente resolve isso, desde que o servidor tenha um resolvedor DNS escutando na VPN.If AllowedIPs sends all TRAFFIC through the VPN but the device still asks the local Wi-Fi "what is banco.com's IP?", whoever owns that Wi-Fi can still see which sites you visit — that is a DNS leak. The DNS = 10.8.0.1 line in the client config fixes this, as long as the server has a DNS resolver listening on the VPN.

# no SERVIDOR: um resolvedor simples, só para a rede da VPN
sudo apt install unbound
echo 'interface: 10.8.0.1' | sudo tee -a /etc/unbound/unbound.conf.d/wg.conf
echo 'access-control: 10.8.0.0/24 allow' | sudo tee -a /etc/unbound/unbound.conf.d/wg.conf
sudo systemctl restart unbound

# teste de vazamento, dos dois lados
dig @10.8.0.1 example.com            # pelo resolvedor da VPN: deve responder
cat /etc/resolv.conf                 # no cliente, depois de subir o túnel: deve apontar para 10.8.0.1CopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: com a VPN ligada, abra dnsleaktest.com num navegador: os servidores de DNS listados devem ser os do SEU servidor (ou do provedor que ele usa), nunca os do Wi-Fi em que você está.Expected result: with the VPN on, open dnsleaktest.com in a browser: the DNS servers listed should be YOUR server's (or whatever provider it uses), never the Wi-Fi's you are on.

Kill switch: não deixar vazar se a VPN cairKill switch: don't leak if the VPN drops

Com túnel completo, se o WireGuard cair por um instante (trocou de rede, o app travou), o sistema operacional pode voltar a mandar tráfego direto pela rede local sem avisar. Um kill switch é uma regra de firewall que só libera saída pela interface wg0 (e descarta o resto), então, se o túnel cai, a internet para de funcionar em vez de vazar.With a full tunnel, if WireGuard drops for a moment (you switched networks, the app froze), the operating system may fall back to sending traffic directly over the local network without warning. A kill switch is a firewall rule that only allows outbound traffic through the wg0 interface (and drops the rest), so if the tunnel drops, the internet stops working instead of leaking.

# /etc/wireguard/wg0.conf (notebook) — bloco [Interface], regras extras
[Interface]
Address = 10.8.0.2/24
PrivateKey = <conteúdo de laptop.key>
DNS = 10.8.0.1
PostUp = iptables -I OUTPUT ! -o %i -m mark ! --mark $(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT
PostDown = iptables -D OUTPUT ! -o %i -m mark ! --mark $(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECTCopiarCopyCopiadoCopiedFalhouFailed

WireGuard gerenciadoManaged WireGuard

Quando configurar à mão em vários dispositivos cansa, wg-easy (um contêiner com painel web) e Tailscale/Netbird (redes "mesh" sobre WireGuard, com login por conta) resolvem a parte chata de distribuir chaves. Internamente, todos usam o mesmo protocolo que você acabou de configurar à mão.When configuring by hand on several devices gets old, wg-easy (a container with a web panel) and Tailscale/Netbird (WireGuard-based "mesh" networks with account login) solve the tedious part of distributing keys. Internally, all of them use the same protocol you just configured by hand.

Projeto: sua VPN com escolha de país (estilo ProtonVPN)Project: your own VPN with a country picker (ProtonVPN-style)

Serviços como o ProtonVPN deixam você escolher um país e passar a navegar com o IP de lá, por um túnel cifrado. Dá para montar o mesmo princípio com peças abertas: WireGuard (o túnel), iptables (o NAT que troca o seu IP) e unbound (o DNS), em um servidor pequeno por país numa nuvem. Esta seção é um projeto passo a passo, com scripts prontos, e termina com testes que provam que o IP mudou e que nada vaza.Services like ProtonVPN let you pick a country and browse with an IP from there, through an encrypted tunnel. You can build the same principle from open parts: WireGuard (the tunnel), iptables (the NAT that swaps your IP) and unbound (the DNS), on one small server per country in a cloud. This section is a step-by-step project with ready-made scripts, and it ends with tests that prove the IP changed and that nothing leaks.

O que vamos construir e como se comparaWhat we are building and how it compares

A peça que faltava: o NAT no servidorThe missing piece: NAT on the server

Ligar o ip_forward só deixa o servidor retransmitir pacotes. Mas o seu notebook tem um IP privado da VPN (10.8.0.2), que a internet não sabe rotear de volta. O servidor precisa reescrever a origem de cada pacote para o IP público dele: isso é o MASQUERADE, o mesmo NAT que o seu roteador doméstico faz. Sem essa regra o handshake funciona e o ping 10.8.0.1 responde, mas nenhum site abre. É também por isso que o IP "muda": o site vê o servidor, não você.Turning on ip_forward only lets the server relay packets. But your laptop has a private VPN IP (10.8.0.2) that the internet cannot route back to. The server has to rewrite each packet’s source to its own public IP: that is MASQUERADE, the same NAT your home router does. Without this rule the handshake works and ping 10.8.0.1 replies, but no website opens. It is also why your IP "changes": the site sees the server, not you.

Passo 1 — Suba um servidor por paísStep 1 — Spin up one server per country

Para cada país que quiser, crie uma VM pequena (1 vCPU e 512 MB a 1 GB de RAM bastam para uso pessoal) com Ubuntu 24.04 LTS, na região desse país. Os nomes de região abaixo são os da AWS; outros provedores têm equivalentes.For each country you want, create a small VM (1 vCPU and 512 MB to 1 GB of RAM is plenty for personal use) running Ubuntu 24.04 LTS, in that country’s region. The region names below are AWS’s; other providers have equivalents.

• IP fixo: reserve um IP estático (na AWS, um Elastic IP). Sem isso o IP público muda quando a VM é parada e religada, e o Endpoint dos seus perfis para de funcionar.Fixed IP: reserve a static IP (on AWS, an Elastic IP). Without it the public IP changes when the VM is stopped and started, and your profiles’ Endpoint stops working.
• Firewall da nuvem (security group): libere UDP 51820 de qualquer origem, e TCP 22 (SSH) só do seu IP.Cloud firewall (security group): allow UDP 51820 from anywhere, and TCP 22 (SSH) only from your IP.
• Se usar ufw no servidor: sudo ufw allow 51820/udp. As regras de FORWARD do script entram antes das do ufw.If you use ufw on the server: sudo ufw allow 51820/udp. The script’s FORWARD rules go in ahead of ufw’s.

Passo 2 — O script do servidor (rode em cada um)Step 2 — The server script (run it on each one)

Entre por SSH no servidor, salve o script abaixo como setup-vpn-server.sh e rode com sudo bash setup-vpn-server.sh. Ele instala tudo, cria a chave, liga o encaminhamento de forma permanente, configura o NAT (IPv4 e IPv6), sobe o DNS e deixa o WireGuard ligando sozinho no boot. Pode rodar de novo sem apagar seus peers.SSH into the server, save the script below as setup-vpn-server.sh and run it with sudo bash setup-vpn-server.sh. It installs everything, creates the key, turns on forwarding permanently, sets up the NAT (IPv4 and IPv6), starts the DNS and makes WireGuard start on boot. You can re-run it without wiping your peers.

#!/usr/bin/env bash
# setup-vpn-server.sh — rode UMA vez em cada servidor (um por país): sudo bash setup-vpn-server.sh
set -euo pipefail
[ "$(id -u)" -eq 0 ] || { echo "rode com sudo"; exit 1; }

# interface de saída para a internet (eth0, ens5, enp1s0...)
WAN=$(ip -o -4 route show to default | awk '{print $5}' | head -n1)
echo "interface de saída: $WAN"

apt-get update
apt-get install -y wireguard unbound qrencode

umask 077
mkdir -p /etc/wireguard
[ -f /etc/wireguard/server.key ] || wg genkey | tee /etc/wireguard/server.key | wg pubkey > /etc/wireguard/server.pub

# encaminhar pacotes: agora PERMANENTE (sobrevive ao reboot)
cat > /etc/sysctl.d/99-wg.conf <<EOF
net.ipv4.ip_forward=1
net.ipv6.conf.all.forwarding=1
EOF
sysctl --system > /dev/null

# configuração do WireGuard: só cria se ainda não existir (não apaga seus peers)
if [ ! -f /etc/wireguard/wg0.conf ]; then
cat > /etc/wireguard/wg0.conf <<EOF
[Interface]
Address = 10.8.0.1/24, fd42:42:42::1/64
ListenPort = 51820
PrivateKey = $(cat /etc/wireguard/server.key)

# NAT: troca o IP de origem pelo IP público deste servidor
PostUp = iptables  -t nat -A POSTROUTING -s 10.8.0.0/24 -o $WAN -j MASQUERADE
PostUp = ip6tables -t nat -A POSTROUTING -s fd42:42:42::/64 -o $WAN -j MASQUERADE
# deixa passar o tráfego da VPN para fora e as respostas de volta
PostUp = iptables  -I FORWARD -i %i -j ACCEPT
PostUp = iptables  -I FORWARD -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
PostUp = ip6tables -I FORWARD -i %i -j ACCEPT
PostUp = ip6tables -I FORWARD -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

PostDown = iptables  -t nat -D POSTROUTING -s 10.8.0.0/24 -o $WAN -j MASQUERADE
PostDown = ip6tables -t nat -D POSTROUTING -s fd42:42:42::/64 -o $WAN -j MASQUERADE
PostDown = iptables  -D FORWARD -i %i -j ACCEPT
PostDown = iptables  -D FORWARD -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
PostDown = ip6tables -D FORWARD -i %i -j ACCEPT
PostDown = ip6tables -D FORWARD -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
EOF
fi

# DNS próprio, só para a VPN (ip-freebind: sobe mesmo antes do wg0 existir)
cat > /etc/unbound/unbound.conf.d/wg.conf <<EOF
server:
    interface: 10.8.0.1
    access-control: 10.8.0.0/24 allow
    ip-freebind: yes
EOF
systemctl enable --now unbound
systemctl restart unbound

systemctl enable --now wg-quick@wg0

echo
echo "Pronto. Chave PÚBLICA deste servidor (vai nos perfis do cliente):"
cat /etc/wireguard/server.pubCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o script termina imprimindo a chave pública do servidor. Anote essa chave e o IP público de cada servidor. Confira: sudo wg show mostra a interface wg0 escutando na porta 51820; sudo iptables -t nat -S POSTROUTING lista a regra MASQUERADE; dig @10.8.0.1 example.com responde.Expected result: the script ends by printing the server’s public key. Write down that key and the public IP of each server. Check: sudo wg show shows the wg0 interface listening on port 51820; sudo iptables -t nat -S POSTROUTING lists the MASQUERADE rule; dig @10.8.0.1 example.com answers.

Passo 3 — Uma chave de cliente, registrada em todos os servidoresStep 3 — One client key, registered on every server

Truque que simplifica tudo: o notebook tem um único par de chaves e a mesma chave pública é cadastrada nos servidores de todos os países. Assim cada perfil só difere no Endpoint e na chave pública do servidor. A chave privada nunca sai do notebook.A trick that simplifies everything: the laptop has a single key pair and the same public key is registered on the servers of every country. That way each profile only differs in the Endpoint and the server’s public key. The private key never leaves the laptop.

# NO NOTEBOOK (uma vez só)
mkdir -p ~/vpn && cd ~/vpn
umask 077
wg genkey | tee laptop.key | wg pubkey > laptop.pub
cat laptop.pub        # copie esta chave públicaCopiarCopyCopiadoCopiedFalhouFailed

Em cada servidor, salve e rode o script que cadastra o notebook como peer (o último argumento é o final do IP dele na VPN: 2 para o notebook, 3 para o celular, e assim por diante):On each server, save and run the script that registers the laptop as a peer (the last argument is the end of its VPN IP: 2 for the laptop, 3 for the phone, and so on):

#!/usr/bin/env bash
# add-peer.sh NOME CHAVE_PUBLICA_DO_CLIENTE N (N = final do IP do cliente: 2, 3, 4...)
# exemplo: sudo bash add-peer.sh notebook 'AbC...=' 2
set -euo pipefail
NAME=$1; PUB=$2; N=$3

# vale já, sem derrubar ninguém...
wg set wg0 peer "$PUB" allowed-ips 10.8.0.$N/32,fd42:42:42::$N/128
# ...e fica gravado para o próximo reboot
cat >> /etc/wireguard/wg0.conf <<EOF

[Peer]  # $NAME
PublicKey = $PUB
AllowedIPs = 10.8.0.$N/32, fd42:42:42::$N/128
EOF
echo "peer $NAME adicionado: 10.8.0.$N"CopiarCopyCopiadoCopiedFalhouFailed

# em cada servidor, depois de salvar o script como add-peer.sh:
sudo bash add-peer.sh notebook 'COLE_AQUI_O_CONTEUDO_DE_laptop.pub' 2CopiarCopyCopiadoCopiedFalhouFailed

Passo 4 — Um perfil por país e o comando vpnStep 4 — One profile per country and the vpn command

No notebook, gere um perfil por servidor. O script já traz o kill switch (também para IPv6) e o DNS do servidor:On the laptop, generate one profile per server. The script already includes the kill switch (IPv6 too) and the server’s DNS:

#!/usr/bin/env bash
# make-profile.sh PAIS IP_DO_SERVIDOR CHAVE_PUBLICA_DO_SERVIDOR [N]
# exemplo: bash make-profile.sh de 203.0.113.10 'XyZ...=' -> /etc/wireguard/de.conf
set -euo pipefail
CC=$1; ENDPOINT=$2; SERVER_PUB=$3; N=${4:-2}

umask 077
sudo tee /etc/wireguard/$CC.conf > /dev/null <<EOF
[Interface]
Address = 10.8.0.$N/24, fd42:42:42::$N/64
PrivateKey = $(cat ~/vpn/laptop.key)
DNS = 10.8.0.1
# kill switch: sem o túnel, sem internet (IPv4 e IPv6)
PostUp = iptables  -I OUTPUT ! -o %i -m mark ! --mark \$(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT
PostUp = ip6tables -I OUTPUT ! -o %i -m mark ! --mark \$(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT
PostDown = iptables  -D OUTPUT ! -o %i -m mark ! --mark \$(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT
PostDown = ip6tables -D OUTPUT ! -o %i -m mark ! --mark \$(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT

[Peer]
PublicKey = $SERVER_PUB
Endpoint = $ENDPOINT:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25
EOF
echo "perfil criado: /etc/wireguard/$CC.conf"CopiarCopyCopiadoCopiedFalhouFailed

# um perfil por país (IP e chave pública que você anotou no Passo 2)
bash make-profile.sh br  IP_DO_SERVIDOR_BR  'CHAVE_PUBLICA_BR='
bash make-profile.sh de  IP_DO_SERVIDOR_DE  'CHAVE_PUBLICA_DE='
bash make-profile.sh us  IP_DO_SERVIDOR_US  'CHAVE_PUBLICA_US='CopiarCopyCopiadoCopiedFalhouFailed

O nome do arquivo vira o nome da interface (br, de, us), e é isso que seleciona o país. Para trocar com um comando só, ponha esta função no ~/.bashrc (abra um terminal novo depois):The file name becomes the interface name (br, de, us), and that is what selects the country. To switch with one command, put this function in ~/.bashrc (open a new terminal afterwards):

# ~/.bashrc — vpn de | vpn br | vpn us | vpn off
vpn() {
  for i in $(sudo wg show interfaces); do sudo wg-quick down "$i"; done
  [ "${1:-off}" = off ] || sudo wg-quick up "$1"
  curl -s -m 5 https://ipinfo.io/country || echo "sem VPN / sem rede"
}CopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: vpn de imprime DE; vpn br imprime BR; vpn off volta ao seu país de verdade. A troca derruba o túnel antigo e sobe o novo, então há uma janela de alguns segundos sem túnel durante a troca.Expected result: vpn de prints DE; vpn br prints BR; vpn off returns to your real country. Switching tears the old tunnel down and brings the new one up, so there is a window of a few seconds without a tunnel during the switch.

Passo 5 — Prove que funciona (e que não vaza)Step 5 — Prove it works (and does not leak)

Com vpn de ligado, faça cada teste. Um VPN que "parece" funcionar mas vaza é pior do que nenhum, porque dá falsa segurança.With vpn de on, run each test. A VPN that "seems" to work but leaks is worse than none, because it gives false security.

curl -s https://ipinfo.io            # IP e país: devem ser os do SERVIDOR (203.0.113.10, DE)
curl -6 -s -m 5 https://ifconfig.co  # IPv6: o IPv6 do servidor, ou ERRO. Nunca o seu IPv6 de casa
cat /etc/resolv.conf                 # DNS deve ser 10.8.0.1 (ou o stub do sistema apontando para ele)
resolvectl status | grep -i 'DNS Server'   # confirma o DNS ativo na interface

# kill switch: derrube o túnel SEM desligar o firewall
sudo ip link set de down
curl -m 5 https://ipinfo.io          # tem que FALHAR (timeout/recusado), não mostrar seu IP real
sudo ip link set de upCopiarCopyCopiadoCopiedFalhouFailed

Celular: um QR code por paísPhone: one QR code per country

No app oficial do WireGuard (Android/iOS) você pode ter vários túneis salvos e ligar o que quiser com um toque: um por país. Use outra chave para o celular, cadastre-a em cada servidor com add-peer.sh celular CHAVE 3, monte um .conf por servidor (como o da seção anterior, mas com Address = 10.8.0.3/24, fd42:42:42::3/64 e AllowedIPs = 0.0.0.0/0, ::/0) e gere um QR com qrencode -t ansiutf8 < br.conf. No celular, ative "Always-on VPN" / "Bloquear conexões sem VPN" para ter o kill switch do sistema.In the official WireGuard app (Android/iOS) you can save several tunnels and switch on whichever you want with one tap: one per country. Use a different key for the phone, register it on each server with add-peer.sh phone KEY 3, build one .conf per server (like the one in the previous section, but with Address = 10.8.0.3/24, fd42:42:42::3/64 and AllowedIPs = 0.0.0.0/0, ::/0) and generate a QR with qrencode -t ansiutf8 < br.conf. On the phone, turn on "Always-on VPN" / "Block connections without VPN" for the system kill switch.

Problemas comunsCommon problems

Limites: o que isso protege e o que não protegeLimits: what this protects and what it does not

Atalhos e alternativasShortcuts and alternatives

• Automatizar a criação: coloque o script do Passo 2 no user data / cloud-init da VM, e o servidor nasce pronto, sem SSH. Depois é só ler a chave pública (cat /etc/wireguard/server.pub) e cadastrar o cliente.Automating creation: put the Step 2 script in the VM’s user data / cloud-init and the server is born ready, with no SSH. Then just read the public key (cat /etc/wireguard/server.pub) and register the client.
• wg-easy: um contêiner com painel web que gera perfis e QR codes, em vez dos scripts de add-peer.sh/make-profile.sh. Você ainda precisa de um servidor por país.wg-easy: a container with a web panel that generates profiles and QR codes, instead of the add-peer.sh/make-profile.sh scripts. You still need one server per country.
• Tailscale com exit node: você escolhe qual máquina sua (por exemplo, a VM de cada país) vira a saída para a internet, sem abrir portas nem editar configs. Em troca, depende do serviço de coordenação deles.Tailscale with an exit node: you pick which of your machines (say, each country’s VM) becomes the way out to the internet, with no open ports and no config editing. In return, it depends on their coordination service.

Wireshark e tcpdump: ver os pacotesWireshark and tcpdump: seeing the packets

tcpdump captura pacotes no terminal; Wireshark faz o mesmo com uma interface gráfica para ler e filtrar o que foi capturado. Os dois leem a mesma coisa: os bytes que realmente passam pela sua placa de rede, camada por camada.tcpdump captures packets in the terminal; Wireshark does the same with a graphical interface to read and filter what was captured. Both read the same thing: the bytes that actually travel through your network card, layer by layer.

InstalarInstall

sudo apt install tcpdump wireshark termshark   # termshark = Wireshark no terminal
sudo usermod -aG wireshark $USER               # captura sem sudo (requer novo login)CopiarCopyCopiadoCopiedFalhouFailed

Exercício 1: ver um handshake TCPExercise 1: see a TCP handshake

sudo tcpdump -i any -n port 80 -c 20 &          # captura em segundo plano
curl -s http://example.com -o /dev/null
waitCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: três linhas com flags [S], [S.], [.] (o SYN, SYN-ACK, ACK da seção de sessões), depois pacotes [P.] com dados, e no fim [F.] de cada lado fechando a conexão. É o diagrama da seção "Sessões", agora em bytes de verdade.Expected result: three lines with flags [S], [S.], [.] (the SYN, SYN-ACK, ACK from the sessions section), then [P.] data packets, and at the end [F.] from each side closing the connection. It is the "Sessions" diagram, now in real bytes.

Exercício 2: texto puro vs. cifradoExercise 2: plain text vs. encrypted

sudo tcpdump -i any -n -A port 80 -c 30 &
curl -s http://neverssl.com -o /dev/null
wait
# compare:
sudo tcpdump -i any -n -A port 443 -c 30 &
curl -s https://example.com -o /dev/null
waitCopiarCopyCopiadoCopiedFalhouFailed

Filtros essenciaisEssential filters

tcpdump -i any -n port 53                               # equivalente em tcpdump
tcpdump -i any -n "tcp[13] & 2 != 0 and tcp[13] & 16 = 0"  # só SYN (sem ACK) — filtro cru de bits
sudo tcpdump -i any -w captura.pcap                      # salva para abrir no Wireshark depoisCopiarCopyCopiadoCopiedFalhouFailed

Firewall: medir a defesa com o nmapFirewall: measuring the defence with nmap

A nota de Linux explica a teoria do firewall. Aqui o exercício é fechar o laço: configurar uma regra e provar com o nmap que ela funciona, de fora para dentro.The Linux note explains the firewall theory. Here the exercise is to close the loop: set a rule and prove with nmap that it works, from the outside in.

Exercício: negar por padrão e medir com nmapExercise: deny by default and measure with nmap

# ANTES: confirme o que está aberto hoje
sudo ss -tulpn
nmap -p- localhost

# aplique uma política restritiva (ufw; veja a nota de Linux para nftables puro)
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp          # não se tranque fora se isto for remoto!
sudo ufw enable

# DEPOIS: meça de novo
nmap -p- localhostCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o segundo nmap -p- mostra só a porta 22 (ou as que você liberou de propósito); as outras aparecem como filtered em vez de open. Se alguma porta que você queria aberta sumiu, falta uma regra ufw allow para ela.Expected result: the second nmap -p- shows only port 22 (or whichever you opened on purpose); the others show as filtered instead of open. If a port you wanted open disappeared, it is missing a ufw allow rule.

ARP spoofing: se passar pelo roteador da sua própria redeARP spoofing: posing as your own network's router

ARP (Address Resolution Protocol) traduz um IP para o endereço MAC da placa de rede, numa LAN, mas não tem nenhuma autenticação: qualquer host pode anunciar "este IP é meu MAC" e os outros aceitam sem verificar. ARP spoofing (ou ARP poisoning) explora exatamente isso para se colocar no meio do tráfego de outra máquina — um ataque man-in-the-middle clássico, só dentro da sua própria LAN.ARP (Address Resolution Protocol) translates an IP into a network card's MAC address on a LAN, but has no authentication at all: any host can announce "this IP is mine" and others accept it without checking. ARP spoofing (or ARP poisoning) exploits exactly that to insert itself into another machine's traffic — a classic man-in-the-middle attack, just inside your own LAN.

Exercício: ver a tabela ARP mudarExercise: watch the ARP table change

# numa VM "vítima", confira a tabela ARP normal
ip neigh show                     # mostra IP, MAC, interface de cada vizinho conhecido

# numa segunda VM "atacante", na MESMA rede, instale o arpspoof (pacote dsniff)
sudo apt install dsniff
sudo arpspoof -i eth0 -t IP_DA_VITIMA IP_DO_ROTEADOR   # anuncia: "eu sou o roteador"

# de volta na vítima, enquanto o comando acima roda:
ip neigh show                     # o MAC associado ao IP do roteador mudou?CopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o MAC associado ao IP do roteador na tabela ARP da vítima passa a ser o MAC da máquina atacante, sem nenhum alerta visível — é exatamente por isso que o ataque funciona tão bem. Combine com o Wireshark da seção anterior (filtro arp) para ver os ARP replies forjados chegando repetidamente.Expected result: the MAC associated with the router's IP in the victim's ARP table becomes the attacker machine's MAC, with no visible warning — this is exactly why the attack works so well. Pair it with the Wireshark from the previous section (arp filter) to see the forged ARP replies arriving repeatedly.

Defesa: detectar e, onde possível, travarDefence: detect, and lock down where you can

sudo apt install arpwatch
sudo systemctl enable --now arpwatch
# gere o spoof de novo (exercício acima) e observe:
sudo journalctl -u arpwatch -f    # ou /var/log/syslog, dependendo da distroCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o arpwatch registra uma linha changed ethernet address para o IP do roteador, com o MAC antigo e o novo — o mesmo evento que, numa rede de verdade, dispararia um alerta para o time de segurança.Expected result: arpwatch logs a changed ethernet address line for the router's IP, with the old and new MAC — the same event that, on a real network, would fire an alert to the security team.

O kit de reconhecimento, com limitesThe recon kit, with limits

Um time de segurança (e um atacante) usa um kit pequeno e bem conhecido. Conhecer os nomes e para que servem já tira o mistério; usá-los de verdade exige sempre o mesmo limite: sistemas seus ou autorização explícita por escrito (um contrato de pentest, uma competição de CTF, um laboratório próprio).A security team (and an attacker) uses a small, well-known kit. Knowing the names and what they are for already removes the mystery; actually using them always requires the same boundary: your own systems or explicit written authorization (a pentest contract, a CTF competition, your own lab).

O único exercício seguro de "ataque": força bruta contra o seu próprio SSHThe one safe "attack" exercise: brute force against your own SSH

# no seu laboratório: veja as tentativas de login falharem, do lado do SERVIDOR
sudo journalctl -u ssh -f &
# de outro terminal, erre a senha de propósito algumas vezes
ssh ana@localhost   # digite qualquer coisa errada, 3x

# instale e observe o fail2ban reagir
sudo apt install fail2ban
sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshdCopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: o journal mostra Failed password para cada tentativa; depois de configurar o fail2ban (padrão: 5 tentativas), o IP some de fail2ban-client status sshd e entra na lista de banidos — tente de novo e a conexão nem completa o handshake TCP.Expected result: the journal shows Failed password for each attempt; after setting up fail2ban (default: 5 attempts), the IP shows up in fail2ban-client status sshd's ban list — try again and the connection does not even complete the TCP handshake.

Docker para o laboratório localDocker for the local lab

Para praticar com duas ou mais "máquinas" sem comprar duas máquinas, o jeito mais rápido é o Docker. Mas a rede de um contêiner não é a rede de uma máquina real, e isso confunde muita gente quando o laboratório não se comporta como esperado. Esta seção explica as duas, nessa ordem.To practice with two or more "machines" without buying two machines, the fastest way is Docker. But a container's network is not a real machine's network, and that confuses a lot of people when the lab does not behave as expected. This section explains both, in that order.

Sem Docker: como é numa máquina de verdadeWithout Docker: how it is on a real machine

Com Docker: uma rede inteira simulada dentro da sua máquinaWith Docker: a whole network simulated inside your machine

Laboratório: duas "máquinas" em contêineresLab: two "machines" in containers

mkdir lab-rede && cd lab-rede
cat > docker-compose.yml <<'EOF'
services:
  alvo:
    image: nginx
    networks: [lab]
  ferramentas:
    image: instrumentisto/nmap     # já vem com nmap, tcpdump, curl
    networks: [lab]
    command: sleep infinity
networks:
  lab:
    driver: bridge
EOF
docker compose up -d
docker compose exec ferramentas nmap alvo          # escaneia pelo NOME (o DNS embutido resolve)
docker compose exec ferramentas sh -c "nc -zv alvo 80 && echo OK"CopiarCopyCopiadoCopiedFalhouFailed

Resultado esperado: nmap alvo resolve o nome pelo DNS interno do Docker e mostra 80/tcp open, mesmo sem nenhum -p no docker-compose.yml — porque, dentro da rede lab, os contêineres se enxergam direto, sem precisar publicar porta nenhuma. Compare com o exercício de nmap da seção anterior, feito do HOST contra a porta publicada: são dois cenários diferentes, e é exatamente essa diferença que costuma confundir.Expected result: nmap alvo resolves the name through Docker's internal DNS and shows 80/tcp open, even with no -p at all in docker-compose.yml — because, inside the lab network, the containers see each other directly, with no port to publish. Compare this with the nmap exercise from the previous section, done from the HOST against the published port: these are two different scenarios, and that difference is exactly what usually trips people up.

Onde a simulação paraWhere the simulation stops

Use contêineres para aprender comandos e ler saídas sem custo. Para medir o que um atacante real veria — latência, firewall de verdade, uma rota pela internet — volte para uma VM real ou de nuvem (nota de AWS) de vez em quando.Use containers to learn commands and read output at no cost. To measure what a real attacker would see — latency, a real firewall, a route across the actual internet — go back to a real or cloud VM (AWS note) every so often.

Cola e revisãoCheat sheet and review

ColaCheat sheet

Perguntas de revisãoReview questions

Fontes recomendadasRecommended sources

Os livros abaixo aprofundam cada ferramenta desta nota.The books below go deeper into each tool in this note.