Como construir um SIEM com Suricata e Elastic Stack no Rocky Linux 8

Introdução

Os tutoriais anteriores nesta série guiaram você na instalação, configuração e execução do Suricata como um sistema de Detecção de Intrusões (IDS) e Prevenção de Intrusões (IPS). Você também aprendeu sobre as regras do Suricata e como criar as suas próprias.

Neste tutorial, você irá explorar como integrar o Suricata com o Elasticsearch, Kibana e Filebeat para começar a criar sua própria ferramenta de Gerenciamento de Informações e Eventos de Segurança (SIEM) usando o stack Elastic e o Rocky Linux 8. As ferramentas SIEM são utilizadas para coletar, agregar, armazenar e analisar dados de eventos para buscar ameaças de segurança e atividades suspeitas em suas redes e servidores.

Os componentes que você irá utilizar para construir seu próprio SIEM são:

• Elasticsearch para armazenar, indexar, correlacionar e buscar os eventos de segurança provenientes do seu servidor Suricata.
• Kibana para exibir e navegar pelos registros de eventos de segurança armazenados no Elasticsearch.
• Filebeat para analisar o arquivo de log eve.json do Suricata e enviar cada evento para o Elasticsearch para processamento.
• Suricata para escanear o tráfego da sua rede em busca de eventos suspeitos e, em seguida, registrar ou descartar pacotes inválidos.

Primeiro, você irá instalar e configurar o Elasticsearch e o Kibana com algumas configurações de autenticação específicas. Em seguida, você adicionará o Filebeat ao seu sistema Suricata para enviar os logs eve.json para o Elasticsearch.

Por fim, você aprenderá como se conectar ao Kibana usando SSH e seu navegador da web, e então carregar e interagir com os painéis do Kibana que mostram os eventos e alertas do Suricata.

Pré-requisitos

Se você esteve acompanhando esta série de tutoriais, então você já deve ter o Suricata em execução em um servidor Rocky Linux. Este servidor será referido como seu servidor Suricata.

• Se você ainda precisa instalar o Suricata, então você pode seguir este tutorial que explica Como Instalar o Suricata no Rocky Linux 8.

Você também precisará de um segundo servidor para hospedar o Elasticsearch e o Kibana. Este servidor será referido como seu servidor Elasticsearch. Deve ser um servidor Rocky Linux 8 com:

• 4GB de RAM e 2 CPUs configurados com um usuário sudo não-root. Você pode conseguir isso seguindo a Configuração Inicial do Servidor com Rocky Linux 8.

Para os fins deste tutorial, ambos os servidores devem ser capazes de se comunicar usando endereços IP privados. Você pode usar uma VPN como o WireGuard para conectar seus servidores, ou usar um provedor de nuvem que tenha rede privada entre os hosts. Você também pode optar por executar o Elasticsearch, Kibana, Filebeat e Suricata no mesmo servidor para experimentar.

Passo 1 — Instalando Elasticsearch e Kibana

O primeiro passo deste tutorial é instalar o Elasticsearch e o Kibana no seu servidor Elasticsearch. Para começar, adicione a chave GPG da Elastic ao seu servidor com o seguinte comando:

sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Em seguida, crie um arquivo elasticsearch.repo no diretório /etc/yum/yum.repos.d com o seguinte conteúdo, usando o vi ou o editor de sua preferência. Isso garante que os repositórios upstream do Elasticsearch serão usados ao instalar novos pacotes via yum:

sudo vi /etc/yum.repos.d/elasticsearch.repo

[elasticsearch]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md

Se estiver usando o vi, quando terminar de fazer as alterações, pressione ESC e depois :x para escrever as alterações no arquivo e sair.

Agora, instale o Elasticsearch e o Kibana usando o comando dnf. Pressione Y para aceitar quaisquer prompts sobre as impressões digitais da chave GPG:

sudo dnf install --enablerepo=elasticsearch elasticsearch kibana

