Sharker: onde o Wireshark termina, nós começamos

O Sharker é uma ferramenta poderosa e extensível para extrair dados valiosos de arquivos PCAP ou de interfaces ao vivo. Ele aproveita o poder do tshark para analisar eficientemente capturas de rede e aplica um sistema flexível de filtros para localizar e extrair informações interessantes.

Principais Recursos

Filtragem Extensível: Crie filtros baseados em Python para extrair qualquer dado de pacotes de rede.
Mecanismo de Filtragem Poderoso: Ative ou desative seletivamente filtros e categorias de filtros para ajustar e acelerar sua análise.
Múltiplas Fontes de Entrada: Analise arquivos .pcap, diretórios de capturas ou até mesmo tráfego de rede ao vivo de uma interface.
Saída Flexível: Salve resultados em arquivos de texto organizados, imprima no console ou ambos.

Requisitos

tshark: O companheiro de linha de comando do Wireshark é essencial. Você normalmente pode instalá-lo através do gerenciador de pacotes do seu sistema (ex.: apt-get install tshark, brew install wireshark).
Python 3
Bibliotecas Python: As bibliotecas necessárias estão listadas em requirements.txt e podem ser instaladas com pip/pipx.

Instalação

Você pode instalar o Sharker usando pipx (recomendado) ou um ambiente padrão com pip e venv.

Usando `pipx` (Recomendado)

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

# Verify the installation
sharker -h

Usando `pip` e `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

A sintaxe básica do Sharker é:

sharker [OPTIONS] [PCAP_FILE(s)]

Opções Comuns

Opções principais

Opções de filtragem

Exemplos de Uso

1. Analise um único PCAP e salve os resultados:

sharker my_capture.pcap

Isso executará todos os filtros, exceto aqueles da categoria heavy, e salvará a saída no diretório sharker_out/. Os filtros da categoria creds também serão impressos no stdout.

2. Aplique todos os filtros e tente ir o mais rápido possível:

sharker -A -F my_captures.pcap

Isso aplicará todos os filtros e enviará tudo para arquivos; nenhum resultado será impresso no console.

3. Analise um diretório de PCAPs, com foco em credenciais:

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

Este comando processa todos os arquivos PCAP no diretório especificado, mas executa apenas os filtros da categoria creds.

4. Capture tráfego ao vivo e imprima informações relacionadas a HTTP no console:

sudo sharker -i eth0 -c http -m console

Isto capturará tráfego da interface eth0, executará apenas os filtros da categoria http e imprimirá todos os resultados diretamente no terminal.

5. Liste todos os filtros disponíveis:

sharker -L

Saída de ajuda

Clique para ver a saída de ajuda 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.

O Sistema de Filtros

O poder do Sharker vem de seus filtros, localizados no diretório sharker/filters/. Cada filtro é uma classe Python que define:

name: Um nome único para o filtro.
description: Uma breve explicação do que o filtro faz.
pcap_filter: Um filtro de exibição do tshark para selecionar pacotes relevantes para este filtro.
categories: Uma lista de categorias às quais o filtro pertence (ex.: creds, dns, http). heavy pode ser usada para filtros que correspondam a muitos pacotes ou executem operações lentas.
mandatory_selectors e optional_selectors: Chaves a procurar na representação JSON do pacote para identificar os dados de interesse. O Sharker usará esses atributos para gerar a saída de dados se nenhuma função parser for definida no filtro.

Por padrão, o Sharker executa todos os filtros, exceto aqueles da categoria heavy. Você pode personalizar esse comportamento com as opções -c, -nc, -f e -nf.

Clique para ver o exemplo de extração 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

Desenvolvimento

Se você quiser contribuir com o Sharker ou desenvolver seus próprios filtros, pode configurar um ambiente de desenvolvimento.

# 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

Criando um Novo Filtro

Crie um novo arquivo Python no diretório sharker/filters/.
Nesse arquivo, crie uma classe que herde de FilterConfigBase (definida em sharker/filters/base.py).
Defina os atributos necessários (name, description, pcap_filter, etc.).
Implemente o método parser() para extrair os dados de que você precisa.
- Chame o método self.output com os dados a serem emitidos.
O Sharker descobrirá e carregará automaticamente o seu novo filtro.

Inspiração e Referências

Este projeto foi inspirado pelo trabalho dos seguintes projetos de código aberto muito bons:

`-i, --interface <IFACE>`	Captura tráfego ao vivo de uma interface de rede (ex.: `eth0`).
`-d, --pcap-dir <DIR>`	Analisa todos os arquivos PCAP em um diretório.
`-o, --output-dir <DIR>`	Especifica o diretório para os arquivos de saída (padrão: `./sharker_out`).
`-m, --output-mode <MODE>`	Define o modo de saída: `file`, `console`, `both` ou `develop` (padrão: `both`).
`-u, --unique`	Produz apenas resultados únicos.
`-F, --fast`	Configuração mais rápida (não afeta a seleção de filtros).
`-A, --all`	Ativa todos os filtros; será mais lento.

`-c, --categories <CATS>`	Uma lista separada por vírgulas de categorias de filtros para executar (ex.: `creds,http`).
`-nc, --not-categories <CATS>`	Uma lista separada por vírgulas de categorias de filtros a excluir (ex.: `heavy`). Por padrão, `heavy` é excluída.
`-f, --filters <FILTERS>`	Uma lista separada por vírgulas de filtros específicos para executar.
`-nf, --not-filters <FILTERS>`	Uma lista separada por vírgulas de filtros específicos a excluir.
`-L, --list-all-filters`	Exibe uma lista de todos os filtros disponíveis e suas descrições.
`-Lc, --list-all-filter-categories`	Exibe uma lista de todas as categorias de filtros disponíveis.
`-l, --list-filters`	Mostra os filtros que estarão ativos com as opções atuais de linha de comando.
`-v, --verbose`	Ativa o registro detalhado (verbose) para depuração.

sharker

Mais Populares