Filtrar Tráfego HTTP no Tshark: Guia Prático

Introdução

Neste laboratório, você aprenderá a filtrar e analisar tráfego HTTP usando o Tshark, a ferramenta de linha de comando do Wireshark. Você praticará a captura de tráfego web na porta 80 e o isolamento de requisições HTTP com técnicas de filtragem específicas.

Os exercícios o guiarão através da extração de métodos HTTP (GET/POST) e da formatação da saída em JSON para análise estruturada. Essas habilidades são essenciais para a solução de problemas de rede e tarefas de inspeção de tráfego.

Capturar HTTP com -f "tcp port 80"

Nesta etapa, você aprenderá a capturar tráfego HTTP usando o filtro de exibição do Wireshark -f "tcp port 80". HTTP (Hypertext Transfer Protocol) é a base da comunicação de dados para a World Wide Web e normalmente usa a porta 80 para tráfego web não criptografado. Este filtro ajuda a isolar o tráfego HTTP de outros protocolos de rede, facilitando a análise das comunicações web.

Antes de começarmos, vamos entender alguns conceitos básicos:

Portas de rede são como portas onde tipos específicos de tráfego de rede entram e saem
A porta 80 é a porta padrão atribuída ao tráfego HTTP
O Wireshark pode filtrar o tráfego com base nesses números de porta

Primeiro, vamos abrir o Wireshark no ambiente da VM do LabEx. Siga estas etapas cuidadosamente:

Abra um terminal no desktop Xfce (você pode encontrá-lo no menu Aplicativos > Sistema > Terminal)
Navegue até o diretório de trabalho padrão onde armazenaremos nossos arquivos de captura:

cd ~/project

Inicie o Wireshark com o filtro de exibição para tráfego HTTP:

sudo wireshark -k -f "tcp port 80"

Vamos detalhar as opções do comando:

-k: Isso informa ao Wireshark para começar a capturar pacotes imediatamente
-f "tcp port 80": Este é o nosso filtro de captura que instrui o Wireshark a registrar apenas o tráfego TCP destinado ou proveniente da porta 80

Agora precisamos de algum tráfego HTTP para analisar. Abra outra janela de terminal (você pode clicar com o botão direito na área de trabalho e selecionar "Abrir Terminal") e gere tráfego de teste com:

curl http://example.com

Na janela do Wireshark, você verá os pacotes capturados mostrando:

A requisição HTTP do seu computador para example.com (geralmente começando com "GET / HTTP/1.1")
A resposta do servidor web (geralmente contendo "HTTP/1.1 200 OK")

Cada pacote mostra detalhes importantes como:

Endereços IP de origem e destino
Protocolo (HTTP)
Tamanho do pacote
Informações de tempo

Para iniciantes: O Wireshark age como um microscópio para o tráfego de rede. O filtro tcp port 80 funciona como uma lente especializada que mostra apenas o tráfego web, ignorando outros tipos de comunicação de rede. Essa visualização focada ajuda você a entender como navegadores e servidores web se comunicam sem se sentir sobrecarregado por outras atividades de rede.

Filtrar Requisições com -Y "http.request"

Nesta etapa, você aprenderá a filtrar requisições HTTP usando o filtro de exibição do Wireshark -Y "http.request". Este filtro ajuda você a se concentrar especificamente em pacotes de requisição HTTP, excluindo respostas e outros tráfegos de rede. Entender as requisições HTTP é fundamental para a análise de tráfego web, pois elas representam as mensagens iniciais que os clientes enviam aos servidores.

Com base na etapa anterior, onde capturamos o tráfego HTTP, vamos agora filtrar apenas as requisições HTTP:

Primeiro, certifique-se de estar no diretório de trabalho padrão onde trabalharemos com nossos arquivos de captura:

cd ~/project

Execute o Wireshark com o filtro de exibição para requisições HTTP:

sudo wireshark -k -Y "http.request"

A opção -Y aplica um filtro de exibição (diferente do filtro de captura -f usado na etapa 1). Enquanto os filtros de captura limitam o que é gravado, os filtros de exibição ajudam a analisar dados já capturados. Este filtro específico mostrará apenas pacotes que contêm requisições HTTP.

Para gerar tráfego de teste que podemos analisar, abra outro terminal e execute estes comandos comuns de cliente HTTP:

curl http://example.com
wget http://example.com

Para iniciantes: O filtro de exibição http.request corresponde especificamente a pacotes de requisição HTTP. Isso é útil quando você deseja analisar apenas as requisições sendo enviadas de clientes para servidores, ignorando as respostas do servidor. A sintaxe do filtro faz parte da poderosa linguagem de filtro de exibição do Wireshark que permite selecionar com precisão quais pacotes visualizar com base em critérios específicos do protocolo.

Na janela do Wireshark, você agora deve ver apenas pacotes de requisição HTTP dos comandos curl e wget. Cada pacote exibirá informações importantes do protocolo HTTP, incluindo:

O método HTTP (GET, POST, etc.) que indica o tipo de requisição
O URI solicitado mostrando o recurso específico que está sendo acessado
Versão HTTP (como HTTP/1.1) mostrando a versão do protocolo
Informações do host identificando o servidor de destino

