Evidência, Diagnóstico e Operação em Redes

Do "acho que funciona" ao "eu provo o que aconteceu"

Por Fábio Linhares • Instituto Infnet

TP 2 • 13.03.2026

Evidência antes de opinião

Estas questões não são "mais um TP de redes". Elas funcionam como um treino de postura técnica: sair do "rodei um comando e deu certo" e entrar no "eu provo o que aconteceu, com evidência mínima, coerente e cruzada". O desafio real não é decorar ferramentas. É aprender a raciocinar como operador de redes e de sistemas distribuídos: hipótese clara, teste controlado, artefato verificável e conclusão curta.

Ao longo do TP2, você terá de separar problema de aplicação, transporte, serviço, configuração e observabilidade. Também precisará montar experimentos pequenos e repetíveis, provar cada etapa sem achismo e escrever conclusões operacionais curtas, do tipo que um time de produção aceita. Se você resolver tudo com método, não terá apenas aprendido comandos: terá adquirido autonomia operacional para investigar rede e serviços com evidência forte, integrar sinais de múltiplas ferramentas e concluir de forma verificável.

Competências esperadas ao concluir o TP2
  1. Diagnóstico por camadas com evidência forte: separar falha de aplicação, transporte e serviço com prova observável.
  2. Leitura do plano de transporte: interpretar LISTEN, ESTABLISHED, endpoints e exposição em IPv4/IPv6.
  3. Correlação porta para processo: mapear socket para PID, processo e usuário com precisão operacional.
  4. Experimento controlado: montar laboratório mínimo com listener, cliente e validação reproduzível.
  5. Observabilidade de tráfego: usar captura de pacotes como evidência de verdade para confirmar ou negar hipóteses.
  6. Validação cruzada: combinar visão interna (ss/lsof) e externa (nmap) para fechar diagnóstico.
  7. Operação segura de SSH: mudar serviço crítico com backup, validação, teste e rollback.
  8. Produção de artefatos auditáveis: gerar traces, pcaps e trechos de saída úteis para revisão técnica.
  9. Comunicação técnica curta: escrever conclusões operacionais defensáveis em poucas linhas.
O objetivo final nao e "rodar todos os comandos"; e produzir uma narrativa curta em que cada evidencia confirma a mesma hipotese operacional.
Compatibilidade entre distribuicoes
1. O guia prioriza comandos portaveis entre Debian/Ubuntu, Arch e RHEL-like.
2. Onde houver variacao real, ela sera indicada no proprio exercicio.
3. Diferencas mais comuns aqui: nome do servico SSH (`ssh` vs `sshd`) e sintaxe/implementacao do `nc`.
4. Ferramentas como `ip`, `ss`, `lsof`, `curl`, `nmap` e `tcpdump` tendem a manter o mesmo fluxo entre distribuicoes.
Pre-voo por distribuicao
1. Instale apenas o que faltar no seu ambiente; varias destas ferramentas ja vem por padrao.
2. Em RHEL-like atual, use `dnf`; em imagens antigas, substitua por `yum`.
# Debian/Ubuntu
sudo apt install curl openssh-client openssh-server iproute2 lsof netcat-openbsd tcpdump nmap inetutils-telnet

# Arch
sudo pacman -S curl openssh iproute2 lsof openbsd-netcat tcpdump nmap inetutils

# RHEL-like
sudo dnf install curl openssh-clients openssh-server iproute lsof nmap-ncat tcpdump nmap telnet
EXERCÍCIO 01
Sessão TCP manual e resposta HTTP mínima
Objetivo: Provar conexão TCP, envio de requisição HTTP mínima e recebimento de resposta observável.

O objetivo aqui é mostrar, na prática, a diferença entre "abrir uma conexão" e "falar um protocolo de aplicação". Ao conectar manualmente à porta 80 com telnet, você demonstra que o transporte TCP está funcional. Ao digitar uma requisição HTTP mínima com linha GET, header Host e linha em branco final, você prova que o servidor não apenas aceitou a conexão, mas recebeu bytes interpretáveis como HTTP e respondeu com status e headers.