A opção --enablerepo é usada para substituir a configuração padrão desabilitada no arquivo /etc/yum.repos.d/elasticsearch.repo. Esta abordagem garante que os pacotes Elasticsearch e Kibana não sejam atualizados acidentalmente quando você instala outras atualizações de pacotes no seu servidor.

Depois de concluir a instalação dos pacotes, encontre e registre o endereço IP privado do seu servidor usando o comando ip address show:

ip -brief address show

Você receberá uma saída como a seguinte:

Output
lo               UNKNOWN        127.0.0.1/8 ::1/128
eth0             UP             159.89.122.115/20 10.20.0.8/16 2604:a880:cad:d0::e56:8001/64 fe80::b832:69ff:fe46:7e5d/64
eth1             UP             10.137.0.5/16 fe80::b883:5bff:fe19:43f3/64

A interface de rede privada nesta saída é o dispositivo eth1 destacado, com o endereço IPv4 10.137.0.5. O nome do seu dispositivo e os endereços IP serão diferentes. Independentemente do nome do seu dispositivo e do endereço IP privado, o endereço será de um dos seguintes blocos reservados:

• 10.0.0.0 a 10.255.255.255 (prefixo 10/8)
• 172.16.0.0 a 172.31.255.255 (prefixo 172.16/12)
• 192.168.0.0 a 192.168.255.255 (prefixo 192.168/16)

Registre o endereço IP privado do seu servidor Elasticsearch (neste caso 10.137.0.5). Este endereço será referido como your_private_ip no restante deste tutorial. Também observe o nome da interface de rede, neste caso eth1. Na próxima parte deste tutorial, você configurará o Elasticsearch e o Kibana para ouvirem conexões no endereço IP privado provenientes do seu servidor Suricata.

Passo 2 — Configurando o Elasticsearch

O Elasticsearch está configurado para aceitar apenas conexões locais por padrão. Além disso, não possui autenticação habilitada, então ferramentas como o Filebeat não poderão enviar logs para ele. Nesta seção do tutorial, você configurará as configurações de rede para o Elasticsearch e então habilitará o módulo de segurança xpack integrado ao Elasticsearch.

Configurando a Rede do Elasticsearch

Como seus servidores Elasticsearch e Suricata são separados, você precisará configurar o Elasticsearch para ouvir conexões em sua interface de rede privada.

Abra o arquivo /etc/elasticsearch/elasticsearch.yml usando o vi ou seu editor preferido:

sudo vi /etc/elasticsearch/elasticsearch.yml

Encontre a linha comentada #network.host: 192.168.0.1 entre as linhas 50–60 e adicione uma nova linha após ela que configure a configuração network.bind_host, conforme destacado abaixo:

# Por padrão, o Elasticsearch só é acessível no localhost. Defina um endereço diferente
# aqui para expor este nó na rede:
#
#network.host: 192.168.0.1
network.bind_host: ["127.0.0.1", "your_private_ip"]
#
# Por padrão, o Elasticsearch escuta o tráfego HTTP na primeira porta livre que
# encontra a partir de 9200. Defina uma porta HTTP específica aqui:

Substitua seu IP privado pelo endereço seu_ip_privado. Esta linha garantirá que o Elasticsearch ainda esteja disponível em seu endereço local para que o Kibana possa alcançá-lo, bem como no endereço IP privado do seu servidor.

Em seguida, vá para o final do arquivo usando o atalho vi SHIFT+G.

Adicione as seguintes linhas destacadas ao final do arquivo:

. . .
discovery.type: single-node
xpack.security.enabled: true

A configuração discovery.type permite que o Elasticsearch seja executado como um único nó, em oposição a um cluster de outros servidores Elasticsearch. A configuração xpack.security.enabled ativa algumas das funcionalidades de segurança incluídas no Elasticsearch.

Salve e feche o arquivo quando terminar de editá-lo.

Por fim, adicione regras de firewall para garantir que seu servidor Elasticsearch seja acessível em sua interface de rede privada. Se você seguiu os tutoriais pré-requisitos e está usando o firewalld, execute os seguintes comandos:

