Analisar Portas e Sessões de Rede com netstat no Linux

Introdução

Neste laboratório, você aprenderá a usar o comando netstat para analisar a atividade de rede em um sistema Linux. Você explorará conceitos fundamentais como portas de rede, sockets e conexões ativas para obter insights sobre como os serviços se comunicam pela rede.

Você começará listando todos os sockets ativos e, em seguida, filtrará os resultados para se concentrar em portas TCP e UDP em escuta, mapeando-as para seus serviços em execução. Para ver esses conceitos em ação, você gerará uma nova conexão navegando em um site e, em seguida, usará o netstat para identificar a sessão ESTABLISHED recém-criada e sua porta efêmera associada.

Listar Todos os Sockets Ativos e em Escuta com `netstat -a`

Nesta etapa, você começará a explorar a atividade de rede do seu sistema usando o comando netstat. Este comando é uma ferramenta fundamental para administradores de rede e desenvolvedores, fornecendo insights sobre conexões de rede, tabelas de roteamento e estatísticas de interface. Começaremos com a opção -a, que instrui o netstat a exibir todos os sockets ativos, incluindo conexões com sistemas remotos e portas que estão "escutando" novas conexões de entrada.

Primeiro, certifique-se de estar no seu diretório de trabalho padrão. Todos os comandos neste laboratório serão executados a partir do terminal.

Agora, vamos listar todos os sockets. No seu terminal, digite o seguinte comando e pressione Enter:

netstat -a

Você verá uma grande quantidade de saída. Não se preocupe, vamos detalhá-la. A saída mostra todos os tipos de sockets, incluindo sockets de domínio TCP, UDP e UNIX.

Vamos examinar a estrutura da saída. Ela deve ser semelhante a esta (os detalhes exatos no seu sistema variarão):

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN
tcp        0      0 localhost:6010          0.0.0.0:*               LISTEN
tcp        0     52 labex-vm:ssh            192.168.0.10:54321      ESTABLISHED
tcp6       0      0 [::]:http-alt           [::]:*                  LISTEN
udp        0      0 0.0.0.0:bootpc          0.0.0.0:*
...
Active UNIX domain sockets (servers and established)
Proto RefCnt Flags       Type       State         I-Node   Path
unix  2      [ ]         DGRAM                    23456    /run/systemd/notify
unix  2      [ ACC ]     STREAM     LISTENING     34567    /tmp/.X11-unix/X0
...

Aqui está uma análise das colunas mais importantes para conexões de Internet:

Proto: O protocolo usado pelo socket, como tcp (para TCPv4), tcp6 (para TCPv6) ou udp.
Local Address: O endereço IP do seu sistema e o número da porta que ele está usando para esta conexão. A porta é o número após os dois pontos (:). Um endereço de 0.0.0.0 ou [::] significa que a porta está escutando em todas as interfaces de rede disponíveis na sua máquina.
Foreign Address: O endereço IP e o número da porta do sistema remoto. Se o estado for LISTEN, este será tipicamente 0.0.0.0:* ou [::]:*, indicando que está aguardando uma conexão de qualquer endereço.
State: Isso é crucial para conexões TCP.
- LISTEN: A aplicação está aguardando uma conexão de entrada na porta especificada em Local Address. Este é um estado do lado do servidor.
- ESTABLISHED: Uma conexão está ativa e os dados podem ser transferidos entre os endereços local e remoto.
- Outros estados como TIME_WAIT ou CLOSE_WAIT estão relacionados ao processo de fechamento de uma conexão TCP.

Reserve um momento para percorrer a saída e identificar quaisquer entradas no estado LISTEN. Estas representam serviços no seu sistema que estão prontos para aceitar conexões de rede. Este é um olhar direto sobre a Camada de Transporte (Camada 4) em ação.

Filtrar Portas TCP/UDP em Escuta com `sudo netstat -tulnp`

Na etapa anterior, o comando netstat -a nos forneceu uma lista completa, mas extensa, de todos os sockets. Para tornar essas informações mais úteis, precisamos filtrá-las. Nesta etapa, você aprenderá a usar opções específicas com o netstat para exibir apenas as portas TCP e UDP em escuta e, o mais importante, para identificar quais programas as estão utilizando.

Para ver o nome do programa associado a uma porta, você geralmente precisa de privilégios administrativos, pois o processo pode pertencer ao sistema ou a outro usuário. É por isso que usamos o comando sudo. No ambiente LabEx, você pode usar sudo sem senha.

Vamos executar um comando netstat mais focado. No seu terminal, digite o seguinte:

sudo netstat -tulnp

Vamos detalhar essas opções, pois elas são comumente combinadas:

t: Exibe conexões TCP.
u: Exibe conexões UDP.
l: Exibe apenas sockets em lista (listening). Este é o nosso filtro principal para ver quais serviços estão aguardando conexões.
n: Exibe endereços numéricos. Isso impede que o netstat tente resolver endereços IP e números de porta em nomes de host e nomes de serviço (por exemplo, mostra 22 em vez de ssh), o que faz com que o comando seja executado muito mais rapidamente.
p: Mostra o ID do processo (PID) e o nome do programa ao qual o socket pertence. Isso requer sudo para ver todos os processos.