A evidência essencial deve conter três partes: sinal de conexão estabelecida, requisição enviada corretamente e resposta recebida. Se a conexão não abre, o problema tende a estar em rota, firewall ou porta. Se a conexão abre, mas a resposta é erro ou redirecionamento, o transporte funcionou e a análise passa a ser de aplicação.

telnet example.com 80

GET / HTTP/1.1
Host: example.com
Connection: close
[pressione Enter em branco para encerrar os headers]
Evidencia minima a copiar
1. Linha de conexao estabelecida no telnet (`Connected to ...`).
2. Status line HTTP (ex.: `HTTP/1.1 301 Moved Permanently`).
3. Pelo menos 3 headers de resposta (ex.: `Date: ...`, `Server: ...`, `Location: ...`).
4. Um trecho curto do body ou o header `Location` quando houver redirecionamento.
Conclusao (2-3 linhas) - modelo
A conexao TCP na porta 80 foi estabelecida e a requisicao HTTP minima foi aceita pelo servidor.
A resposta com status e headers prova que o transporte funcionou e que houve processamento na camada de aplicacao.
A linha em branco ao final dos headers nao e detalhe; ela encerra a requisicao HTTP e evita que o servidor fique esperando indefinidamente.
EXERCÍCIO 02
Curl com trace-ascii e comparação objetiva
Objetivo: Gerar artefatos verificáveis de uma requisição HTTP e comparar comportamentos distintos do cliente.

Neste exercício, o foco sai do terminal como tela momentânea e entra no território dos artefatos auditáveis. O parâmetro --trace-ascii permite registrar em arquivo o que o cliente enviou e recebeu, tornando o experimento reproduzível. A ideia não é copiar o trace inteiro, mas extrair sinais curtos: request line, alguns headers, status code e headers de resposta.

O valor técnico aparece quando você repete o teste com uma pequena mudança, como seguir redirects com -L. Nesse momento, o trace deixa de ser apenas registro e vira instrumento comparativo. Você passa a mostrar, com prova, que o comportamento do cliente mudou e que essa mudança alterou o destino ou o status final da interação.

curl --trace-ascii trace1.txt -o /dev/null -sS http://example.com/
ls -lh trace1.txt

curl -L --trace-ascii trace2.txt -o /dev/null -sS http://example.com/
ls -lh trace2.txt
Evidencia minima a copiar
1. De cada trace, extrair: request line, 3 headers enviados, status code e 3 headers recebidos.
2. Exemplo de recorte util: `GET / HTTP/1.1`, `Host: example.com`, `HTTP/1.1 301 ...`, `Location: ...`.
3. Artefato: registrar nome e tamanho de `trace1.txt` e `trace2.txt` com `ls -lh`.
Conclusao (2-4 linhas) - modelo
Sem `-L`, o trace mostra redirecionamento (ex.: 301 + `Location`).
Com `-L`, o cliente segue o destino e a resposta final muda (ex.: status 200 no endpoint final).
Use -o /dev/null para evitar poluir a evidencia com o corpo da resposta; o que importa aqui e o rastro operacional da conversa cliente-servidor.
EXERCÍCIO 03
SSH como serviço operável
Objetivo: Verificar estado do servico SSH, inspecionar configuracao efetiva e provar execucao remota no proprio host.

SSH não deve ser tratado como "programa para login", mas como serviço crítico de operação. Por isso, o exercício exige três verificações complementares: o processo está ativo, a configuração relevante está coerente e a execução remota realmente funciona. Esse trio evita confundir presença do cliente ssh com disponibilidade real do servidor sshd.

A leitura da configuração pode ser feita diretamente no arquivo, mas a forma mais robusta é consultar a configuração efetiva. Em seguida, a execução de um comando remoto em localhost fecha o ciclo: o serviço está ativo, configurado e operacional. É o tipo de validação mínima que reduz improviso em ambiente real.

