Extender Tshark con Scripts Lua

Introducción

En este laboratorio, aprenderá cómo extender las capacidades de análisis de paquetes de Wireshark utilizando scripting en Lua. Explorará cómo cargar scripts personalizados a través de opciones de línea de comandos y pasar argumentos para mejorar la funcionalidad.

Los ejercicios lo guiarán a través de la creación de scripts en Lua, la prueba de ellos con el comando tshark de Wireshark y la verificación de la salida. Practicará la ejecución de scripts con capturas vacías y aprenderá a interpretar los detalles detallados de los paquetes.

Cargar script con -X lua_script:script.lua

En este paso, aprenderá cómo cargar un script Lua en Wireshark utilizando la opción -X. Lua es un lenguaje de scripting ligero que se integra bien con Wireshark, lo que le permite extender su funcionalidad para el análisis personalizado de paquetes sin modificar el programa principal.

Primero, creemos un simple script Lua en el directorio de trabajo predeterminado. Este script servirá como nuestro caso de prueba básico para verificar que Wireshark puede cargar y ejecutar código Lua correctamente:

Abra una terminal y asegúrese de estar en el directorio ~/project. Aquí es donde crearemos y almacenaremos nuestro script Lua:
```
cd ~/project
```
Cree un nuevo archivo de script Lua llamado script.lua utilizando nano. Estamos usando nano porque es simple y está disponible en la mayoría de los entornos Linux:
```
nano script.lua
```
Agregue el siguiente código Lua básico para imprimir un mensaje cuando se cargue. Esto demuestra la operación más fundamental: verificar la ejecución del script.
```
-- Simple Wireshark Lua script
print("Wireshark Lua script loaded successfully!")
```
Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X). El script ya está listo para ser cargado por Wireshark.

Ahora carguemos este script utilizando la interfaz de línea de comandos de Wireshark. Usaremos una combinación especial de parámetros para probar el script sin procesar tráfico de red real:

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

Desglosemos lo que hace cada parte de este comando:

-X lua_script:script.lua le dice a Wireshark que cargue nuestro archivo de script Lua.
-r /dev/null especifica un archivo de captura vacío (solo estamos probando la carga del script, no analizando paquetes).
-k inicia la captura inmediatamente sin esperar la entrada del usuario.

Cuando ejecute este comando, debería ver el mensaje "Wireshark Lua script loaded successfully!" en la salida de la terminal. Esto confirma que Wireshark encontró, cargó y ejecutó correctamente su script Lua. Si no ve este mensaje, verifique que el archivo del script exista en la ubicación correcta y no contenga errores de sintaxis.

Pasar argumento con -X lua_script1:arg1

En este paso, aprenderá cómo pasar argumentos a un script Lua en Wireshark utilizando la opción -X lua_script1:. Esta técnica es útil cuando desea hacer que sus scripts sean más flexibles al aceptar diferentes entradas sin modificar el script en sí cada vez.

Primero, entendamos cómo funciona el paso de argumentos en el entorno Lua de Wireshark. La opción -X lua_script1: le permite enviar un valor de cadena a su script, que luego se puede acceder utilizando la función get_string(). Esto es similar a cómo funcionan los argumentos de línea de comandos en otros lenguajes de programación.

Modifiquemos nuestro script Lua existente para aceptar y procesar un argumento:

Abra el archivo script.lua del paso anterior:
```
nano ~/project/script.lua
```
Reemplace el contenido con el siguiente código que acepta y muestra un argumento:
```
-- Lua script with argument handling
local arg1 = get_string("lua_script1")
print("Received argument: " .. (arg1 or "no argument provided"))
```
La función get_string("lua_script1") recupera el argumento pasado con -X lua_script1:. La parte or "no argument provided" proporciona un mensaje predeterminado si no se dio ningún argumento.
Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X).

Ahora ejecutemos el script con un argumento:

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

Desglosando este comando:

