Sharker: donde termina Wireshark, nosotros empezamos

Sharker es una herramienta potente y extensible para extraer datos valiosos de archivos PCAP o de interfaces en vivo. Aprovecha el poder de tshark para analizar capturas de red de manera eficiente y aplica un sistema de filtrado flexible para localizar y extraer información interesante.

Características principales

Filtrado extensible: Crea filtros basados en Python para extraer cualquier dato de los paquetes de red.
Motor de filtrado potente: Activa o desactiva selectivamente filtros y categorías de filtros para ajustar y acelerar tu análisis.
Múltiples fuentes de entrada: Analiza archivos .pcap, directorios de capturas o incluso tráfico de red en vivo desde una interfaz.
Salida flexible: Guarda los resultados en archivos de texto organizados, imprime en la consola o ambas opciones.

Requisitos

tshark: El complemento de línea de comandos de Wireshark es esencial. Normalmente puedes instalarlo a través del gestor de paquetes de tu sistema (por ejemplo, apt-get install tshark, brew install wireshark).
Python 3
Librerías de Python: Las librerías necesarias están listadas en requirements.txt y se pueden instalar con pip/pipx.

Instalación

Puedes instalar Sharker usando pipx (recomendado) o un entorno estándar de pip y venv.

Usando `pipx` (recomendado)

# Install from this repository
pipx install git+https://github.com/synacktiv/sharker.git

# Verify the installation
sharker -h

Usando `pip` y `venv`

# Clone the repository
git clone https://github.com/synacktiv/sharker.git
cd sharker

# Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate

# Install Sharker
pip install .

# Verify the installation
sharker -h

Uso

La sintaxis básica de Sharker es:

sharker [OPTIONS] [PCAP_FILE(s)]

Opciones comunes

Opciones principales

Opciones de filtrado

Ejemplos de uso

1. Analizar un único PCAP y guardar los resultados:

sharker my_capture.pcap

Esto ejecutará todos los filtros excepto los de la categoría heavy y guardará la salida en el directorio sharker_out/. Los filtros de la categoría creds también se imprimirán en stdout.

2. Aplicar todos los filtros e intentar ir lo más rápido posible:

sharker -A -F my_captures.pcap

Esto aplicará todos los filtros y enviará toda la salida a archivos; no se imprimirán resultados en la consola.

3. Analizar un directorio de PCAPs, centrándose en credenciales:

sharker -d /path/to/pcaps -c creds

Este comando procesa todos los archivos PCAP del directorio especificado, pero solo ejecuta los filtros de la categoría creds.

4. Capturar tráfico en vivo e imprimir información relacionada con HTTP en la consola:

sudo sharker -i eth0 -c http -m console

Esto capturará tráfico de la interfaz eth0, ejecutará solo los filtros de la categoría http e imprimirá todos los resultados directamente en la terminal.

5. Listar todos los filtros disponibles:

sharker -L

Salida de ayuda

Haz clic para ver la salida de ayuda completa