# Debian/Ubuntu
systemctl status ssh
# Arch / RHEL-like
systemctl status sshd

sudo sshd -T | grep -E '^(port|passwordauthentication|permitrootlogin)\b'
sudo grep -E '^\s*(Port|PasswordAuthentication|PermitRootLogin)\b' /etc/ssh/sshd_config

ssh localhost 'whoami'
Evidencia minima a copiar
1. Estado do servico (`active (running)` ou equivalente), usando `ssh` em Debian/Ubuntu e `sshd` em Arch/RHEL-like.
2. Port, PasswordAuthentication e PermitRootLogin na configuracao efetiva (`sshd -T`).
3. Um comando remoto executado em `localhost` (saida de `whoami` ou `hostname`).
4. Se estiver inativo, registrar `sudo systemctl enable --now ssh` ou `sudo systemctl enable --now sshd` e repetir a validacao.
Conclusao (2-3 linhas) - modelo
O servico SSH esta ativo, com parametros efetivos identificados, e executa comando remoto no proprio host.
A evidencia confirma servico operavel, nao apenas a presenca do cliente SSH.
Configuracao escrita em arquivo nao e sinonimo de configuracao ativa; sempre que possivel, valide o efetivo e nao apenas o texto do arquivo.
EXERCÍCIO 04
Netstat ou ss como inventário do plano de transporte
Objetivo: Inventariar portas em LISTEN, conexões ativas e exposição em IPv4 e IPv6.

Aqui você aprende a olhar o host como um ponto de escuta e trânsito de conexões, não como uma caixa-preta. Portas em LISTEN indicam processos aguardando conexão. Entradas ESTABLISHED indicam sessões ativas. Endereços locais e remotos mostram quem fala com quem. E a separação entre IPv4 e IPv6 permite responder uma pergunta operacional concreta: o serviço está exposto em qual pilha de rede.

O ganho pedagógico está menos em "listar portas" e mais em interpretar estados e escopo de exposição. Um operador de verdade não para no número da porta; ele lê estado, endereço, família de protocolo e dono do socket, e transforma isso em conclusão operacional.

sudo ss -tlnp
sudo ss -tanp

sudo ss -4 -tlnp
sudo ss -6 -tlnp
Evidencia minima a copiar
1. Um trecho com LISTEN e um trecho com ESTABLISHED no inventario TCP.
2. Um trecho de IPv4 e um de IPv6 para a mesma analise de exposicao.
3. Regra de decisao para SSH: `0.0.0.0:22` indica IPv4, `[::]:22` indica IPv6, ambos indicam dual-stack.
Conclusao (2-3 linhas) - modelo
O inventario mostra quais sockets aceitam conexao e quais sessoes estao ativas no momento.
Com base nos binds de porta 22, o SSH esta exposto em IPv4, IPv6 ou em ambos.
LISTEN responde "quem aceita conexao"; ESTABLISHED responde "quem ja esta conversando". Misturar os dois leva a diagnostico ruim.
EXERCÍCIO 05
Correlação porta para processo com lsof
Objetivo: Descobrir, com precisão, qual processo e qual usuário são responsáveis por uma porta em escuta.

Saber que uma porta está aberta é útil. Saber quem a abriu é decisivo. O lsof transforma a observação de socket em evidência acionável: ele mostra processo, PID, usuário e porta. Essa correlação é o que impede que você mexa no serviço errado, reinicie o que não deveria ou perca tempo caçando um problema fantasma.

Em cenários reais, essa habilidade economiza minutos preciosos em incidentes. Em laboratório, ela ensina a substituir suposição por autoria comprovada: a porta não "está aberta"; ela está aberta porque um processo específico a mantém em LISTEN sob um determinado usuário.

sudo ss -tlnp

