snort3/snort3Sistema multithread de detecção e prevenção de intrusão em rede com detecção baseada em regras, inspeção ciente de protocolos e análise de pcap para monitoramento de tráfego empresarial.
Snort 3 é a próxima geração do Snort IPS (Sistema de Prevenção de Intrusão). Este arquivo mostrará o que o Snort++ tem a oferecer e o guiará pelas etapas desde o download até a demonstração. Se você não conhece o Snort, deve consultar primeiro a documentação do Snort. Abordaremos os seguintes tópicos:
Esta versão do Snort++ inclui novos recursos, bem como todos os recursos do Snort 2.X e correções de bugs para a versão base do Snort, exceto conforme indicado abaixo:
Project = Snort++
Binary = snort
Version = 3.0.0 (Build 250) from 2.9.11
Aqui estão alguns recursos principais do Snort++:
Recursos adicionais no roteiro incluem:
Se você já compila o Snort, pode ter tudo o que precisa. Caso contrário, obtenha as versões mais recentes:
Pacotes adicionais fornecem recursos opcionais. Consulte o manual para mais informações.
Há um tarball de código-fonte disponível na seção Downloads em snort.org:
snort-3.0.0-a3.tar.gz
Você também pode obter o código com:
git clone https://github.com/snort3/snort3.git
Existem pacotes extras separados para cmake que fornecem recursos adicionais e demonstram como compilar plugins. O código-fonte dos extras está no repositório snort3_extra.git.
Siga estas etapas:
Se você estiver usando um clone do github:
cd snort3/
Caso contrário, faça isto:
tar zxf snort-tarball
cd snort-3.0.0*
Configure o caminho de instalação:
export my_path=/path/to/snorty
Compile e instale:
Para compilar com cmake e make, execute configure_cmake.sh. Ele criará e preencherá automaticamente um novo subdiretório chamado 'build'.
./configure_cmake.sh --prefix=$my_path
cd build
make -j $(nproc) install
Nota:
Aqui estão alguns exemplos. Se você estiver usando regras e/ou configurações do Talos, deve primeiro definir quaisquer variáveis necessárias no topo de snort.lua e snort_defaults.lua.
O Snort++ fornece muita ajuda a partir da linha de comando, incluindo:
$my_path/bin/snort --help $my_path/bin/snort --help-module suppress $my_path/bin/snort --help-config | grep thread
* Examine e faça o dump de um pcap. A seguir, substitua a.pcap pelo seu
favorito:
```shell
$my_path/bin/snort -r a.pcap
$my_path/bin/snort -L dump -d -e -q -r a.pcap
```
* Verifique uma configuração, com ou sem regras:
```shell
$my_path/bin/snort -c $my_path/etc/snort/snort.lua
$my_path/bin/snort -c $my_path/etc/snort/snort.lua -R $my_path/etc/snort/sample.rules
```
* Execute o modo IDS. A seguir, substitua pcaps/ por um caminho para um diretório
com um ou mais arquivos *.pcap:
```shell
$my_path/bin/snort -c $my_path/etc/snort/snort.lua -R $my_path/etc/snort/sample.rules \
-r a.pcap -A alert_test -n 100000
```
* Vamos suprimir 1:2123. Poderíamos editar a configuração ou simplesmente fazer isto:
```shell
$my_path/bin/snort -c $my_path/etc/snort/snort.lua -R $my_path/etc/snort/sample.rules \
-r a.pcap -A alert_test -n 100000 --lua "suppress = { { gid = 1, sid = 2123 } }"
```
* Faça tudo em um diretório com múltiplas threads de pacotes:
```shell
$my_path/bin/snort -c $my_path/etc/snort/snort.lua -R $my_path/etc/snort/sample.rules \
--pcap-filter \*.pcap --pcap-dir pcaps/ -A alert_fast --max-packet-threads 8
```
Exemplos adicionais são fornecidos em doc/usage.txt.
# TESTE DE FUZZING
O Snort inclui alvos de fuzzing do libFuzzer para testar vários componentes. Compilar
e executar fuzzers requer o Clang.
* Compile os fuzzers com AddressSanitizer:
```shell
CC=clang CXX=clang++ ./configure_cmake.sh --enable-fuzz-sanitizer --enable-fuzzers \
--enable-address-sanitizer
cd build
make fuzz -j $(nproc)
```
* Se você precisar especificar os caminhos de include e biblioteca do DAQ:
```shell
CC=clang CXX=clang++ ./configure_cmake.sh --enable-fuzz-sanitizer --enable-fuzzers \
--enable-address-sanitizer --with-daq-includes=/path/to/daq/include --with-daq-libraries=/path/to/daq/lib
cd build
make fuzz -j $(nproc)
```
* Execute um alvo de fuzzing fornecendo um diretório de corpus. Cada alvo é compilado
em `build/fuzz/`:
```shell
mkdir file_olefile_fuzz_corpus
./fuzz/file_olefile_fuzz ./file_olefile_fuzz_corpus
```
* Se as bibliotecas do DAQ não estiverem no caminho de biblioteca padrão, defina `LD_LIBRARY_PATH`:
```shell
LD_LIBRARY_PATH=/path/to/daq/lib ./fuzz/file_olefile_fuzz ./file_olefile_fuzz_corpus
```
* Pressione Ctrl+C para interromper o fuzzer. Liste os arquivos de corpus salvos com:
```shell
ls ./file_olefile_fuzz_corpus
```
* Compile com instrumentação de cobertura em vez de AddressSanitizer para medir
quais caminhos de código o fuzzer exercita:
```shell
CC=clang CXX=clang++ ./configure_cmake.sh --enable-fuzz-sanitizer --enable-fuzzers \
--enable-fuzz-coverage
cd build
make fuzz -j $(nproc)
```
* Execute a compilação de cobertura contra um corpus existente (usando `-runs=0` para reproduzir
sem gerar novas entradas):
```shell
LLVM_PROFILE_FILE="file_olefile_fuzz.profraw" ./fuzz/file_olefile_fuzz \
file_olefile_fuzz_corpus -runs=0 -detect_leaks=0
```
* Gere um relatório de cobertura HTML:
```shell
llvm-profdata merge -sparse file_olefile_fuzz.profraw -o file_olefile_fuzz.profdata
llvm-cov show -format=html -instr-profile=file_olefile_fuzz.profdata \
./fuzz/file_olefile_fuzz -output-dir=file_olefile_fuzz_cov_html
```