Introdução
Neste laboratório, você aprenderá como capturar e analisar tráfego de rede usando ferramentas de linha de comando, canalizando a saída do Tshark para outros utilitários. Você praticará a captura de pacotes na interface eth1 com tcpdump, filtrando mensagens de erro usando grep e contando correspondências com wc -l.
O laboratório se concentra em técnicas práticas para solução de problemas de rede, incluindo a salvaguarda de capturas no formato pcap para análise posterior. Você aprenderá a verificar interfaces, aplicar filtros e otimizar fluxos de trabalho de análise de pacotes por meio de pipes Unix e operações de arquivo.
Capturar Tráfego com -i eth1
Nesta etapa, você aprenderá como capturar tráfego de rede na interface eth1 usando comandos Linux básicos. A interface eth1 é tipicamente a interface de rede primária em sistemas Linux, representando a primeira conexão Ethernet em sua máquina.
Antes de capturar o tráfego, é importante verificar se a interface existe e está ativa. Interfaces de rede podem ser físicas (como portas Ethernet) ou virtuais (como conexões VPN). Execute este comando para verificar o status da sua interface eth1:
ip link show eth1
Você deve ver uma saída semelhante a:
2: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
link/ether 00:16:3e:5e:6c:00 brd ff:ff:ff:ff:ff:ff
O status UP indica que a interface está ativa. Agora, usaremos o tcpdump, uma ferramenta fundamental para análise de rede que permite ver o tráfego em tempo real. Este comando básico de captura ajudará você a entender o que está acontecendo em sua rede:
sudo tcpdump -i eth1 -c 5
Vamos detalhar o que este comando faz:
-i eth1: Especifica qual interface de rede monitorar (eth1 neste caso)-c 5: Limita a captura a 5 pacotes, o que é suficiente para demonstração sem inundar seu terminal
A saída mostrará detalhes dos pacotes, incluindo timestamps, IPs de origem/destino e informações de protocolo:
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 262144 bytes
12:34:56.789012 IP 192.168.1.100.22 > 192.168.1.1.12345: Flags [P.], seq 1:21, ack 1, win 501, length 20
12:34:56.789123 IP 192.168.1.1.12345 > 192.168.1.100.22: Flags [.], ack 21, win 1024, length 0
...
5 packets captured
5 packets received by filter
0 packets dropped by kernel
Para uma análise mais detalhada, você desejará salvar os pacotes em um arquivo. Arquivos PCAP preservam todos os dados dos pacotes e podem ser abertos em ferramentas gráficas como o Wireshark. Este comando cria um arquivo de captura:
sudo tcpdump -i eth1 -c 5 -w ~/project/eth1_capture.pcap
A flag -w grava os pacotes em eth1_capture.pcap no seu diretório de projeto. Este formato binário mantém todas as informações originais dos pacotes exatamente como foram capturadas.
Filtrar Erros com | grep "ERROR"
Nesta etapa, você aprenderá como filtrar o tráfego de rede em busca de mensagens de erro usando o comando grep. Isso é particularmente útil ao analisar grandes capturas de pacotes onde você só deseja ver pacotes contendo erros. O operador pipe (|) no Linux permite que você pegue a saída de um comando e a use como entrada para outro comando, criando fluxos de trabalho de análise poderosos.
Primeiro, vamos examinar o arquivo de captura que criamos na etapa anterior. Execute o seguinte comando para visualizar o conteúdo do arquivo pcap em formato de texto. Isso converte os dados binários dos pacotes em um formato legível por humanos:
tcpdump -r ~/project/eth1_capture.pcap
Agora, vamos criar um arquivo de log de amostra contendo mensagens normais e de erro para fins de demonstração. Isso nos ajudará a entender como o grep funciona antes de aplicá-lo ao tráfego de rede real:
echo -e "INFO: Connection established\nERROR: Authentication failed\nINFO: Data transfer complete\nERROR: Connection timeout" > ~/project/network.log
Para filtrar apenas as mensagens de erro deste arquivo de log, usaremos grep com o padrão "ERROR". grep pesquisa texto linha por linha e imprime apenas as linhas que correspondem ao padrão:
grep "ERROR" ~/project/network.log
Você deve ver uma saída contendo apenas as linhas de erro:
ERROR: Authentication failed
ERROR: Connection timeout
Agora, vamos aplicar isso à nossa captura de pacotes real. Primeiro, precisamos converter o pcap para um formato de texto legível, pois o grep funciona com arquivos de texto. Isso cria uma versão em texto da nossa captura de pacotes:
tcpdump -r ~/project/eth1_capture.pcap > ~/project/packets.txt
Em seguida, filtre por quaisquer mensagens de erro nos dados de pacotes convertidos. Usamos a flag -i para tornar a pesquisa case-insensitive (sem distinção entre maiúsculas e minúsculas), o que significa que ela corresponderá a "error", "ERROR" ou qualquer outra capitalização:
grep -i "error" ~/project/packets.txt
A flag -i torna a pesquisa case-insensitive. Se houver pacotes contendo "error" (em qualquer caso), eles serão exibidos. Isso ajuda a garantir que não percamos nenhuma mensagem de erro devido a diferentes capitalizações nos protocolos de rede.
Contar Correspondências com | wc -l
Nesta etapa, aprenderemos como quantificar erros de rede contando as linhas correspondentes usando o comando wc -l. Essa técnica ajuda os administradores de rede a entender a frequência de erros no tráfego capturado.
Antes de contar, vamos primeiro revisar as mensagens de erro que identificamos anteriormente. O seguinte comando exibe todas as linhas contendo "error" (sem distinção entre maiúsculas e minúsculas) do nosso arquivo de captura de pacotes:
grep -i "error" ~/project/packets.txt
Para contar essas ocorrências de erro em vez de exibi-las, usaremos um pipe (|) para enviar a saída do grep para wc -l. O comando wc conta palavras, linhas ou caracteres, e a opção -l conta especificamente linhas:
grep -i "error" ~/project/packets.txt | wc -l
O comando gera um número simples que representa quantas mensagens de erro foram encontradas:
2
Para contexto, vamos também contar o número total de pacotes em nosso arquivo de captura. Isso nos ajuda a entender qual proporção do tráfego contém erros:
wc -l ~/project/packets.txt
A saída mostra a contagem e o nome do arquivo:
50 packets.txt
Para calcular a taxa de erro como uma porcentagem, usaremos a aritmética básica do shell. Primeiro, armazenamos a contagem de erros e a contagem total de pacotes em variáveis, depois realizamos o cálculo usando bc (um programa de calculadora básico):
errors=$(grep -i "error" ~/project/packets.txt | wc -l)
total=$(wc -l < ~/project/packets.txt)
echo "scale=2; ($errors/$total)*100" | bc
A configuração scale=2 diz ao bc para exibir duas casas decimais no resultado:
4.00
Salvar em Arquivo com > output.txt
Nesta etapa, exploraremos como salvar os resultados da análise de rede em arquivos para documentação e exame posterior. Ao trabalhar com a saída do Tshark, é frequentemente útil armazenar dados filtrados separadamente, em vez de apenas visualizá-los no terminal.
Primeiro, vamos relembrar o comando que usamos anteriormente para contar as ocorrências de erro em nossa captura de pacotes:
grep -i "error" ~/project/packets.txt | wc -l
O operador > no Linux nos permite redirecionar a saída do comando para um arquivo em vez de exibi-la na tela. Para salvar apenas a contagem numérica de erros em um novo arquivo chamado error_count.txt, modificamos nosso comando assim:
grep -i "error" ~/project/packets.txt | wc -l > ~/project/error_count.txt
Após executar isso, você pode verificar se o arquivo contém exatamente o que esperamos - apenas o número da contagem de erros:
cat ~/project/error_count.txt
Às vezes, precisamos de mais do que apenas contagens - queremos as mensagens de erro reais para análise. Para salvar todas as linhas de erro correspondentes em um arquivo, removemos a parte da contagem de palavras:
grep -i "error" ~/project/packets.txt > ~/project/error_messages.txt
Verifique o conteúdo para confirmar se todas as mensagens de erro foram capturadas:
cat ~/project/error_messages.txt
Para monitoramento contínuo, podemos querer adicionar a arquivos existentes em vez de substituí-los. O operador >> anexa aos arquivos. Veja como criar um relatório de erro com carimbo de data/hora:
echo "Contagem de erros em $(date):" >> ~/project/error_report.txt
grep -i "error" ~/project/packets.txt | wc -l >> ~/project/error_report.txt
Visualize seu arquivo de relatório crescente para ver os dados acumulados:
cat ~/project/error_report.txt
Resumo
Neste laboratório, você aprendeu técnicas práticas para captura e análise de tráfego de rede usando ferramentas de linha de comando. Os exercícios cobriram a captura de pacotes com tcpdump, a verificação da interface usando ip link show e a criação de arquivos PCAP para análise offline.
Você também explorou métodos eficientes de processamento de dados por meio de operações de piping (encadeamento), incluindo filtragem de erros com grep, contagem de correspondências via wc -l e redirecionamento de saída para arquivos de texto. Essas habilidades permitem a extração direcionada de informações de rede para uma solução de problemas eficaz.