sudo lsof -nP -iTCP:22 -sTCP:LISTEN
sudo lsof -nP -iTCP:<porta2> -sTCP:LISTEN
Evidencia minima a copiar
1. Escolher 2 portas em LISTEN (uma delas 22, se SSH estiver ativo).
2. Para cada porta, copiar os campos `PID`, `USER` e `COMMAND` do `lsof`.
3. Registrar a porta escolhida como `<porta2>` e o processo responsavel.
Conclusao (2-3 linhas) - modelo
A correlacao porta para processo identificou dono tecnico (PID, usuario e comando) para cada socket em escuta.
Isso reduz risco de acao incorreta em incidentes, porque elimina suposicao sobre qual servico esta na porta.
Use -nP para impedir resolucao de nomes e portas simbolicas; isso deixa a saida mais direta e mais util para evidencia.
EXERCÍCIO 06
Serviço TCP mínimo com netcat
Objetivo: Construir um experimento controlado com listener, cliente e prova de troca de dados.

Este é o coração do laboratório: criar um cenário mínimo sob seu controle. Com netcat, você monta um listener TCP simples em uma porta alta e depois conecta um cliente local para enviar uma mensagem. Isso elimina variáveis externas e cria um ambiente de teste limpo, pequeno e repetível.

A força didática do exercício está em provar cada etapa: a porta em LISTEN, a conexão realizada e a mensagem recebida. É assim que se começa a pensar como alguém que trabalha com sistemas distribuídos: controlar variáveis, observar sinais e repetir o experimento sem depender de infraestrutura alheia.

# Terminal A (OpenBSD netcat)
nc -lvp 55555
# alternativa comum
nc -l -p 55555 -v

# Terminal B
echo "mensagem-teste" | nc 127.0.0.1 55555

# Evidencia de LISTEN
sudo ss -tlnp | grep 55555
sudo lsof -nP -iTCP:55555 -sTCP:LISTEN
Evidencia minima a copiar
1. Tela do listener (Terminal A) mostrando recebimento da string `mensagem-teste`.
2. Trecho do `ss` ou `lsof` comprovando a porta 55555 em LISTEN.
3. Se o `nc -lvp` nao existir na sua implementacao, usar a variante `nc -l -p 55555 -v`.
4. Se usar `netstat`, manter equivalencia com os mesmos sinais de LISTEN.
Conclusao (2-3 linhas) - modelo
O laboratorio controlado mostrou listener ativo, conexao local bem-sucedida e entrega de payload.
A evidencia valida o fluxo fim a fim sem depender de infraestrutura externa.
Escolha uma porta alta para reduzir risco de conflito com servicos do sistema e manter o experimento isolado.
EXERCÍCIO 07
Captura controlada com tcpdump e arquivo pcap
Objetivo: Provar a circulação de pacotes no experimento com netcat e gerar artefato auditável.

Se o exercício anterior prova a troca de dados do ponto de vista da aplicação, este aqui prova do ponto de vista do tráfego. O tcpdump captura os pacotes reais e grava um arquivo .pcap, que funciona como artefato técnico verificável. Isso muda a natureza do diagnóstico: a rede deixa de ser hipótese e passa a ser evidência observável.

A captura precisa ser pequena e bem focada. Por isso, primeiro se identifica a interface correta e depois se filtra pela porta do experimento. O resultado desejado não é uma montanha de pacotes, mas um recorte preciso que mostre SYN, handshake ou payload trafegando, dependendo do momento coletado.

ip route get 1.1.1.1

sudo tcpdump -i <iface> -nn tcp port 55555 -w nc_55555.pcap
# pare com Ctrl+C apos gerar trafego

ls -lh nc_55555.pcap

sudo tcpdump -nn -r nc_55555.pcap | head -n 10
Evidencia minima a copiar
1. Interface ativa selecionada (`dev <iface>`).
2. Artefato: nome e tamanho do arquivo `nc_55555.pcap`.
3. Ate 10 linhas de leitura do pcap provando trafego na porta 55555.
Conclusao (2-3 linhas) - modelo
A captura pcap confirma observabilidade do trafego do experimento na interface correta.
Com isso, a validacao deixa de ser inferencia de aplicacao e passa a ter prova de rede.
Capturar na interface errada costuma produzir um arquivo "correto" e inutil; sempre descubra primeiro por onde o trafego realmente passa.
EXERCÍCIO 08
Validação externa com nmap
Objetivo: Obter a visão de fora do host e cruzá-la com as evidências internas.