sudo firewall-cmd --permanent --zone=internal --change-interface=eth1
sudo firewall-cmd --permanent --zone=internal --add-service=elasticsearch
sudo firewall-cmd --permanent --zone=internal --add-service=kibana
sudo systemctl reload firewalld.service

Substitua o nome da sua interface de rede privada no lugar de eth1 no primeiro comando se o seu for diferente. Esse comando altera as regras da interface para usar a zona internal do Firewalld, que é mais permissiva do que a zona padrão public.

Os próximos comandos adicionam regras para permitir o tráfego do Elasticsearch nas portas 9200 e 9300, juntamente com o tráfego do Kibana na porta 5601.

O comando final recarrega o serviço do Firewalld com as novas regras permanentes em vigor.

Em seguida, você iniciará o daemon do Elasticsearch e, em seguida, configurará senhas para uso com o módulo de segurança xpack.

Iniciando o Elasticsearch

Agora que você configurou a rede e as configurações de segurança do xpack para o Elasticsearch, você precisa iniciá-lo para que as alterações tenham efeito.

Execute o seguinte comando systemctl para iniciar o Elasticsearch:

sudo systemctl start elasticsearch.service

Depois que o Elasticsearch terminar de iniciar, você pode continuar para a próxima seção deste tutorial, onde gerará senhas para os usuários padrão integrados ao Elasticsearch.

Configurando Senhas do Elasticsearch

Agora que você habilitou a configuração xpack.security.enabled, você precisa gerar senhas para os usuários padrão do Elasticsearch. O Elasticsearch inclui uma ferramenta no diretório /usr/share/elasticsearch/bin que pode gerar automaticamente senhas aleatórias para esses usuários.

Execute o seguinte comando para cd até o diretório e depois gerar senhas aleatórias para todos os usuários padrão:

cd /usr/share/elasticsearch/bin
sudo ./elasticsearch-setup-passwords auto

Você receberá uma saída como a seguinte. Quando solicitado a continuar, pressione y e depois RETURN ou ENTER:

Initiating the setup of passwords for reserved users elastic,apm_system,kibana,kibana_system,logstash_system,beats_system,remote_monitoring_user.
The passwords will be randomly generated and printed to the console.
Please confirm that you would like to continue [y/N]y


Changed password for user apm_system
PASSWORD apm_system = eWqzd0asAmxZ0gcJpOvn

Changed password for user kibana_system
PASSWORD kibana_system = 1HLVxfqZMd7aFQS6Uabl

Changed password for user kibana
PASSWORD kibana = 1HLVxfqZMd7aFQS6Uabl

Changed password for user logstash_system
PASSWORD logstash_system = wUjY59H91WGvGaN8uFLc

Changed password for user beats_system
PASSWORD beats_system = 2p81hIdAzWKknhzA992m

Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = 85HF85Fl6cPslJlA8wPG

Changed password for user elastic
PASSWORD elastic = 6kNbsxQGYZ2EQJiqJpgl

Você não poderá executar a ferramenta novamente, então certifique-se de registrar essas senhas em um local seguro. Você precisará usar a senha do usuário kibana_system na próxima seção deste tutorial, e a senha do usuário elastic na etapa Configurando o Filebeat deste tutorial.

Neste ponto do tutorial, você concluiu a configuração do Elasticsearch. A próxima seção explica como configurar as configurações de rede do Kibana e o módulo de segurança xpack.

Passo 3 — Configurando o Kibana

Na seção anterior deste tutorial, você configurou o Elasticsearch para ouvir conexões no endereço IP privado do seu servidor Elasticsearch. Você precisará fazer o mesmo para o Kibana, para que o Filebeat no seu servidor Suricata possa alcançá-lo.

Primeiro, você habilitará a funcionalidade de segurança do xpack no Kibana gerando alguns segredos que o Kibana usará para armazenar dados no Elasticsearch. Em seguida, você configurará as configurações de rede e autenticação do Kibana para se conectar ao Elasticsearch.

