Come installare e configurare Suricata IDS insieme a Elastic Stack su Rocky Linux 8

Su questa pagina

Prerequisiti
Configura firewall
PARTE 1
Passaggio 1 - Installa Suricata
Passaggio 2 - Configura Suricata
1. Abilita ID comunità
2. Seleziona Interfaccia di rete
3. Ricarica regola in tempo reale
4. Configura i permessi della directory
1. Aggiungi fornitori di set di regole
1. Configura firewall
2. Avvia Elasticsearch
3. Crea password Elasticsearch
1. Configura la porta di Kibana
2. Configura l'accesso a Kibana
3. Avvio di Kibana
1. Utilizzo del tunnel locale SSH
2. Utilizzo del proxy inverso Nginx
3. Configura firewall
4. Installa e configura SSL
5. Installa e configura Nginx
Suricata è uno strumento di monitoraggio della rete che esamina ed elabora ogni pacchetto di traffico Internet che passa attraverso il tuo server. Può generare eventi di log, attivare avvisi e interrompere il traffico al rilevamento di attività sospette.
Puoi installare Suricata su una singola macchina per monitorarne il traffico o distribuirlo su un host gateway per scansionare tutto il traffico in entrata e in uscita da altri server ad esso collegati. Puoi combinare Suricata con Elasticsearch, Kibana e Filebeat per creare uno strumento SIEM (Security Information and Event Management).
In questo tutorial, installerai Suricata IDS insieme a ElasticStack su un server Rocky Linux 8. I vari componenti dello stack sono:
- Elasticsearch per archiviare, indicizzare, correlare e ricercare gli eventi di sicurezza dal server.
- Kibana per visualizzare i log archiviati in Elasticsearch.
- Filebeat per analizzare il file di log eve.json di Suricata e inviare ciascun evento a Elasticsearch per l'elaborazione.
- Suricata per scansionare il traffico di rete alla ricerca di eventi sospetti ed eliminare i pacchetti non validi.
Il tutorial è diviso in due parti, la prima parte si occuperà dell'installazione e della configurazione di Suricata, e la seconda parte si occuperà dell'installazione e della configurazione di Elastic Stack.
Installeremo Suricata e lo stack elastico su server diversi per il nostro tutorial.
Prerequisiti
- The servers hosting the Elastic Stack and Suricata should have a minimum of 4GB RAM and 2 CPU cores.
- The servers should be able to communicate with each other using private IP addresses.
- The servers should be running Rocky Linux 8 with a non-root sudo user.
- If you want to access Kibana dashboards from everywhere, set up a domain (kibana.example.com) pointing to the server where Suricata will be installed.
- Install essential packages on both servers.
```
$ sudo dnf install yum-utils nano curl
```
Configura firewall
PARTE 1
Passaggio 1: installa Suricata
Per installare Suricata, è necessario aggiungere al server il repository dei pacchetti Open Information Security Foundations (OISF).
```
$ sudo dnf install 'dnf-command(copr)'
$ sudo dnf copr enable @oisf/suricata-6.0
```
Il primo comando abilita i progetti della comunità (copr) per il programma di installazione del pacchetto dnf. Il secondo comando abilita e aggiunge il repository OISF al tuo sistema. suricata-6.0 abilita il repository per l'ultima versione stabile del software. Premi y e INVIO ogni volta che ti viene richiesto.
Successivamente, aggiungi il repository EPEL.
```
$ sudo dnf install epel-release
```
Installa Suricata.
```
$ sudo dnf install suricata
```
Abilita il servizio Suricata.
```
$ sudo systemctl enable suricata
```
Passo 2 - Configura Suricata
Suricata memorizza la sua configurazione nel file /etc/suricata/suricata.yaml. La modalità predefinita per Suricata è la modalità IDS (Intrusion Detection System), in cui il traffico viene solo registrato e non interrotto. Se sei nuovo su Suricata, dovresti lasciare la modalità invariata. Dopo averlo configurato e appreso di più, puoi attivare la modalità IPS (Intrusion Prevention System).
Abilita ID comunità
Il campo ID comunità semplifica la correlazione dei dati tra i record generati da diversi strumenti di monitoraggio. Poiché utilizzeremo Suricata con Elasticsearch, l'abilitazione dell'ID comunità può essere utile.
Apri il file /etc/suricata/suricata.yaml per la modifica.
```
$ sudo nano /etc/suricata/suricata.yaml
```
Individua la riga # Community Flow ID e imposta il valore della variabile community-id su true.
```
. . .
      # Community Flow ID
      # Adds a 'community_id' field to EVE records. These are meant to give
      # records a predictable flow ID that can be used to match records to
      # output of other tools such as Zeek (Bro).
      #
      # Takes a 'seed' that needs to be same across sensors and tools
      # to make the id less predictable.

      # enable/disable the community id feature.
      community-id: true
. . .
```
Ora, i tuoi eventi conterranno un ID come 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ= che puoi utilizzare per abbinare set di dati tra diversi strumenti di monitoraggio.
Seleziona Interfaccia di rete
Il file di configurazione predefinito di Suricata ispeziona il traffico sull'interfaccia di rete/dispositivo eth0. Se il tuo server utilizza un'interfaccia di rete diversa, dovrai aggiornarla nella configurazione.
Controlla il nome del dispositivo della tua interfaccia di rete usando il seguente comando.
```
$ ip -p -j route show default
```
Riceverai un output simile al seguente.
```
[ {
        "dst": "default",
        "gateway": "164.90.192.1",
        "dev": "eth0",
        "protocol": "static",
		"metric": 100,
        "flags": [ ]
    } ]
```
La variabile dev si riferisce al dispositivo di rete. Nel nostro output, mostra eth0 come dispositivo di rete. L'output potrebbe essere diverso a seconda del sistema.
Ora che conosci il nome del tuo dispositivo, apri il file di configurazione.
```
$ sudo nano /etc/suricata/suricata.yaml
```
Trova la riga af-packet: attorno al numero di riga 580. Sotto di essa, imposta il valore della variabile interface sul nome del dispositivo per il tuo sistema.
```
# Linux high speed capture support
af-packet:
  - interface: eth0
    # Number of receive threads. "auto" uses the number of cores
    #threads: auto
    # Default clusterid. AF_PACKET will load balance packets based on flow.
    cluster-id: 99
. . .
```
Se vuoi aggiungere altre interfacce, puoi farlo aggiungendole in fondo alla sezione af-packet intorno alla riga 650.
Per aggiungere una nuova interfaccia, inseriscila appena sopra la sezione - interface: default come mostrato di seguito.
```
    #  For eBPF and XDP setup including bypass, filter and load balancing, please
    #  see doc/userguide/capture-hardware/ebpf-xdp.rst for more info.

  - interface: enp0s1
    cluster-id: 98
...
  - interface: default
    #threads: auto
    #use-mmap: no
    #tpacket-v3: yes
```
Abbiamo aggiunto una nuova interfaccia enp0s1 e un valore univoco per la variabile cluster-id nel nostro esempio. Devi includere un ID cluster univoco con ogni interfaccia che aggiungi.
Ricarica regola in tempo reale
Devi riavviare Suricata ogni volta che aggiungi, rimuovi e modifichi le sue regole. Abilitando Live Rule, Suricata può elaborare qualsiasi modifica alle regole senza riavviare.
Per abilitare il ricaricamento in tempo reale, aggiungi le seguenti righe nella parte inferiore del file di configurazione.
```
. . .

detect-engine:
  - rule-reload: true
```
Con il ricaricamento in tempo reale abilitato, puoi utilizzare il seguente comando per ricaricare le regole senza riavviare il processo Suricata.
```
$ sudo kill -usr2 $(pidof suricata)
```
Il flag $ (pidof suricata) individua l'ID del processo Suricata. La parte -usr2 del comando kill invia un segnale SIGUSR2 al processo Suricata. Il segnale SIGUSR2 è configurato con Suricata per ricaricare le regole.
Al termine, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Configura le autorizzazioni della directory
Suricata ha creato automaticamente un utente e un gruppo di sistema denominato suricata durante il processo di installazione. È necessario fornire le autorizzazioni di directory appropriate affinché l'installazione funzioni correttamente.
Esegui il seguente comando per impostare suricata come gruppo per le directory Suricatas.
```
$ sudo chgrp -R suricata /etc/suricata
$ sudo chgrp -R suricata /var/lib/suricata/rules
$ sudo chgrp -R suricata /var/lib/suricata/update
$ sudo chgrp -R suricata /var/log/suricata 
```
Imposta i permessi del gruppo per la lettura e la scrittura.
```
$ sudo chmod -R g+r /etc/suricata/
$ sudo chmod -R g+rw /var/lib/suricata/rules
$ sudo chmod -R g+rw /var/lib/suricata/update
$ sudo chmod -R g+rw /var/log/suricata
```
Aggiungi il tuo nome utente attuale al gruppo suricata in modo da poter eseguire operazioni direttamente senza bisogno di sudo.
```
$ sudo usermod -a -G suricata $USER
```
Per applicare la nuova appartenenza al gruppo, disconnettersi dal server e riconnettersi oppure digitare quanto segue:
```
$ su - ${USER}
```
Ti verrà richiesto di inserire la password dell'utente per continuare.
Conferma che il tuo utente è ora aggiunto al gruppo suricata digitando:
```
$ id -nG
username sudo suricata
```
Passaggio 3: configurare le regole di Suricata
Suricata, per impostazione predefinita, utilizza solo un insieme limitato di regole per rilevare il traffico di rete. Puoi aggiungere altri set di regole da provider esterni utilizzando uno strumento chiamato suricata-update. Eseguire il comando seguente per includere regole aggiuntive.
```
$ suricata-update
16/2/2022 -- 07:00:16 - <Info> -- Using data-directory /var/lib/suricata.
16/2/2022 -- 07:00:16 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
16/2/2022 -- 07:00:16 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
.....
16/2/2022 -- 07:00:16 - <Info> -- No sources configured, will use Emerging Threats Open
('https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz', None, True)
16/2/2022 -- 07:00:16 - <Info> -- Checking https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.md5.
16/2/2022 -- 07:00:16 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.
 100% - 3162050/3162050
.....
16/2/2022 -- 07:00:23 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 32004; enabled: 24611; added: 8; removed 1; modified: 1218
16/2/2022 -- 07:00:23 - <Info> -- Writing /var/lib/suricata/rules/classification.config
16/2/2022 -- 07:00:23 - <Info> -- Testing with suricata -T.
16/2/2022 -- 07:01:16 - <Info> -- Done.
```
Aggiungi provider di set di regole
Puoi espandere le regole di Suricatas aggiungendo più fornitori. Può recuperare regole da una varietà di fornitori gratuiti e commerciali.
È possibile elencare l'elenco dei provider predefiniti utilizzando il seguente comando.
```
$ suricata-update list-sources
```
Ad esempio, se vuoi includere il set di regole tgreen/hunting, puoi abilitarlo con il seguente comando.
```
$ suricata-update enable-source tgreen/hunting
```
Esegui nuovamente il comando suricata-update per scaricare e aggiornare le nuove regole.
Passaggio 4: convalidare la configurazione di Suricata
Suricata viene fornito con uno strumento di convalida per verificare la presenza di errori nel file di configurazione e nelle regole. Eseguire il comando seguente per eseguire lo strumento di convalida.
```
$ sudo suricata -T -c /etc/suricata/suricata.yaml -v
22/2/2022 -- 23:20:10 - <Info> - Running suricata under test mode
22/2/2022 -- 23:20:10 - <Notice> - This is Suricata version 6.0.4 RELEASE running in SYSTEM mode
22/2/2022 -- 23:20:10 - <Info> - CPUs/cores online: 2
22/2/2022 -- 23:20:10 - <Info> - dropped the caps for main thread
22/2/2022 -- 23:20:10 - <Info> - fast output device (regular) initialized: fast.log
22/2/2022 -- 23:20:10 - <Info> - eve-log output device (regular) initialized: eve.json
22/2/2022 -- 23:20:10 - <Info> - stats output device (regular) initialized: stats.log
22/2/2022 -- 23:20:21 - <Info> - 1 rule files processed. 24611 rules successfully loaded, 0 rules failed
22/2/2022 -- 23:20:21 - <Info> - Threshold config parsed: 0 rule(s) found
22/2/2022 -- 23:20:21 - <Info> - 24614 signatures processed. 1216 are IP-only rules, 4120 are inspecting packet payload, 19074 inspect application layer, 108 are decoder event only
22/2/2022 -- 23:21:02 - <Notice> - Configuration provided was successfully loaded. Exiting.
22/2/2022 -- 23:21:03 - <Info> - cleaning up signature grouping structure... complete
```
Il flag -T indica a Suricata di essere eseguito in modalità test, il flag -c configura la posizione del file di configurazione e il flag -v flag stampa l'output dettagliato del comando. A seconda della configurazione del sistema e del numero di regole aggiunte, il completamento del comando può richiedere alcuni minuti.
Passaggio 5: eseguire Suricata
Ora che Suricata è configurato e configurato, è il momento di eseguire l'applicazione.
```
$ sudo systemctl start suricata
```
Controlla lo stato del processo.
```
$ sudo systemctl status suricata
```
Dovresti vedere il seguente output se tutto funziona correttamente.
```
? suricata.service - Suricata Intrusion Detection Service
   Loaded: loaded (/usr/lib/systemd/system/suricata.service; enabled; vendor preset: disabled)
   Active: active (running) since Wed 2022-02-16 07:14:22 UTC; 32min ago
     Docs: man:suricata(1)
  Process: 1494 ExecStartPre=/bin/rm -f /var/run/suricata.pid (code=exited, status=0/SUCCESS)
 Main PID: 1496 (Suricata-Main)
    Tasks: 8 (limit: 23479)
   Memory: 367.5M
   CGroup: /system.slice/suricata.service
           ??1496 /sbin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid -i eth0 --user suricata

Feb 16 07:14:22 suricata systemd[1]: Starting Suricata Intrusion Detection Service...
Feb 16 07:14:22 suricata systemd[1]: Started Suricata Intrusion Detection Service.
```
Il processo può richiedere alcuni minuti per completare l'analisi di tutte le regole. Pertanto, il controllo dello stato di cui sopra non è un'indicazione completa del fatto che Suricata sia attivo e pronto. È possibile monitorare il file di registro utilizzando il seguente comando.
```
$ sudo tail -f /var/log/suricata/suricata.log
```
Se vedi la seguente riga nel file di registro, significa che Suricata è in esecuzione e pronto per monitorare il traffico di rete.
```
16/02/2022 -- 07:18:39 - <Info> - All AFP capture threads are running.
```
Passaggio 6: test delle regole di Suricata
Verificheremo se Suricata sta rilevando traffico sospetto. La guida Suricata consiglia di testare la regola ET Open numero 2100498 utilizzando il seguente comando.
```
$ curl http://testmynids.org/uid/index.html
```
Otterrai la seguente risposta.
```
uid=0(root) gid=0(root) groups=0(root)
```
Il comando precedente pretende di restituire l'output del comando id che può essere eseguito su un sistema compromesso. Per verificare se Suricata ha rilevato il traffico, è necessario controllare il file di registro utilizzando il numero di regola specificato.
```
$ grep 2100498 /var/log/suricata/fast.log
```
Se la tua richiesta ha utilizzato IPv6, dovresti vedere il seguente output.
```
02/22/2022-23:24:33.997371  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:2204:5c00:0018:30b3:e400:93a1:80 -> 2a03:b0c0:0002:00d0:0000:0000:0fc2:b001:41468
```
Se la tua richiesta utilizzava IPv4, vedresti il seguente output.
```
02/22/2022-23:21:46.783476  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 204.246.178.81:80 -> 164.90.192.1:36364
```
Suricata registra anche gli eventi nel file /var/log/suricata/eve.log utilizzando il formato JSON. Per leggere e interpretare queste regole, devi installare jq che non rientra nell'ambito di questo tutorial.
Abbiamo finito con la prima parte del tutorial, dove abbiamo installato Suricata e l'abbiamo testato. La parte successiva prevede l'installazione dello stack ELK e la sua configurazione per visualizzare Suricata e i suoi registri. Questa seconda parte del tutorial dovrebbe essere eseguita sul secondo server se non diversamente specificato.
Passaggio 7: installa Elasticsearch e Kibana
Il primo passaggio nell'installazione di Elasticsearch prevede l'aggiunta della chiave GPG elastica al server.
```
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
Crea un repository per il pacchetto Elasticsearch creando e aprendo il file /etc/yum/yum.repos.d/elasticsearch.repo per la modifica.
```
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
```
Incolla il seguente codice al suo interno.
```
[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
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installa Elasticsearch e Kibana.
```
$ sudo dnf install --enablerepo=elasticsearch elasticsearch kibana
```
Devi utilizzare il flag --enablerepo=elasticsearch ogni volta da quando abbiamo mantenuto il repository disabilitato per impostazione predefinita. Ciò impedisce l'aggiornamento accidentale di questi pacchetti.
Individua l'indirizzo IP privato del tuo server utilizzando il seguente comando.
```
$ ip -brief address show
lo               UNKNOWN        127.0.0.1/8 ::1/128
eth0             UP             164.90.205.77/20 10.18.0.7/16 2a03:b0c0:2:d0::fef:b001/64 fe80::340a:6eff:fe5c:76ed/64
eth1             UP             10.133.0.3/16 fe80::906f:b5ff:fec4:c7b8/64
```
Annota l'IP privato del tuo server (10.133.0.3 in questo caso). Lo chiameremo your_private_IP. L'indirizzo IP pubblico del server (164.90.205.77) verrà indicato come tuo_IP_pubblico nel tutorial rimanente. Inoltre, annota il nome di rete del tuo server, eth1.
Passaggio 8: configurare Elasticsearch
Elasticsearch memorizza la sua configurazione nel file /etc/elasticsearch/elasticsearch.yml. Apri il file per la modifica.
```
$ sudo nano /etc/elasticsearch/elasticsearch.yml
```
Elasticsearch accetta solo connessioni locali per impostazione predefinita. Dobbiamo cambiarlo in modo che Kibana possa accedervi tramite l'indirizzo IP privato.
Trova la riga #network.host: 192.168.0.1 e aggiungi la seguente riga proprio sotto di essa, come mostrato di seguito.
```
# By default Elasticsearch is only accessible on localhost. Set a different
# address here to expose this node on the network:
#
#network.host: 192.168.0.1
network.bind_host: ["127.0.0.1", "your_private_IP"]
#
# By default Elasticsearch listens for HTTP traffic on the first free port it
# finds starting at 9200. Set a specific HTTP port here:
```
Ciò garantirà che Elastic possa ancora accettare connessioni locali pur essendo disponibile per Kibana tramite l'indirizzo IP privato.
Il passaggio successivo consiste nell'attivare alcune funzionalità di sicurezza e assicurarsi che Elastic sia configurato per l'esecuzione su un singolo nodo. Per fare ciò, aggiungi le seguenti righe alla fine del file.
```
. . .
discovery.type: single-node
xpack.security.enabled: true
```
Se intendi utilizzare più nodi di ricerca elastici, puoi tralasciare la prima riga.
Al termine, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Configura firewall
Aggiungi le regole del firewall appropriate per Elasticsearch in modo che sia accessibile tramite la rete privata.
```
$ 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 firewall-cmd --reload
```
Assicurati di scegliere il nome dell'interfaccia nel primo comando come quello ottenuto dal passaggio 7. I comandi precedenti modificano la zona predefinita del firewall in porte interne e aperte 9200, 9300 per Elasticsearch e porta 5601 per Kibana.
Avvia Elasticsearch
Ora che hai configurato Elasticsearch, è il momento di avviare il servizio.
```
$ sudo systemctl start elasticsearch
```
Crea password Elasticsearch
Dopo aver abilitato le impostazioni di sicurezza di Elasticsearch, il passaggio successivo consiste nel generare alcune password per l'utente predefinito. Elasticsearch viene fornito con un'utilità per la creazione di password in /usr/share/elasticsearch/bin/elasticsearch-setup-passwords che può generare password casuali.
Crea le password.
```
$ cd /usr/share/elasticsearch/bin
$ sudo ./elasticsearch-setup-passwords auto
```
Otterrai un output simile al seguente. Premi y per continuare quando richiesto.
```
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 = EtwMg8maU67o5tvD5rse

Changed password for user kibana_system
PASSWORD kibana_system = dTanR7Q2HtgDtATRvuJv

Changed password for user kibana
PASSWORD kibana = dTanR7Q2HtgDtATRvuJv

Changed password for user logstash_system
PASSWORD logstash_system = XGSjxNktuNMWVfGYibox

Changed password for user beats_system
PASSWORD beats_system = JXTr7CeHkMue608qVTQa

Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = Q6JTJNl3lPy0fhy6QuMP

Changed password for user elastic
PASSWORD elastic = bd1YJfhSa8RC8SMvTIwg
```
Puoi eseguire l'utilità solo una volta, quindi salva tutte le password in un luogo sicuro.
Passaggio 9: configurare Kibana
Il primo passo nella configurazione di Kibana è abilitare la funzione di sicurezza xpack generando chiavi segrete. Kibana utilizza queste chiavi segrete per archiviare i dati in Elasticsearch. È possibile accedere all'utilità per generare chiavi segrete dalla directory /usr/share/kibana/bin.
```
$ cd /usr/share/kibana/bin/
$ sudo ./kibana-encryption-keys generate -q --force
```
Il flag -q sopprime le istruzioni di comando e il flag --force garantisce la generazione di nuovi segreti. Riceverai un output simile al seguente.
```
xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da
xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5
xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
```
Copia l'output. Apri il file di configurazione di Kibanas in /etc/kibana/kibana.yml per modificarlo.
```
$ sudo nano /etc/kibana/kibana.yml
```
Incolla il codice del comando precedente alla fine del file.
```
. . .

# Specifies locale to be used for all localizable strings, dates and number formats.
# Supported languages are the following: English - en , by default , Chinese - zh-CN .
#i18n.locale: "en"

xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da
xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5
xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
```
Configura la porta Kibana
Kibana deve essere configurato in modo che sia accessibile sull'indirizzo IP privato del server. Trova la riga #server.host: \localhost\ nel file e aggiungi la seguente riga subito sotto come mostrato.
```
# Kibana is served by a back end server. This setting specifies the port to use.
#server.port: 5601

# Specifies the address to which the Kibana server will bind. IP addresses and host names are both valid values.
# The default is 'localhost', which usually means remote machines will not be able to connect.
# To allow connections from remote users, set this parameter to a non-loopback address.
#server.host: "localhost"
server.host: "your_private_IP"
```
Al termine, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Configura l'accesso Kibana
Il passaggio successivo consiste nel creare un nome utente e una password che Kibana possa utilizzare per l'autenticazione. Puoi farlo modificando direttamente il file di configurazione di Kibanas, ma può causare un problema di sicurezza. Il metodo sicuro implica l'uso dell'applicazione kibana-keystore.
Eseguire i seguenti comandi per impostare un nome utente. Inserisci kibana_system come nome utente.
```
$ cd /usr/share/kibana/bin
$ sudo ./kibana-keystore add elasticsearch.username
Enter value for elasticsearch.username: *************
```
Eseguire nuovamente il comando per impostare la password. Assicurati di utilizzare la password che hai creato per Kibana nel passaggio 8. Per il nostro tutorial, la password è dTanR7Q2HtgDtATRvuJv.
```
$ sudo ./kibana-keystore add elasticsearch.password
Enter value for elasticsearch.password: ********************
```
Avvio di Kibana
Ora che hai configurato l'accesso sicuro e la rete per Kibana, avvia il processo.
```
$ sudo systemctl start kibana
```
Controlla lo stato per vedere se è in esecuzione.
```
$ sudo systemctl status kibana
```
Passo 10 - Installa e configura Filebeat
È importante notare che installeremo Filebeat sul server Suricata. Quindi torna ad esso e aggiungi la chiave GPG elastica per iniziare.
```
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
Crea e apri il repository elastico.
```
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
```
Incolla il seguente codice.
```
[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
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installa filebeat.
```
$ sudo dnf install --enablerepo=elasticsearch filebeat
```
Filebeat memorizza la sua configurazione nel file /etc/filebeat/filebeat.yml. Aprilo per la modifica.
```
$ sudo nano /etc/filebeat/filebeat.yml
```
La prima cosa che devi fare è collegarlo alla dashboard di Kibana. Trova la riga #host: \localhost:5601\ nella sezione Kibana e aggiungi la seguente riga proprio sotto di essa come mostrato.
```
. . .
# Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API.
# This requires a Kibana endpoint configuration.
setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  #host: "localhost:5601"
  host: "your_private_IP:5601"

. . .
```
Successivamente, trova la sezione Elasticsearch Output del file e modifica i valori di hosts, username e password come mostrato di seguito. Per il nome utente, scegli elastic come valore e per la password, usa il valore generato nel passaggio 8 di questo tutorial.
```
output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["your_private_IP:9200"]

  # Protocol - either `http` (default) or `https`.
  #protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "bd1YJfhSa8RC8SMvTIwg"

. . .
```
Al termine, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Successivamente, abilita il modulo Suricata integrato in Filebeats.
```
$ sudo filebeat modules enable suricata
```
Il passaggio finale nella configurazione di Filebeat consiste nel caricare i dashboard e le pipeline SIEM in Elasticsearch utilizzando il comando filebeat setup.
```
$ sudo filebeat setup
```
Il completamento del comando potrebbe richiedere alcuni minuti. Una volta terminato, dovresti ricevere il seguente 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
```
Avvia il servizio Filebeat.
```
$ sudo systemctl start filebeat
```
Controlla lo stato del servizio.
```
$ sudo systemctl status filebeat
```
Passaggio 11: accesso alla dashboard di Kibana
Poiché KIbana è configurato per accedere a Elasticsearch solo tramite il suo indirizzo IP privato, hai due opzioni per accedervi. Il primo metodo consiste nell'utilizzare un tunnel SSH al server Elasticsearch dal tuo PC. Questo inoltrerà la porta 5601 dal tuo PC all'indirizzo IP privato del server e sarai in grado di accedere a Kibana dal tuo PC all'indirizzo http://localhost:5601. Ma questo metodo significa che non sarai in grado di accedervi da nessun'altra parte.
L'opzione è installare Nginx sul tuo server Suricata e usarlo come proxy inverso per accedere al server Elasticsearchs tramite il suo indirizzo IP privato. Discuteremo in entrambi i modi. Puoi scegliere in entrambi i modi in base alle tue esigenze.
Utilizzo del tunnel locale SSH
Se utilizzi Windows 10 o Windows 11, puoi eseguire SSH LocalTunnel da Windows PowerShell. Su Linux o macOS, puoi usare il terminale. Probabilmente dovrai configurare l'accesso SSH se non l'hai già fatto.
Esegui il seguente comando nel terminale del tuo computer per creare il tunnel SSH.
```
$ ssh -L 5601:your_private_IP:5601 _public_IP -N
```
- Il flag -L si riferisce al tunnel SSH locale, che inoltra il traffico dalla porta del tuo PC al server.
- Il private_IP:5601 è l'indirizzo IP a cui viene inoltrato il tuo traffico sul server. In questo caso, sostituiscilo con l'indirizzo IP privato del tuo server Elasticsearch.
- Il your_public_IP è l'indirizzo IP pubblico del server Elasticsearch, utilizzato per aprire una connessione SSH.
- Il flag -N dice a OpenSSH di non eseguire alcun comando ma di mantenere attiva la connessione finché il tunnel è in esecuzione.
Ora che il tunnel è aperto, puoi accedere a Kibana aprendo l'URL http://localhost:5601 sul browser del tuo PC. Otterrai la seguente schermata.
Dovrai mantenere il comando in esecuzione per tutto il tempo necessario per accedere a Kibana. Premi Ctrl + C nel tuo terminale per chiudere il tunnel.
Utilizzo del proxy inverso Nginx
Questo metodo è più adatto se desideri accedere alla dashboard da qualsiasi parte del mondo.
Configura firewall
Prima di procedere oltre, è necessario aprire le porte HTTP e HTTPS nel firewall.
```
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
```
Ricarica il firewall per abilitare le modifiche.
```
$ sudo firewall-cmd --reload
```
Installa e configura SSL
Il primo passo è installare il certificato SSL Lets Encrypt. Poiché abbiamo già configurato il repository EPEL, installa lo strumento Certbot.
```
$ sudo dnf install certbot
```
Genera il certificato SSL per il dominio kibana.example.com.
```
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d kibana.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/kibana.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
```
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
```
Crea una directory radice Web di verifica per il rinnovo automatico di Lets Encrypt.
```
$ sudo mkdir -p /var/lib/letsencrypt
```
Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, per prima cosa, crea il file /etc/cron.daily/certbot-renew e aprilo per modificarlo.
```
$ sudo nano /etc/cron.daily/certbot-renew
```
Incolla il seguente codice.
```
#!/bin/sh
certbot renew --cert-name kibana.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Modificare le autorizzazioni sul file dell'attività per renderlo eseguibile.
```
$ sudo chmod +x /etc/cron.daily/certbot-renew
```
Installa e configura Nginx
Rocket Linux 8.5 viene fornito con l'ultima versione stabile di Nginx come modulo. Installalo usando il seguente comando.
```
$ sudo dnf module install nginx:1.20
```
Puoi controllare la versione che desideri installare utilizzando il seguente comando.
```
$ dnf module list nginx
Rocky Linux 8 - AppStream
Name                                           Stream                                            Profiles                                                Summary
nginx                                          1.14 [d]                                          common [d]                                              nginx webserver
nginx                                          1.16                                              common [d]                                              nginx webserver
nginx                                          1.18                                              common [d]                                              nginx webserver
nginx                                          1.20 [e]                                          common [d] [i]                                          nginx webserver

Extra Packages for Enterprise Linux Modular 8 - x86_64
Name                                           Stream                                            Profiles                                                Summary
nginx                                          mainline                                          common                                                  nginx webserver
nginx                                          1.20 [e]                                          common [d] [i]                                          nginx webserver
```
Conferma l'installazione di Nginx.
```
$ nginx -v
nginx version 1.20.1
```
Abilita il servizio Nginx.
```
$ sudo systemctl enable nginx
```
Crea e apri il file di configurazione Nginx per Kibana.
```
$ sudo nano /etc/nginx/conf.d/kibana.conf
```
Incolla il seguente codice al suo interno. Sostituisci l'indirizzo IP con l'indirizzo IP privato del tuo server Elasticsearch.
```
server {
        listen 80; listen [::]:80;
        server_name kibana.example.com;
        return 301 https://$host$request_uri;
}

server {
        server_name kibana.example.com;
        charset utf-8;

        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        access_log /var/log/nginx/kibana.access.log;
        error_log /var/log/nginx/kibana.error.log;

        ssl_certificate /etc/letsencrypt/live/kibana.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/kibana.example.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/kibana.example.com/chain.pem;
        ssl_session_timeout 1d;
        ssl_session_cache shared:MozSSL:10m;
        ssl_session_tickets off;

        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
		
		resolver 8.8.8.8;

        ssl_stapling on;
        ssl_stapling_verify on;
        ssl_dhparam /etc/ssl/certs/dhparam.pem;
 
        location / {
                proxy_pass http://your_private_IP:5601;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;
        }
}
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Apri il file /etc/nginx/nginx.conf per la modifica.
```
$ sudo nano /etc/nginx/nginx.conf
```
Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
```
server_names_hash_bucket_size  64;
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Verifica la configurazione.
```
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Avvia il servizio Nginx.
```
$ sudo systemctl start nginx
```
La dashboard di Kibana dovrebbe essere accessibile tramite l'URL https://kibana.example.com da qualsiasi luogo tu voglia.
Passaggio 12: gestione dei dashboard di Kibana
Prima di procedere ulteriormente con la gestione dei dashboard, è necessario aggiungere il campo URL di base nella configurazione di Kibanas.
Apri il file di configurazione di Kibanas.
```
$ sudo nano /etc/kibana/kibana.yml
```
Trova la riga commentata #server.publicBaseUrl: \\ e modificala come segue rimuovendo l'hash che la precede.
```
server.publicBaseUrl: "https://kibana.example.com"
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il servizio Kibana.
```
$ sudo systemctl restart kibana
```
Attendi qualche minuto e carica l'URL https://kibana.example.com nel tuo browser. Accedi con il nome utente elastic e la password che hai generato in precedenza (bd1YJfhSa8RC8SMvTIwg) e otterrai la seguente schermata.
Digita type:data suricata nella casella di ricerca in alto per individuare le informazioni su Suricata.
Fai clic sul primo risultato ([Filebeat Suricata] Panoramica degli avvisi) e otterrai una schermata simile alla seguente. Per impostazione predefinita, mostra solo le voci degli ultimi 15 minuti, ma lo stiamo visualizzando su un periodo di tempo più ampio per mostrare più dati per il tutorial.
Fare clic sul pulsante Eventi per visualizzare tutti gli eventi registrati.
Scorrendo verso il basso le pagine degli eventi e degli avvisi, è possibile identificare ciascun evento e avviso in base al tipo di protocollo, alle porte di origine e di destinazione e all'indirizzo IP dell'origine. Puoi anche visualizzare i paesi da cui ha avuto origine il traffico.
Puoi utilizzare Kibana e Filebeat per accedere e generare altri tipi di dashboard. Uno degli utili dashboard integrati che puoi subito è il dashboard di sicurezza. Fai clic sulla dashboard Rete dal menu dell'hamburger a sinistra e otterrai la seguente schermata.
Puoi aggiungere più dashboard come Nginx abilitando e configurando i moduli Filebeat integrati.
Conclusione
Questo conclude il tutorial per l'installazione e la configurazione di Suricata IDS con Elastic Stack su un server basato su Rocky Linux 8. Hai anche configurato Nginx come proxy inverso per accedere ai dashboard di Kibana dall'esterno. Se hai domande, pubblicale nei commenti qui sotto.

Come installare e configurare Suricata IDS insieme a Elastic Stack su Rocky Linux 8

Su questa pagina

Prerequisiti

Configura firewall

PARTE 1

Passaggio 1: installa Suricata

Passo 2 - Configura Suricata

Abilita ID comunità

Seleziona Interfaccia di rete

Ricarica regola in tempo reale

Configura le autorizzazioni della directory

Passaggio 3: configurare le regole di Suricata

Aggiungi provider di set di regole

Passaggio 4: convalidare la configurazione di Suricata

Passaggio 5: eseguire Suricata

Passaggio 6: test delle regole di Suricata

Passaggio 7: installa Elasticsearch e Kibana

Passaggio 8: configurare Elasticsearch

Configura firewall

Avvia Elasticsearch

Crea password Elasticsearch

Passaggio 9: configurare Kibana

Configura la porta Kibana

Configura l'accesso Kibana

Avvio di Kibana

Passo 10 - Installa e configura Filebeat

Passaggio 11: accesso alla dashboard di Kibana

Utilizzo del tunnel locale SSH

Utilizzo del proxy inverso Nginx

Configura firewall

Installa e configura SSL

Installa e configura Nginx

Passaggio 12: gestione dei dashboard di Kibana

Conclusione