Até aqui, você olhou o sistema por dentro. Agora entra a perspectiva externa. O nmap permite verificar se a porta aparece como aberta para quem se conecta de fora, mesmo que o "fora" seja o próprio localhost em uma varredura local. Isso ensina uma disciplina importante: não confiar em uma única ferramenta nem em um único ângulo de observação.

Quando o nmap mostra a porta aberta e o lsof ou ss mostra quem a mantém em LISTEN, o circuito de validação se fecha. Você deixa de ter apenas uma porta aberta "aparente" e passa a ter uma cadeia causal verificável: serviço em escuta, visível externamente, associado a um processo específico.

nmap localhost
nmap -sT -Pn localhost
nmap -sT -Pn -p 55555 localhost

sudo lsof -nP -iTCP:55555 -sTCP:LISTEN
Evidencia minima a copiar
1. Scan amplo mostrando portas TCP abertas no host.
2. Linha especifica da porta 55555 como `open` no scan focado.
3. Cruzamento interno com `lsof` (PID/USER/COMMAND da porta 55555).
Conclusao (2-3 linhas) - modelo
A visao externa (`nmap`) confirmou a porta aberta e a visao interna (`lsof`) identificou o processo dono.
O diagnostico fica fechado por evidencias independentes e coerentes.
Visao interna e visao externa nao sao redundantes; elas se validam mutuamente e aumentam a confianca no diagnostico.
EXERCÍCIO 09
Serviços legados em claro e risco operacional
Objetivo: Detectar exposição de telnet ou ftp e propor mitigação mínima baseada em risco.

Nem todo diagnóstico serve apenas para provar que algo funciona. Às vezes, ele serve para provar que algo perigoso não deveria estar exposto. É o caso de serviços legados em claro, como FTP e Telnet. O exercício pede verificação objetiva da presença ou ausência dessas portas e, em seguida, uma conclusão curta sobre risco e mitigação.

A maturidade aqui está em não dramatizar nem improvisar. Se a porta não está exposta, isso já é uma evidência válida. Se estiver, a análise deve apontar risco concreto: aumento de superfície de ataque e tráfego sem criptografia. Depois disso, entram medidas mínimas e plausíveis, como bloqueio por firewall, desativação do serviço ou segmentação de rede.

Formato de entrega: evidencia minima + recorte curto + conclusao em 2-4 linhas. Sem despejar output inteiro.

nmap -p 21,23 localhost

sudo ss -tlnp | egrep ':(21|23)\b'
# opcional (legado):
sudo netstat -tulnp 2>/dev/null | egrep ':(21|23)\b'
Evidencia minima a copiar (escolha 1 opcao)
Opcao A (nmap): copiar 1-2 linhas de `nmap -p 21,23 localhost` mostrando `closed/filtered` ou `open`.
Opcao B (ss/netstat): copiar recorte curto mostrando ausencia de 21/23 em LISTEN (ou presenca, se aparecer).
Se aparecer `open`, registrar explicitamente: "servico exposto; risco alto; mitigar".
Resposta pronta (2-4 linhas) - modelo
Motivo 1: trafego em claro aumenta risco de credenciais expostas.
Motivo 2: servico legado exposto amplia superficie de ataque.
Mitigacao 1: bloquear 21/23 no firewall (host e/ou borda).
Mitigacao 2: remover/desativar FTP/Telnet e substituir por SSH/SFTP/FTPS.
Mini-rodape de entrega
Como validar: `nmap -p 21,23 localhost`.
Qual evidencia anexar: 1 recorte curto (nmap ou ss/netstat).
Conclusao: 2-4 linhas com 2 motivos + 2 mitigacoes.
"Nao encontrei" so vira evidencia quando voce mostra com qual comando procurou e qual foi o resultado obtido.
EXERCÍCIO 10
Mitigação mínima de SSH com rollback
Objetivo: Fazer alteração segura no sshd com backup, validação de sintaxe, teste e plano de retorno.