Após pressionar Enter, sua saída será muito mais curta e informativa. Ela se parecerá com algo assim:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve

Observe a nova coluna no final: PID/Program name. Esta é a informação chave. Agora você pode mapear diretamente uma porta em escuta para a aplicação exata que a abriu. Por exemplo, na saída acima, você pode ver que a porta 22 (a porta padrão para SSH) está sendo usada pelo programa sshd com um ID de Processo de 3422.

Este comando é extremamente poderoso para administradores de sistemas. Ele permite verificar rapidamente quais serviços estão em execução e expostos à rede, o que é essencial tanto para solução de problemas quanto para auditoria de segurança.

Mapear Portas em Escuta para Serviços em Execução

Nesta etapa, você solidificará seu entendimento sobre a ligação entre aplicações em execução e portas de rede em escuta. Você viu como listar serviços existentes com netstat. Agora, você iniciará seu próprio serviço web simples e o observará aparecer na saída do netstat, demonstrando essa relação em tempo real.

Usaremos o módulo http.server integrado do Python para iniciar rapidamente um servidor web. Esta é uma ferramenta conveniente para desenvolvimento e testes.

Primeiro, vamos iniciar o servidor web. Direcionaremos ele para escutar na porta 8080, uma porta alternativa comum para serviços web. No seu terminal, execute o seguinte comando. Observe que seu terminal parecerá "congelar", pois ele agora está executando ativamente o servidor.
```
python3 -m http.server 8080
```
Você deverá ver uma saída indicando que o servidor foi iniciado:
```
Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) ...
```
Este terminal agora está ocupado pelo processo do servidor web. Você precisa de um novo terminal para executar outros comandos. No ambiente LabEx, você pode abrir uma nova aba de terminal clicando no ícone de "mais" na janela do terminal ou usando o menu (File -> New Tab).
Na sua nova aba de terminal, execute o comando netstat novamente para ver a lista de portas em escuta.
```
sudo netstat -tulnp
```

Examine a saída cuidadosamente. Agora você verá uma nova entrada para a porta 8080.

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      12345/python3
udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve
...

Como você pode ver, o sistema agora relata que o programa python3 (com um PID específico, como 12345) está no estado LISTEN na porta 8080. Você iniciou com sucesso um serviço e confirmou que ele está escutando por conexões de rede.

Agora, vamos parar o serviço. Volte para a sua primeira aba de terminal (aquela que está executando o servidor Python) e pressione Ctrl+C. Isso interromperá e encerrará o processo do servidor.
Retorne à segunda aba de terminal e execute o comando netstat mais uma vez.
```
sudo netstat -tulnp
```
A linha para a porta 8080 terá desaparecido, provando que, quando uma aplicação é encerrada, ela deixa de escutar na porta.

Criar uma Nova Conexão Navegando em um Website

Nesta etapa, você mudará seu foco das portas de escuta do lado do servidor para as conexões ativas do lado do cliente. Até agora, você observou serviços esperando que outros se conectassem a eles. Agora, você iniciará uma conexão da sua máquina para um servidor remoto e observará a formação da conexão. Usaremos a ferramenta de linha de comando curl para simular a visita a um website.

Para observar este evento fugaz, usaremos o comando watch, que executa repetidamente outro comando, permitindo-nos ver as mudanças na saída do netstat em tempo quase real.

Primeiro, vamos configurar nossa janela de monitoramento. No seu terminal, execute o seguinte comando. Isso executará netstat -antp a cada dois segundos e exibirá os resultados, atualizando continuamente a tela.
```
watch netstat -antp
```
- a: Mostra todos os sockets.
- n: Mostra endereços numéricos.
- t: Mostra apenas conexões TCP.
- p: Mostra o PID/Nome do Programa.
Seu terminal agora será preenchido com a saída do netstat, que se atualiza automaticamente. Mantenha este terminal aberto e visível.
Agora, você precisa abrir uma nova aba de terminal para emitir o comando que criará a conexão. Clique no ícone de "mais" na barra de abas do seu terminal.
Na nova aba de terminal, você usará curl para buscar a página inicial do website LabEx. O símbolo > redireciona a saída HTML para /dev/null para que não polua sua tela.
```
curl https://www.labex.io > /dev/null
```
Assim que você pressionar Enter, mude rapidamente sua visualização de volta para a sua primeira aba de terminal (aquela que está executando o watch). Você verá uma nova conexão aparecer por alguns segundos. Ela se parecerá com algo assim:
```
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
...
tcp        0      0 172.17.0.2:45678        104.21.5.141:443        ESTABLISHED 13579/curl
...
```
- Observe que o State é ESTABLISHED, indicando uma conexão ativa.
- O Foreign Address mostra o endereço IP do servidor labex.io e a porta 443 (o padrão para HTTPS).
- A coluna PID/Program name identifica claramente curl como o programa que iniciou esta conexão.
- O Local Address usa uma porta aleatória de alto número (como 45678 no exemplo). Esta é uma porta efêmera, que discutiremos na próxima etapa.
Assim que o comando curl terminar de baixar (o que é muito rápido), você verá o estado da conexão mudar para TIME_WAIT ou FIN_WAIT antes de desaparecer completamente da lista.
Agora você pode parar o comando watch. Vá para a primeira aba de terminal e pressione Ctrl+C. Você também pode fechar a segunda aba de terminal.

