Estender o Tshark com Scripts Lua - Aprenda a Analisar Pacotes

Introdução

Neste laboratório, você aprenderá como estender as capacidades de análise de pacotes do Wireshark usando scripts Lua. Você explorará o carregamento de scripts personalizados via opções de linha de comando e a passagem de argumentos para aprimorar a funcionalidade.

Os exercícios o guiarão pela criação de scripts Lua, testando-os com o comando tshark do Wireshark e verificando a saída. Você praticará a execução de scripts com capturas vazias e aprenderá a interpretar detalhes verbosos de pacotes.

Carregar Script com -X lua_script:script.lua

Nesta etapa, você aprenderá como carregar um script Lua no Wireshark usando a opção -X. Lua é uma linguagem de script leve que se integra bem com o Wireshark, permitindo que você estenda sua funcionalidade para análise de pacotes personalizada sem modificar o programa principal.

Primeiro, vamos criar um script Lua simples no diretório de trabalho padrão. Este script servirá como nosso caso de teste básico para verificar se o Wireshark pode carregar e executar o código Lua com sucesso:

Abra um terminal e certifique-se de estar no diretório ~/project. É aqui que criaremos e armazenaremos nosso script Lua:
```
cd ~/project
```
Crie um novo arquivo de script Lua chamado script.lua usando nano. Estamos usando nano porque é simples e está disponível na maioria dos ambientes Linux:
```
nano script.lua
```
Adicione o seguinte código Lua básico para imprimir uma mensagem quando carregado. Isso demonstra a operação mais fundamental - verificar a execução do script:
```
-- Simple Wireshark Lua script
print("Wireshark Lua script loaded successfully!")
```
Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X). O script agora está pronto para ser carregado pelo Wireshark.

Agora, vamos carregar este script usando a interface de linha de comando do Wireshark. Usaremos uma combinação especial de parâmetros para testar o script sem processar o tráfego de rede real:

wireshark -X lua_script:script.lua -r /dev/null -k

Vamos detalhar o que cada parte deste comando faz:

-X lua_script:script.lua diz ao Wireshark para carregar nosso arquivo de script Lua
-r /dev/null especifica um arquivo de captura vazio (estamos apenas testando o carregamento do script, não analisando pacotes)
-k inicia a captura imediatamente sem esperar pela entrada do usuário

Quando você executar este comando, você deverá ver a mensagem "Wireshark Lua script loaded successfully!" na saída do terminal. Isso confirma que o Wireshark localizou, carregou e executou seu script Lua com sucesso. Se você não vir esta mensagem, verifique se o arquivo de script existe no local correto e não contém erros de sintaxe.

Passar Argumento com -X lua_script1:arg1

Nesta etapa, você aprenderá como passar argumentos para um script Lua no Wireshark usando a opção -X lua_script1:. Essa técnica é útil quando você deseja tornar seus scripts mais flexíveis, aceitando diferentes entradas sem modificar o próprio script a cada vez.

Primeiro, vamos entender como a passagem de argumentos funciona no ambiente Lua do Wireshark. A opção -X lua_script1: permite que você envie um valor de string para o seu script, que pode então ser acessado usando a função get_string(). Isso é semelhante a como os argumentos de linha de comando funcionam em outras linguagens de programação.

Vamos modificar nosso script Lua existente para aceitar e processar um argumento:

Abra o arquivo script.lua da etapa anterior:
```
nano ~/project/script.lua
```
Substitua o conteúdo pelo seguinte código que aceita e exibe um argumento:
```
-- Lua script with argument handling
local arg1 = get_string("lua_script1")
print("Received argument: " .. (arg1 or "no argument provided"))
```
A função get_string("lua_script1") recupera o argumento passado com -X lua_script1:. A parte or "no argument provided" fornece uma mensagem padrão se nenhum argumento for fornecido.
Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X).

Agora, vamos executar o script com um argumento:

wireshark -X lua_script:script.lua -X lua_script1:test123 -r /dev/null -k

Analisando este comando:

-X lua_script:script.lua carrega nosso arquivo de script Lua
-X lua_script1:test123 passa "test123" como um argumento para o script
-r /dev/null especifica um arquivo de captura vazio (já que estamos apenas testando o script)
-k inicia a captura imediatamente sem esperar pela entrada do usuário

Você deve ver uma saída semelhante a:

Received argument: test123

Para verificar se o script funciona com diferentes entradas, tente executá-lo com outro valor:

wireshark -X lua_script:script.lua -X lua_script1:another_value -r /dev/null -k

Isso demonstra como você pode reutilizar o mesmo script com diferentes argumentos, tornando sua análise mais dinâmica e adaptável a diferentes cenários.

Processar Arquivo com -r capture.pcap