Habilitando xpack.security no Kibana

Para começar com as configurações de segurança do xpack no Kibana, você precisa gerar algumas chaves de criptografia. O Kibana usa essas chaves para armazenar dados de sessão (como cookies), bem como vários painéis salvos e visualizações de dados no Elasticsearch.

Você pode gerar as chaves de criptografia necessárias usando o utilitário kibana-encryption-keys que está incluído no diretório /usr/share/kibana/bin. Execute o seguinte para cd para o diretório e depois gerar as chaves:

cd /usr/share/kibana/bin/
sudo ./kibana-encryption-keys generate -q --force

A bandeira -q suprime as instruções da ferramenta, e a bandeira --force garantirá que você crie novas chaves. Você deverá receber uma saída como a seguinte:

Output
xpack.encryptedSavedObjects.encryptionKey: 66fbd85ceb3cba51c0e939fb2526f585
xpack.reporting.encryptionKey: 9358f4bc7189ae0ade1b8deeec7f38ef
xpack.security.encryptionKey: 8f847a594e4a813c4187fa93c884e92b

Copie essas três chaves para algum lugar seguro. Agora, você irá adicioná-las ao arquivo de configuração /etc/kibana/kibana.yml do Kibana.

Abra o arquivo usando vi ou seu editor preferido:

sudo vi /etc/kibana/kibana.yml

Vá para o final do arquivo usando o atalho do vi SHIFT+G. Cole as três linhas do xpack que você copiou no final do arquivo:

. . .

# Especifica a localidade a ser usada para todas as strings localizáveis, datas e formatos de números.
# Os idiomas suportados são os seguintes: Inglês - en, por padrão, Chinês - zh-CN.
#i18n.locale: "en"

xpack.encryptedSavedObjects.encryptionKey: 66fbd85ceb3cba51c0e939fb2526f585
xpack.reporting.encryptionKey: 9358f4bc7189ae0ade1b8deeec7f38ef
xpack.security.encryptionKey: 8f847a594e4a813c4187fa93c884e92b

Mantenha o arquivo aberto e prossiga para a próxima seção onde você irá configurar as configurações de rede do Kibana.

Configurando a Rede do Kibana

Para configurar a rede do Kibana para que ele esteja disponível no endereço IP privado do seu servidor Elasticsearch, encontre a linha comentada #server.host: "localhost" no arquivo /etc/kibana/kibana.yml. A linha está perto do início do arquivo. Adicione uma nova linha após ela com o endereço IP privado do seu servidor, como destacado abaixo:

# O Kibana é servido por um servidor de back-end. Esta configuração especifica a porta a ser usada.
#server.port: 5601

# Especifica o endereço ao qual o servidor Kibana se ligará. Endereços IP e nomes de host são valores válidos.
# O padrão é 'localhost', o que normalmente significa que máquinas remotas não poderão se conectar.
# Para permitir conexões de usuários remotos, defina este parâmetro para um endereço que não seja loopback.
#server.host: "localhost"
server.host: "your_private_ip"

Substitua seu IP privado no lugar do endereço seu_ip_privado.

Salve e feche o arquivo quando terminar de editá-lo. Em seguida, você precisará configurar o nome de usuário e senha que o Kibana usa para se conectar ao Elasticsearch.

Configurando Credenciais do Kibana

Há duas maneiras de definir o nome de usuário e senha que o Kibana usa para autenticar no Elasticsearch. A primeira é editar o arquivo de configuração /etc/kibana/kibana.yml e adicionar os valores lá. O segundo método é armazenar os valores no keystore do Kibana, que é um arquivo ofuscado que o Kibana pode usar para armazenar segredos.

Neste tutorial, usaremos o método do keystore, pois evita a edição direta do arquivo de configuração do Kibana.