Este exercício introduz mentalidade de mudança controlada. Alterar SSH em produção sem backup, teste e rollback é um clássico convite ao desastre. Por isso, o fluxo correto começa com cópia de segurança do arquivo, passa por uma alteração mínima e termina com validação de sintaxe, reinício controlado, teste funcional e plano de desfazer.

Padrao do TP para mitigacao minima: usar apenas `PermitRootLogin no`. Assim, a entrega fica comparavel e evita armadilhas para quem ainda nao configurou autenticacao por chave.

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
ls -lh /etc/ssh/sshd_config.bak

# evidencia curta antes da mudanca
sudo grep -nE '^\s*PermitRootLogin\b' /etc/ssh/sshd_config

# mitigacao minima padrao do TP
sudo sed -i 's/^#\?PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
sudo grep -nE '^\s*PermitRootLogin\b' /etc/ssh/sshd_config

# checkpoint obrigatorio antes do restart
sudo sshd -t
# Debian/Ubuntu
sudo systemctl restart ssh
systemctl is-active ssh
# Arch / RHEL-like
sudo systemctl restart sshd
systemctl is-active sshd

ssh localhost 'whoami'

# rollback
sudo cp /etc/ssh/sshd_config.bak /etc/ssh/sshd_config
sudo systemctl restart ssh || sudo systemctl restart sshd
Evidencia minima a copiar
1. Backup criado com nome e tamanho (`sshd_config.bak`).
2. Evidencia curta ANTES da linha alterada (`grep -nE '^\s*PermitRootLogin\b'`).
3. Evidencia curta DEPOIS da linha alterada (mesmo comando).
4. Checkpoint obrigatorio: `sudo sshd -t` antes de reiniciar o servico.
5. Servico ativo, teste remoto funcional e rollback executavel.
Conclusao (2-4 linhas) - modelo
Backup criado; linha `PermitRootLogin` alterada; sintaxe validada; sshd ativo; conexao funcionando; rollback definido.
Mudanca aplicada com risco controlado e evidencia curta anexada.
Mini-rodape de entrega
Como validar: `sudo sshd -t && systemctl is-active ssh || systemctl is-active sshd`.
Qual evidencia anexar: 1 recorte antes + 1 recorte depois + status ativo.
Conclusao: 2-4 linhas com backup, linha alterada, validacao e rollback.
Nunca aplique mudanca em SSH sem manter uma sessao ja aberta ou sem ter um rollback simples e testavel.
EXERCÍCIO 11
Socket operacional: bind, listen, accept, send e recv
Objetivo: Relacionar os conceitos de socket com os estados e sinais exibidos pelas ferramentas do sistema.

A proposta aqui é fazer a ponte entre teoria e observação. Os conceitos clássicos de programação de rede - bind, listen, accept, send e recv - não ficam restritos a livros ou código-fonte; eles aparecem materializados em estados, processos e tráfego. Um socket associado a uma porta mostra bind. Um socket em LISTEN mostra listen. Uma conexão ativa em ESTABLISHED mostra accept já ocorrido. A mensagem entregue ou o pacote capturado fecha o ciclo com send e recv.

Esse tipo de mapeamento é importante porque reduz abstração solta. Você passa a ver que a API de sockets não é um "mundo teórico separado", mas um modo de organizar o que o sistema já torna visível com ss, lsof e tcpdump.

# Terminal A (listener)
nc -lvp 55555

# Terminal B (cliente)
nc 127.0.0.1 55555
# digite algo e pressione Enter (nao feche imediatamente)