Nesta etapa, você aprenderá como processar um arquivo de captura de rede pré-gravado usando a ferramenta de linha de comando Tshark do Wireshark com a opção -r. Isso é útil quando você deseja analisar o tráfego de rede salvo em vez de capturar pacotes ao vivo.

Primeiro, precisamos de um arquivo de captura de pacotes de amostra para trabalhar. Arquivos PCAP contêm dados reais de tráfego de rede que podemos analisar. Vamos baixar uma amostra padrão de tráfego HTTP:

Baixe um arquivo pcap de amostra para o seu diretório do projeto:

wget https://wiki.wireshark.org/SampleCaptures/http.cap -O ~/project/capture.pcap

Verifique se o arquivo foi baixado corretamente, verificando seu tamanho e localização:
```
ls -lh ~/project/capture.pcap
```

Agora, modificaremos nosso script Lua para analisar este arquivo de captura. O script contará todos os pacotes no arquivo e relatará o total. Veja como atualizá-lo:

Abra o script para edição:
```
nano ~/project/script.lua
```

Atualize o conteúdo com esta lógica de contagem de pacotes:

-- Packet counter script
local arg1 = get_string("lua_script1") or "default"
local packet_count = 0

-- Called for each packet
function tap.packet(pinfo,tvb)
    packet_count = packet_count + 1
end

-- Called after processing all packets
function tap.draw()
    print("Argument received: " .. arg1)
    print("Total packets processed: " .. packet_count)
end

-- Register the tap
tap = Listener.new()

Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X).

Agora, vamos executar nosso script contra o arquivo de captura. Este comando diz ao Tshark para:

Usar nosso script Lua (-X lua_script)
Passar um argumento para o script (-X lua_script1)
Processar nosso arquivo baixado (-r)
Executar silenciosamente sem GUI (-q)

wireshark -X lua_script:script.lua -X lua_script1:analysis -r ~/project/capture.pcap -q

Após o processamento, você deve ver a saída mostrando:

O argumento que passamos para o script
O número total de pacotes contados

Exemplo de saída:

Argument received: analysis
Total packets processed: 83

Verificar Saída Personalizada com -V

Nesta etapa, exploraremos como verificar a saída do seu script Lua usando a opção -V (verbose) do Wireshark. Isso é particularmente útil quando você precisa ver resultados de análise detalhados do seu script personalizado, juntamente com as informações padrão do pacote.

Primeiro, vamos aprimorar nosso script Lua para fornecer estatísticas mais significativas. Vamos modificá-lo para rastrear diferentes tipos de protocolo:

Abra o script para edição no nano:
```
nano ~/project/script.lua
```

Atualize o script com esta versão aprimorada que conta pacotes HTTP e TCP:

-- Enhanced packet analyzer
local arg1 = get_string("lua_script1") or "default"
local stats = {
    total = 0,
    http = 0,
    tcp = 0
}

function tap.packet(pinfo,tvb)
    stats.total = stats.total + 1
    if pinfo.visited then return end

    if pinfo.protocols:find("http") then
        stats.http = stats.http + 1
    end
    if pinfo.protocols:find("tcp") then
        stats.tcp = stats.tcp + 1
    end
end

function tap.draw()
    print("=== Analysis Report ===")
    print("Argument received: " .. arg1)
    print("Total packets: " .. stats.total)
    print("HTTP packets: " .. stats.http)
    print("TCP packets: " .. stats.tcp)
    print("======================")
end

tap = Listener.new()

Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X).

Agora, vamos executar nosso script com a saída verbose habilitada. A flag -V diz ao Wireshark para exibir todas as informações disponíveis, incluindo a saída do nosso script personalizado:

wireshark -X lua_script:script.lua -X lua_script1:final_run -r ~/project/capture.pcap -q -V

Você deve ver uma saída semelhante a esta, mostrando os detalhes do pacote e a análise do seu script:

=== Analysis Report ===
Argument received: final_run
Total packets: 83
HTTP packets: 10
TCP packets: 83
======================

Para salvar esta saída para referência futura, redirecione-a para um arquivo:

wireshark -X lua_script:script.lua -X lua_script1:final_run -r ~/project/capture.pcap -q -V > ~/project/analysis_output.txt

Finalmente, verifique a saída salva visualizando o conteúdo do arquivo:

cat ~/project/analysis_output.txt

Resumo

Neste laboratório, você aprendeu como estender a funcionalidade do Wireshark usando scripts Lua por meio de operações de linha de comando. As etapas principais incluíram o carregamento de scripts Lua com a opção -X lua_script:script.lua e o teste deles com a interface CLI do Wireshark.

Além disso, você explorou a passagem de argumentos para scripts Lua usando -X lua_script1:arg1, demonstrando como criar scripts flexíveis que aceitam parâmetros externos. Essa técnica aprimora as capacidades de análise de pacotes do Wireshark por meio de extensões Lua personalizáveis.