Para adicionar um segredo ao keystore usando o utilitário kibana-keystore, primeiro cd para o diretório /usr/share/kibana/bin. Em seguida, execute o seguinte comando para definir o nome de usuário para o Kibana:

cd /usr/share/kibana/bin
sudo ./kibana-keystore add elasticsearch.username

Você receberá um prompt como o seguinte:

Enter value for elasticsearch.username: *************

Digite kibana_system quando solicitado, seja copiando e colando ou digitando o nome de usuário cuidadosamente. Cada caractere que você digitar será mascarado com um caractere asterisco *. Pressione ENTER ou RETURN quando terminar de inserir o nome de usuário.

Agora repita o processo, desta vez para salvar a senha. Certifique-se de copiar a senha para o usuário kibana_system que você gerou na seção anterior deste tutorial. Para referência, neste tutorial, a senha de exemplo é 1HLVxfqZMd7aFQS6Uabl.

Execute o seguinte comando para definir a senha:

sudo ./kibana-keystore add elasticsearch.password

Quando solicitado, cole a senha para evitar quaisquer erros de transcrição:

Enter value for elasticsearch.password: ********************

Iniciando o Kibana

Agora que você configurou a rede e as configurações de segurança xpack para o Kibana, além de adicionar credenciais ao keystore, você precisa iniciá-lo para que as alterações tenham efeito.

Execute o seguinte comando systemctl para reiniciar o Kibana:

sudo systemctl start kibana.service

Depois que o Kibana iniciar, você pode continuar para a próxima seção deste tutorial, onde configurará o Filebeat em seu servidor Suricata para enviar seus logs para o Elasticsearch.

Passo 4 — Instalando o Filebeat

Agora que seus processos do Elasticsearch e do Kibana estão configurados com as definições de rede e autenticação corretas, o próximo passo é instalar e configurar o Filebeat no seu servidor Suricata.

Para começar a instalação do Filebeat, adicione a chave GPG da Elastic ao seu servidor Suricata com o seguinte comando:

sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Em seguida, crie um arquivo elasticsearch.repo no seu diretório /etc/yum/repos.d com os seguintes conteúdos, usando vi ou seu editor preferido:

sudo vi /etc/yum.repos.d/elasticsearch.repo

[elasticsearch]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md

Quando terminar as alterações, salve e feche o arquivo. Agora instale o pacote Filebeat usando o comando dnf:

sudo dnf install --enablerepo=elasticsearch filebeat

A seguir, você precisará configurar o Filebeat para conectar tanto ao Elasticsearch quanto ao Kibana. Abra o arquivo de configuração /etc/filebeat/filebeat.yml usando vi ou seu editor preferido:

sudo vi /etc/filebeat/filebeat.yml

Encontre a seção Kibana do arquivo por volta da linha 100. Adicione uma linha após a linha comentada #host: "localhost:5601" que aponte para o IP privado e a porta da sua instância do Kibana:

. . .
# A partir da versão 6.0.0 do Beats, os painéis são carregados via API do Kibana.
# Isso requer uma configuração de endpoint do Kibana.
setup.kibana:

  # Host do Kibana
  # O esquema e a porta podem ser omitidos e serão definidos como padrão (http e 5601)
  # Caso você especifique um caminho adicional, o esquema é necessário: http://localhost:5601/caminho
  # Endereços IPv6 devem sempre ser definidos como: https://[2001:db8::1]:5601
  #host: "localhost:5601"
  host: "your_private_ip:5601"

. . .

Essa alteração garantirá que o Filebeat possa se conectar ao Kibana para criar os vários índices SIEM, dashboards e pipelines de processamento no Elasticsearch para lidar com os seus logs do Suricata.

Em seguida, encontre a seção Saída do Elasticsearch do arquivo por volta da linha 130 e edite as configurações hosts, username e password para corresponder aos valores do seu servidor Elasticsearch:

output.elasticsearch:
  # Matriz de hosts para conectar-se.
  hosts: ["your_private_ip:9200"]

  # Protocolo - seja `http` (padrão) ou `https`.
  #protocol: "https"

  # Credenciais de autenticação - seja chave de API ou nome de usuário/senha.
  #api_key: "id:api_key"
  username: "elastic"