-X lua_script:script.lua carga nuestro archivo de script Lua.
-X lua_script1:test123 pasa "test123" como argumento al script.
-r /dev/null especifica un archivo de captura vacío (ya que solo estamos probando el script).
-k inicia la captura inmediatamente sin esperar la entrada del usuario.

Debería ver una salida similar a:

Received argument: test123

Para verificar que el script funcione con diferentes entradas, intente ejecutarlo con otro valor:

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

Esto demuestra cómo puede reutilizar el mismo script con diferentes argumentos, lo que hace que su análisis sea más dinámico y adaptable a diferentes escenarios.

Procesar archivo con -r capture.pcap

En este paso, aprenderá cómo procesar un archivo de captura de red previamente grabado utilizando la herramienta de línea de comandos de Wireshark, Tshark, con la opción -r. Esto es útil cuando desea analizar el tráfico de red guardado en lugar de capturar paquetes en tiempo real.

Primero, necesitamos un archivo de captura de paquetes de muestra con el que trabajar. Los archivos PCAP contienen datos reales de tráfico de red que podemos analizar. Descarguemos una muestra estándar de tráfico HTTP:

Descargue un archivo pcap de muestra en su directorio de proyecto:

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

Verifique que el archivo se haya descargado correctamente comprobando su tamaño y ubicación:
```
ls -lh ~/project/capture.pcap
```

Ahora modificaremos nuestro script Lua para analizar este archivo de captura. El script contará todos los paquetes en el archivo y reportará el total. Así es como actualizarlo:

Abra el script para editarlo:
```
nano ~/project/script.lua
```

Actualice el contenido con esta lógica de conteo de paquetes:

-- 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()

Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X).

Ahora ejecutemos nuestro script en el archivo de captura. Este comando le dice a Tshark que:

Utilice nuestro script Lua (-X lua_script)
Pase un argumento al script (-X lua_script1)
Procese nuestro archivo descargado (-r)
Se ejecute en silencio sin interfaz gráfica (-q)

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

Después del procesamiento, debería ver una salida que muestre:

El argumento que le pasamos al script
El número total de paquetes contados

Ejemplo de salida:

Argument received: analysis
Total packets processed: 83

Verificar salida personalizada con -V

En este paso, exploraremos cómo verificar la salida de su script Lua utilizando la opción -V (detallada) de Wireshark. Esto es especialmente útil cuando necesita ver los resultados de análisis detallados de su script personalizado junto con la información estándar de los paquetes.

Primero, mejoremos nuestro script Lua para proporcionar estadísticas más significativas. Lo modificaremos para realizar un seguimiento de diferentes tipos de protocolos:

Abra el script para editarlo en nano:
```
nano ~/project/script.lua
```

Actualice el script con esta versión mejorada que cuenta los paquetes HTTP y 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()

Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X).

Ahora ejecutemos nuestro script con la salida detallada habilitada. La bandera -V le dice a Wireshark que muestre toda la información disponible, incluyendo la salida de nuestro script personalizado:

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

Debería ver una salida similar a esta, que muestra tanto los detalles de los paquetes como el análisis de su script:

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

Para guardar esta salida para referencia futura, rediríjala a un archivo:

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

Finalmente, verifique la salida guardada viendo el contenido del archivo:

cat ~/project/analysis_output.txt

Resumen

En este laboratorio, has aprendido cómo extender la funcionalidad de Wireshark utilizando scripts Lua a través de operaciones de línea de comandos. Los pasos clave incluyeron cargar scripts Lua con la opción -X lua_script:script.lua y probarlos con la interfaz de línea de comandos (CLI, por sus siglas en inglés) de Wireshark.

Además, has explorado cómo pasar argumentos a los scripts Lua utilizando -X lua_script1:arg1, demostrando cómo crear scripts flexibles que acepten parámetros externos. Esta técnica mejora las capacidades de análisis de paquetes de Wireshark a través de extensiones Lua personalizables.