$ sharker -h
Usage: sharker [OPTIONS] [PCAP[ PCAP[ ...]]

  Sharker: A reasonably fast network protocol analysis tool with extensible
  filters.

Options:
  Input Source:
    -d, --pcap-dir DIR            Path to a directory containing PCAP files to
                                  parse.
    -i, --interface IFACE         Network interface to capture live data from
                                  (e.g., eth0, wlan0).
  Output Handling:                By default, everything is written to file,
                                  and only creds category is printed to
                                  console. For very large PCAPs, advised to
                                  disable console output or at least colors,
                                  since it slows down the parsing.
    -m, --output-mode [file|console|both|develop]
                                  Which output mode to enable.  [default:
                                  both]
    -u, --unique                  Output only unique results, will gradually
                                  take more and more RAM.
    -F, --fast                    Fastest configuration (do not affect filter
                                  selection).
  Output file mode:
    -o, --output-dir DIR          Output directory.
    -op, --output-prefix NAME     Prefix to use for the output files, defaults
                                  to the PCAP/interface name.
  Output console mode:
    -P                            Send all filters to console (default in
                                  console output mode).
    -C                            Do not use colors in console output, will
                                  speed up sharker when lot of stuff is
                                  printed.
    -pf FILT[,FILT[...]]          Send specific filters output to console.
    -xpf FILT[,FILT[...]]         Do not send specific filters to console.
    -pc CAT[,CAT[...]]            Send specific filter categories to console.
    -xpc CAT[,CAT[...]]           Do not send specific categories to console.
    -nwf FILT[,FILT[...]]         Do not write filters output to file.
    -nwc CAT[,CAT[...]]           Do not write filter categories to file.
  Filter Selection:
    -A, --all                     Enable all filters, will be slower.
    -f, --filters FILT[,FILT[...]]
                                  Only run specified filters.
    -nf, --not-filters FILT[,FILT[...]]
                                  Exclude specified filters.
    -c, --categories CAT[,CAT[...]]
                                  Only run specified categories of filters.
    -nc, --not-categories CAT[,CAT[...]]
                                  Exclude specified categories of filters.
  Filter Information:
    -l, --list-filters            List filters that would be active with
                                  current filtering options.
    -L, --list-all-filters        List all available filters.
    -Lc, --list-all-filter-categories
                                  List all available filter categories.
  Debugging:
    -v, --verbose                 Verbose mode.
  -h, --help                      Show this message and exit.

El sistema de filtros

El poder de Sharker proviene de sus filtros, ubicados en el directorio sharker/filters/. Cada filtro es una clase de Python que define:

name: Un nombre único para el filtro.
description: Una breve explicación de lo que hace el filtro.
pcap_filter: Un filtro de visualización de tshark para seleccionar los paquetes relevantes para este filtro.
categories: Una lista de categorías a las que pertenece el filtro (por ejemplo, creds, dns, http). heavy puede usarse para filtros que coincidan con muchos paquetes o que realicen operaciones lentas.
mandatory_selectors y optional_selectors: Claves que se buscan en la representación JSON del paquete para identificar los datos de interés. Sharker usará estos atributos para generar datos si no se define una función parser en el filtro.

Por defecto, Sharker ejecuta todos los filtros excepto los de la categoría heavy. Puedes personalizar este comportamiento con las opciones -c, -nc, -f y -nf.

Haz clic para ver el ejemplo de extracción de hashes NTLM

from .base import FilterConfigBase


class FilterConfig(FilterConfigBase):
    name = 'ntlmssp'
    description = 'Extract Net-NTLM hashes for cracking purposes'

    categories = [
        'creds',
        'windows'
    ]

    pcap_filter = 'gss-api || ntlmssp'

    mandatory_selectors = [
        'ntlmssp'
    ]

    def __init__(self, *args, **kwargs):
        self.challenges = {}
        super().__init__(*args, **kwargs)

    def parser(self, data):
        tcp_conn = data['tcp.stream'][0]
        msg_type = int(data['ntlmssp.messagetype'][0], 16) if 'ntlmssp.messagetype' in data else 0

        if msg_type == 1:
            # NTLM NEGOTIATE: nothing to do
            pass
        elif msg_type == 2:
            # NTLM CHALLENGE
            self.challenges[tcp_conn] = data['ntlmssp.ntlmserverchallenge'][0].replace(':', '')
        elif msg_type == 3:
            if tcp_conn not in self.challenges:
                self.log.error('Found an NTLM message type 3 (AUTH), but no type 2 (CHALLENGE) was received beforehand -> check in pcap if the challenge was not sent in an unsupported by tshark manner from the server, like in a Proxy-Authenticate HTTP header.')
                return 0

            ntresp = data['ntlmssp.auth.ntresponse'][0].replace(':', '')
            lmresp = data['ntlmssp.auth.lmresponse'][0].replace(':', '')
            user = data['ntlmssp.auth.username'][0]
            domain = data['ntlmssp.auth.domain'][0]
            workstation = data['ntlmssp.auth.hostname'][0]

            ntlm_hash = ''
            if len(ntresp) == 24 * 2:
                # NTLMv1 response
                if domain != '':
                    ntlm_hash = f'{user}::{domain}:{lmresp}:{ntresp}:{self.challenges[tcp_conn]}'
                else:
                    ntlm_hash = f'{user}::{workstation}:{lmresp}:{ntresp}:{self.challenges[tcp_conn]}'
            else:
                # NTLMv2 response
                if domain != '':
                    ntlm_hash = f'{user}::{domain}:{self.challenges[tcp_conn]}:{ntresp[:32]}:{ntresp[32:]}'
                else:
                    ntlm_hash = f'{user}::{workstation}:{self.challenges[tcp_conn]}:{ntresp[:32]}:{ntresp[32:]}'

            del self.challenges[tcp_conn]
            self.output(ntlm_hash)
            return 1

        return 0

Desarrollo

Si quieres contribuir a Sharker o desarrollar tus propios filtros, puedes configurar un entorno de desarrollo.

# Clone the repository
git clone https://github.com/synacktiv/sharker.git
cd sharker

# Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate

# Install in editable mode
pip install -e .

# Now you can run sharker and your changes will be reflected immediately
sharker -h

Crear un nuevo filtro

Crea un nuevo archivo de Python en el directorio sharker/filters/.
En ese archivo, crea una clase que herede de FilterConfigBase (definida en sharker/filters/base.py).
Define los atributos requeridos (name, description, pcap_filter, etc.).
Implementa el método parser() para extraer los datos que necesites.
- Llama al método self.output con los datos para generar la salida.
Sharker descubrirá y cargará automáticamente tu nuevo filtro.

Inspiración y referencias

Este proyecto se inspiró en el trabajo de los siguientes proyectos de código abierto realmente excelentes:

`-i, --interface <IFACE>`	Captura tráfico en vivo desde una interfaz de red (por ejemplo, `eth0`).
`-d, --pcap-dir <DIR>`	Analiza todos los archivos PCAP de un directorio.
`-o, --output-dir <DIR>`	Especifica el directorio para los archivos de salida (por defecto: `./sharker_out`).
`-m, --output-mode <MODE>`	Establece el modo de salida: `file`, `console`, `both` o `develop` (por defecto: `both`).
`-u, --unique`	Muestra solo resultados únicos.
`-F, --fast`	Configuración más rápida (no afecta la selección de filtros).
`-A, --all`	Activa todos los filtros; será más lento.

`-c, --categories <CATS>`	Lista de categorías de filtros separadas por comas para ejecutar (por ejemplo, `creds,http`).
`-nc, --not-categories <CATS>`	Lista de categorías de filtros separadas por comas para excluir (por ejemplo, `heavy`). Por defecto, `heavy` está excluida.
`-f, --filters <FILTERS>`	Lista de filtros específicos separados por comas para ejecutar.
`-nf, --not-filters <FILTERS>`	Lista de filtros específicos separados por comas para excluir.
`-L, --list-all-filters`	Muestra una lista de todos los filtros disponibles y sus descripciones.
`-Lc, --list-all-filter-categories`	Muestra una lista de todas las categorías de filtros disponibles.
`-l, --list-filters`	Muestra los filtros que estarán activos con las opciones actuales de la línea de comandos.
`-v, --verbose`	Activa el registro detallado (logging) para depuración.

sharker

Más Populares