password: "6kNbsxQGYZ2EQJiqJpgl"

. . .

Substitua pelo endereço IP privado do seu servidor Elasticsearch na linha hosts. Descomente o campo username e deixe-o configurado como usuário elastic. Altere o campo password de changeme para a senha do usuário elastic que você gerou na seção Configurando Senhas do Elasticsearch deste tutorial.

Salve e feche o arquivo quando terminar de editá-lo. Em seguida, habilite o módulo Suricata integrado do Filebeat com o seguinte comando:

sudo filebeat modules enable suricata

Agora que o Filebeat está configurado para se conectar ao Elasticsearch e Kibana, com o módulo Suricata habilitado, o próximo passo é carregar os dashboards e pipelines SIEM no Elasticsearch.

Execute o comando filebeat setup. Pode levar alguns minutos para carregar tudo:

sudo filebeat setup

Uma vez que o comando terminar, você deve receber uma saída como a seguinte:

Output
Overwriting ILM policy is disabled. Set `setup.ilm.overwrite: true` for enabling.

Index setup finished.
Loading dashboards (Kibana must be running and reachable)
Loaded dashboards
Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead.
See more: https://www.elastic.co/guide/en/machine-learning/current/index.html
It is not possble to load ML jobs into an Elasticsearch 8.0.0 or newer using the Beat.
Loaded machine learning job configurations
Loaded Ingest pipelines

Se não houver erros, use o comando systemctl para iniciar o Filebeat. Ele começará a enviar eventos do log eve.json do Suricata para o Elasticsearch assim que estiver em execução.

sudo systemctl start filebeat.service

Agora que você configurou o Filebeat, o Kibana e o Elasticsearch para processar seus logs do Suricata, o último passo deste tutorial é conectar-se ao Kibana e explorar os painéis do SIEM.

Passo 5 — Navegando nos Painéis do SIEM do Kibana

O Kibana é o componente gráfico da pilha Elastic. Você usará o Kibana com seu navegador para explorar os dados de eventos e alertas do Suricata. Como você configurou o Kibana para estar disponível apenas pelo endereço IP privado do seu servidor Elasticsearch, você precisará usar um túnel SSH para se conectar ao Kibana.

Conectando-se ao Kibana com SSH

O SSH tem uma opção -L que permite encaminhar o tráfego de rede de uma porta local sobre sua conexão para um endereço IP e porta remotos em um servidor. Você usará essa opção para encaminhar o tráfego do seu navegador para sua instância do Kibana.

No Linux, macOS e versões atualizadas do Windows 10 e superiores, você pode usar o cliente SSH integrado para criar o túnel. Você usará este comando sempre que quiser se conectar ao Kibana. Você pode fechar esta conexão a qualquer momento e, em seguida, executar o comando SSH novamente para reestabelecer o túnel.

Execute o seguinte comando em um terminal em seu computador local ou laptop para criar o túnel SSH para o Kibana:

ssh -L 5601:your_private_ip:5601 sammy@203.0.113.5 -N

Os vários argumentos para o SSH são:

• A flag -L encaminha o tráfego para o seu sistema local na porta 5601 para o servidor remoto.
• A parte seu_ip_privado:5601 do comando especifica o serviço em seu servidor Elasticsearch para onde seu tráfego será encaminhado. Neste caso, esse serviço é o Kibana. Certifique-se de substituir o endereço IP privado do seu servidor Elasticsearch no lugar de seu_ip_privado.
• O endereço 203.0.113.5 é o endereço IP público que você usa para se conectar e administrar seu servidor. Substitua o endereço IP público do seu servidor Elasticsearch no lugar dele.
• A flag -N instrui o SSH a não executar um comando como um shell interativo /bin/bash, e sim apenas manter a conexão aberta. Geralmente é usado ao encaminhar portas como neste exemplo.