sudo lsof -nP -iTCP:55555 -sTCP:LISTEN
sudo ss -tlnp | grep 55555
sudo ss -tanp | grep 55555
Evidencia minima a copiar
1. `lsof`: processo/PID dono da porta 55555.
2. `ss -tlnp`: porta 55555 em LISTEN.
3. `ss -tanp`: sessao ESTABLISHED durante conexao interativa.
Mapeamento obrigatorio (4 linhas) - modelo
bind: "nc abriu a porta 55555" -> evidencia: `lsof -nP -iTCP:55555 -sTCP:LISTEN`.
listen: "porta 55555 em LISTEN" -> evidencia: `ss -tlnp | grep 55555`.
accept/connect: "sessao ESTABLISHED" -> evidencia: `ss -tanp | grep 55555`.
send/recv: "mensagem apareceu no listener" -> evidencia: terminal do `nc` ou recorte de `tcpdump`.
Conclusao (2-3 linhas) - modelo
O mapeamento bind/listen/accept/send/recv foi comprovado por estados de socket e sinais de trafego.
Isso conecta a API de sockets a evidencias operacionais reais no host.
Mini-rodape de entrega
Como validar: `ss -tanp | grep 55555` durante conexao ativa.
Qual evidencia anexar: 4 linhas (bind/listen/accept-connect/send-recv).
Conclusao: 2-3 linhas conectando conceito e evidencia.
Se nao aparecer ESTABLISHED, voce fechou a conexao rapido demais. Repita mantendo os dois terminais abertos por alguns segundos.
EXERCÍCIO 12
Diagnóstico integrado com uma evidência por ferramenta
Objetivo: Consolidar netstat ou ss, lsof, nmap e tcpdump em uma conclusão única, curta e consistente.

O fechamento do TP2 não pede mais comandos isolados, mas coerência entre evidências. A ideia é selecionar um cenário simples - por exemplo, o listener na porta 55555 - e produzir uma evidência curta por ferramenta. O ss mostra LISTEN e ESTABLISHED. O lsof mostra o processo dono. O nmap mostra que a porta aparece aberta externamente. O tcpdump mostra o tráfego real.

O valor aqui está na convergência. Um diagnóstico forte não depende de uma única saída vistosa. Ele nasce quando várias ferramentas, olhando o mesmo fenômeno por ângulos distintos, contam a mesma história. Quando isso acontece, a conclusão deixa de ser opinião e passa a ser defensável tecnicamente.

sudo ss -tlnp | grep 55555
sudo ss -tanp | grep 55555

sudo lsof -nP -iTCP:55555 -sTCP:LISTEN

nmap -sT -Pn -p 55555 localhost

sudo tcpdump -i <iface> -nn tcp port 55555 -c 10
Um recorte por ferramenta (obrigatorio)
1. `ss` ou `netstat`: 1-2 linhas (LISTEN e/ou ESTABLISHED na 55555).
2. `lsof`: 1 linha com PID/COMMAND/USER da 55555.
3. `nmap`: 1 linha com `55555/tcp open`.
4. `tcpdump`: ate 10 linhas (ideal: 3-5 linhas) na mesma porta.
Conclusao (3-5 linhas) - modelo
Linha 1: `ss/netstat` prova LISTEN e ESTABLISHED na porta 55555.
Linha 2: `lsof` prova o processo dono da porta (PID e comando).
Linha 3: `nmap` confirma externamente `55555/tcp open`.
Linha 4: `tcpdump` prova troca real de pacotes na mesma porta.
Linha 5 (opcional): portanto, o experimento esta consistente e reproduzivel.
Criterio de consistencia (alerta didatico)
Se `nmap` diz `open` mas `ss` nao mostra LISTEN, voce mediu em momentos diferentes. Recolete os recortes em sequencia curta.
Mini-rodape de entrega
Como validar: `ss` + `lsof` + `nmap` + `tcpdump` no mesmo experimento.
Qual evidencia anexar: 1 recorte por ferramenta, curto.
Conclusao: 3-5 linhas, cada linha fechando uma prova.
O objetivo final nao e "mostrar que rodou tudo", mas construir uma narrativa curta em que cada ferramenta confirma uma parte da mesma hipotese.