Identificar uma Sessão ESTABLISHED e Portas Efêmeras

Nesta etapa final, você consolidará seu entendimento examinando uma conexão ativa e persistente. Isso permitirá que você identifique claramente uma "sessão" de rede e veja como seu sistema usa portas temporárias, ou "efêmeras", para comunicação do lado do cliente.

Uma conexão ESTABLISHED na saída do netstat representa uma sessão ativa (Camada 5 do OSI), onde duas aplicações estão prontas para trocar dados. Na etapa anterior, a sessão curl foi muito breve. Para estudar uma sessão com mais facilidade, criaremos uma que permaneça aberta usando SSH.

Primeiro, vamos definir um conceito importante: portas efêmeras. Quando seu computador (o cliente) se conecta a um servidor em uma porta bem conhecida (como a porta 22 para SSH ou 443 para HTTPS), seu sistema operacional deve atribuir uma porta para o seu lado da conversa. Ele escolhe uma porta temporária e não utilizada de uma faixa de números altos (geralmente acima de 32768). Isso é chamado de porta efêmera. Esse mecanismo permite que sua única máquina tenha muitas conexões separadas para a mesma porta do servidor, por exemplo, tendo várias abas do navegador abertas para o mesmo website.

Para criar uma sessão estável e observável, você fará SSH da sua máquina de laboratório de volta para si mesma. No seu terminal, execute o seguinte comando:
```
ssh localhost
```
Na primeira vez que fizer isso, você poderá ver uma mensagem sobre a autenticidade do host. Isso é normal.
```
The authenticity of host 'localhost (127.0.0.1)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?
```
Digite yes e pressione Enter para continuar.

Ele mostrará um prompt para inserir a senha. Você não precisa inserir a senha, apenas aguarde.
Abra uma nova aba de terminal clicando no ícone de "mais". Precisamos deste novo terminal para executar o netstat sem perturbar nossa sessão SSH ativa.
No novo terminal, execute o netstat novamente, mas desta vez, usaremos o comando grep para filtrar a saída e mostrar apenas as linhas que contêm ESTABLISHED. Isso torna muito mais fácil encontrar sessões ativas.
```
netstat -antp | grep ESTABLISHED
```
A saída mostrará todas as conexões TCP ativas no momento. Você pode ver um aviso de que nem todos os processos puderam ser identificados, o que é esperado, pois não estamos usando sudo. Você deverá ver sua conexão SSH original para o ambiente de laboratório e a nova que você acabou de criar para localhost.
```
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 172.16.50.192:22        47.251.66.143:36882     ESTABLISHED -
tcp        0      0 127.0.0.1:46280         127.0.0.1:22            ESTABLISHED 5449/ssh
tcp        0      0 127.0.0.1:22            127.0.0.1:46280         ESTABLISHED -
```
Vamos analisar a nova conexão localhost, identificada pelo endereço 127.0.0.1:
- O lado do servidor da conexão é 127.0.0.1:22, que é o servidor SSH (sshd) escutando na porta 22. Ele tem uma conexão estabelecida de 127.0.0.1:46280. As informações do programa são - porque o processo sshd é de propriedade do usuário root, e não usamos sudo.
- O lado do cliente é 127.0.0.1:46280 conectado a 127.0.0.1:22. O programa é claramente identificado como 5449/ssh.
- A porta 46280 é a porta efêmera. Seu sistema a escolheu aleatoriamente para a extremidade do cliente desta sessão SSH específica. Se você abrisse outra conexão ssh localhost, ela usaria uma porta efêmera diferente.
Para finalizar, feche a sessão. Volte para a aba do terminal onde você executou ssh localhost e digite exit, depois pressione Enter.
```
exit
```
Isso encerrará a conexão. Se você executar netstat -antp | grep ESTABLISHED novamente no outro terminal, verá que a sessão localhost desapareceu.

Resumo

Neste laboratório, você aprendeu a usar o comando netstat para analisar a atividade de rede em um sistema Linux. Você começou usando netstat -a para listar todos os sockets ativos e em escuta, incluindo sockets TCP, UDP e do domínio UNIX. Em seguida, refinou essa saída aplicando flags como -t, -u, -l, -n e -p para filtrar especificamente portas TCP e UDP em escuta, exibir endereços numéricos e identificar o ID do processo e o nome associados a cada porta.

Com base nisso, você praticou a interpretação da saída do comando para mapear portas em escuta aos seus serviços correspondentes. Para observar uma conexão em ação, você iniciou uma nova sessão de rede conectando-se a um website. Isso permitiu que você identificasse uma conexão no estado ESTABLISHED e compreendesse o papel das portas efêmeras, que são portas temporárias atribuídas ao lado do cliente de uma comunicação de rede.