Se você deseja fechar o túnel a qualquer momento, pressione CTRL+C.

No Windows, seu terminal deve se assemelhar à captura de tela a seguir:

No macOS e no Linux, seu terminal será semelhante à captura de tela a seguir:

Depois de se conectar ao seu servidor Elasticsearch via SSH com o encaminhamento de porta configurado, abra seu navegador e visite http://127.0.0.1:5601. Você será redirecionado para a página de login do Kibana:

Se o seu navegador não conseguir se conectar ao Kibana, você receberá uma mensagem como a seguinte em seu terminal:

Output
channel 3: open failed: connect failed: No route to host

Este erro indica que seu túnel SSH não consegue alcançar o serviço Kibana em seu servidor. Certifique-se de ter especificado o endereço IP privado correto para o seu servidor Elasticsearch e recarregue a página no seu navegador.

Faça login no seu servidor Kibana usando elastic como Nome de Usuário e a senha que você copiou anteriormente neste tutorial para o usuário.

Navegando nos Painéis SIEM do Kibana

Depois de fazer login no Kibana, você pode explorar os painéis Suricata que o Filebeat configurou para você.

No campo de pesquisa na parte superior da página de boas-vindas do Kibana, insira os termos de pesquisa type:dashboard suricata. Esta pesquisa retornará dois resultados: os painéis de Eventos Suricata e Alertas Suricata conforme a captura de tela a seguir:

Clique no [Filebeat Suricata] Events Overview resultado para visitar o painel do Kibana que mostra uma visão geral de todos os eventos do Suricata registrados:

Para visitar o painel de Alertas do Suricata, repita a pesquisa ou clique no link Alerts que está incluído no painel de Eventos. Sua página deve se assemelhar à captura de tela a seguir:

Se você deseja inspecionar os eventos e alertas que cada painel exibe, role até o final da página onde encontrará uma tabela que lista cada evento e alerta. Você pode expandir cada entrada para visualizar a entrada de log original do Suricata e examinar em detalhes os vários campos como IPs de origem e destino para um alerta, o tipo de ataque, ID da assinatura do Suricata e outros.

O Kibana também possui um conjunto integrado de painéis de Segurança aos quais você pode acessar usando o menu no lado esquerdo da janela do navegador. Navegue até o painel de Rede para uma visão geral de eventos exibidos em um mapa, bem como dados agregados sobre eventos em sua rede. Seu painel deve se assemelhar à captura de tela a seguir:

Você pode rolar até o final do painel de Rede para uma tabela que lista todos os eventos que correspondem ao período de tempo de pesquisa especificado. Você também pode examinar cada evento em detalhes ou selecionar um evento para gerar uma linha do tempo do Kibana, que você pode então usar para investigar fluxos de tráfego específicos, alertas ou IDs de comunidade.

Conclusão

Neste tutorial, você instalou e configurou o Elasticsearch e o Kibana em um servidor autônomo. Você configurou ambas as ferramentas para estarem disponíveis em um endereço IP privado. Você também configurou as configurações de autenticação do Elasticsearch e do Kibana usando o módulo de segurança xpack que está incluído em cada ferramenta.

Após concluir as etapas de configuração do Elasticsearch e do Kibana, você também instalou e configurou o Filebeat em seu servidor Suricata. Você usou o Filebeat para popular os painéis do Kibana e começar a enviar logs do Suricata para o Elasticsearch.

Por fim, você criou um túnel SSH para o seu servidor Elasticsearch e fez login no Kibana. Você localizou os novos painéis de Eventos e Alertas do Suricata, bem como o painel de Rede.

O último tutorial desta série irá guiá-lo através do uso da funcionalidade SIEM do Kibana para processar seus alertas do Suricata. Nele, você explorará como criar casos para rastrear alertas específicos, cronogramas para correlacionar fluxos de rede e regras para corresponder a eventos específicos do Suricata que você gostaria de rastrear ou analisar com mais detalhes.