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

Introdução

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

Neste tutorial, você 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 conjunto Elastic e Rocky Linux 8. As ferramentas SIEM são usadas para coletar, agregar, armazenar e analisar dados de eventos em busca de ameaças de segurança e atividades suspeitas em suas redes e servidores.

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

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

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

Finalmente, você aprenderá como se conectar ao Kibana usando SSH e seu navegador da web e, em seguida, carregar e interagir com os painéis do Kibana que mostram os eventos e alertas do Suricata.

Pré-requisitos

Se você tem seguido 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 ainda precisar instalar o Suricata, 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 configuradas com um usuário sudo não-root. Você pode alcançar isso seguindo o Procedimento Inicial do Servidor com Rocky Linux 8.

Para os propósitos deste tutorial, ambos os servidores devem ser capazes de 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 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 do 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 seu editor preferido. 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 gravar as alterações no arquivo e sair.

Agora instale o Elasticsearch e o Kibana usando o comando dnf. Pressione Y para aceitar qualquer prompt 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. Este método garante que os pacotes do Elasticsearch e do Kibana não sejam atualizados acidentalmente ao instalar outras atualizações de pacotes em seu servidor.

Após 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 destacado eth1, 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 para o seu servidor Elasticsearch (neste caso 10.137.0.5). Este endereço será referido como seu_ip_privado 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 ouvir conexões no endereço IP privado proveniente do seu servidor Suricata.

Passo 2 — Configurando o Elasticsearch

O Elasticsearch é configurado para aceitar apenas conexões locais por padrão. Além disso, não possui autenticação ativada, 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 depois ativará 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 o editor de sua preferência:

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 depois dela 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
# encontrar, começando em 9200. Defina uma porta HTTP específica aqui:

Substitua o seu IP privado no lugar do endereço your_private_ip. Essa linha garantirá que o Elasticsearch ainda esteja disponível em seu endereço local para que o Kibana possa acessá-lo, bem como no endereço IP privado para o 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 execute 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 com o 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 interface de rede privada pelo 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 Firewalld com as novas regras permanentes em vigor.

Em seguida, você iniciará o daemon do Elasticsearch e depois 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 xpack para o Elasticsearch, você precisa iniciá-lo para que as alterações entrem em vigor.

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 irá gerar senhas para os usuários padrão integrados ao Elasticsearch.

Configurando Senhas do Elasticsearch

Agora que você ativou 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 para 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 será capaz de executar a utilidade novamente, então certifique-se de registrar essas senhas em algum lugar 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 de Configuração do Filebeat deste tutorial.

Neste ponto do tutorial, você terminou de configurar o 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ê vai habilitar a funcionalidade de segurança do xpack do Kibana gerando alguns segredos que o Kibana usará para armazenar dados no Elasticsearch. Em seguida, você configurará as configurações de rede e detalhes de 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 então gerar as chaves:

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

A flag -q suprime as instruções da ferramenta, e a flag --force garantirá que você crie novas chaves. Você deve 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 o editor de sua preferência:

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ê configurará as configurações de rede do Kibana.

Configurando a Rede do Kibana

Para configurar a rede do Kibana para que 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, conforme destacado abaixo:

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

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

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

Salve e feche o arquivo quando terminar de editá-lo. Em seguida, você precisará configurar o nome de usuário e a 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 a 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.

Vamos usar o método do keystore neste tutorial, pois evita editar diretamente o 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á substituído por um caractere de 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 ter adicionado 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

Assim 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 os seus processos Elasticsearch e Kibana estão configurados com as configurações corretas de rede e autenticação, o próximo passo é instalar e configurar o Filebeat no seu servidor Suricata.

Para começar a instalar o 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 diretório /etc/yum/yum.repos.d com o seguinte conteúdo, usando o vi ou o editor de sua preferência:

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

Ao terminar de fazer as alterações, salve e saia do arquivo. Agora instale o pacote do Filebeat usando o comando dnf:

sudo dnf install --enablerepo=elasticsearch filebeat

Em seguida, você precisará configurar o Filebeat para se conectar tanto ao Elasticsearch quanto ao Kibana. Abra o arquivo de configuração /etc/filebeat/filebeat.yml usando o vi ou o editor de sua preferência:

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 aponta para o endereço IP privado e porta da sua instância do Kibana:

. . .
# Começando com a versão 6.0.0 do Beats, os dashboards são carregados via a API do Kibana.
# Isso requer uma configuração do endpoint do Kibana.
setup.kibana:

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

. . .

Esta alteração garantirá que o Filebeat possa se conectar ao Kibana para criar os vários índices SIEM, painéis e pipelines de processamento no Elasticsearch para lidar com 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 se conectar.
  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 o 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 ao Filebeat com o seguinte comando:

sudo filebeat modules enable suricata

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

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

sudo filebeat setup

Assim que o comando terminar, você deverá 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 os logs do Suricata, o último passo neste tutorial é conectar-se ao Kibana e explorar os painéis SIEM.

Passo 5 — Navegando nos Painéis SIEM do Kibana

O Kibana é o componente gráfico do conjunto 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 através do 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 possui 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á esta 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 depois executar o comando SSH novamente para reestabelecer o túnel.

Execute o seguinte comando em um terminal no 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 SSH são:

• A bandeira -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 no 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 bandeira -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 desejar 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 em vigor, 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

Esse 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 pelos 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 resultado [Filebeat Suricata] Events Overview 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 parecer com a captura de tela a seguir:

Se desejar 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, tipo de ataque, ID de 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 Network para uma visão geral de eventos exibidos em um mapa, bem como dados agregados sobre eventos em sua rede. Seu painel deve se parecer com a 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 seu intervalo 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 da 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 no 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á orientá-lo sobre como usar a 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.