Extrair Método com -e http.request.method

Nesta etapa, focaremos especificamente na extração de métodos de requisição HTTP do tráfego de rede usando a ferramenta de linha de comando do Wireshark, tshark. Os métodos HTTP são os verbos que indicam a ação desejada a ser realizada em um recurso, como GET para recuperar dados ou POST para enviar dados.

Antes de começarmos, vamos entender com o que estamos trabalhando:

Os métodos HTTP são componentes fundamentais das comunicações web
O Tshark nos permite examinar esses métodos diretamente dos pacotes de rede capturados
A flag -e nos permite extrair campos específicos dos dados do pacote

Vamos percorrer o processo passo a passo:

Primeiro, precisamos nos posicionar no diretório de trabalho correto onde nossos arquivos de captura são armazenados:

cd ~/project

Agora, executaremos o comando tshark para extrair os métodos HTTP do tráfego ao vivo:

sudo tshark -Y "http.request" -T fields -e http.request.method

Analisando este comando:

sudo: Nos dá as permissões necessárias para capturar o tráfego de rede
tshark: A versão de linha de comando do Wireshark
-Y "http.request": Aplica um filtro de exibição para mostrar apenas requisições HTTP
-T fields: Especifica que queremos uma saída baseada em campos (em vez de pacotes completos)
-e http.request.method: Diz ao tshark para extrair apenas o campo do método HTTP

Para ver isso em ação, geraremos algum tráfego de teste de outra janela do terminal:

curl -X GET http://example.com
curl -X POST http://example.com
curl -X DELETE http://example.com

Cada um desses comandos curl envia um método HTTP diferente para example.com, que o tshark capturará e exibirá. A flag -X no curl nos permite especificar qual método HTTP usar.

Após executar esses comandos, você deverá ver uma saída semelhante a:

GET
POST
DELETE

Esta saída mostra exatamente quais métodos HTTP foram usados no tráfego capturado, facilitando a análise dos padrões de requisição web. Os nomes dos métodos aparecem na ordem em que foram capturados pelo tshark.

Exibir em JSON com -T json

Nesta etapa, exploraremos como formatar dados de tráfego HTTP capturados como JSON usando o utilitário Tshark do Wireshark. JSON (JavaScript Object Notation) é um formato de dados leve que é fácil tanto para humanos lerem quanto para máquinas analisarem. Isso o torna ideal para analisar o tráfego de rede programaticamente.

Antes de começarmos, vamos entender por que a saída JSON é valiosa:

Organização de dados estruturados
Fácil integração com outras ferramentas e scripts
Formato padronizado para troca de dados

Primeiro, certifique-se de estar no diretório de trabalho padrão onde executaremos nossos comandos:

cd ~/project

Agora, vamos executar o Tshark para capturar requisições HTTP e exibi-las em formato JSON. Este comando combina filtragem com formatação JSON:

sudo tshark -Y "http.request" -T json -e http.request.method -e http.host -e http.request.uri

Vamos detalhar o que cada parte deste comando faz:

-Y "http.request": Este filtro diz ao Tshark para mostrar apenas pacotes de requisição HTTP
-T json: Especifica que queremos a saída em formato JSON
Campos -e: Estes extraem informações específicas de cada requisição HTTP:
- http.request.method: O método HTTP usado (GET, POST, etc.)
- http.host: O domínio do site que está sendo acessado
- http.request.uri: O caminho ou recurso específico que está sendo solicitado

Para gerar tráfego de teste que podemos capturar, abra uma segunda janela do terminal e execute estes comandos curl:

curl http://example.com
curl http://example.org/sample

Quando você executar o comando Tshark enquanto este tráfego de teste é gerado, você verá uma saída estruturada como esta:

[
  {
    "_index": "packets-1",
    "_source": {
      "layers": {
        "http.request.method": ["GET"],
        "http.host": ["example.com"],
        "http.request.uri": ["/"]
      }
    }
  },
  {
    "_index": "packets-2",
    "_source": {
      "layers": {
        "http.request.method": ["GET"],
        "http.host": ["example.org"],
        "http.request.uri": ["/sample"]
      }
    }
  }
]

Observe como cada requisição HTTP se torna um objeto JSON separado com campos claramente rotulados. Essa estrutura torna simples identificar:

Qual site foi acessado
Que tipo de requisição foi feita
Qual página ou recurso específico foi solicitado

O formato JSON é particularmente útil quando você deseja salvar esses dados para análise posterior ou alimentá-los em outras ferramentas que podem processar dados JSON automaticamente.

Resumo

Neste laboratório, você aprendeu a filtrar e analisar o tráfego HTTP usando a ferramenta de linha de comando Tshark do Wireshark. Os exercícios cobriram a captura de tráfego HTTP com -f "tcp port 80" e a geração de tráfego de teste usando curl para análise prática.

Você também praticou a filtragem de requisições HTTP com -Y "http.request" e a extração de dados específicos, como métodos HTTP, usando -e http.request.method. O laboratório demonstrou a formatação de saída em JSON com -T json, equipando você com técnicas-chave para a inspeção eficiente do tráfego de rede.