Suricata IDS avec ELK et Web Frontend sur Ubuntu 18.04 LTS

Suricata est un IDS / IPS capable d’utiliser les menaces émergentes et les ensembles de règles VRT comme Snort et Sagan. Ce tutoriel montre l’installation et la configuration du système de détection d’intrusion Suricata sur un serveur Ubuntu 18.04 (Bionic Beaver).

Dans ce howto, nous supposons que toutes les commandes sont exécutées en tant que root. Si ce n’est pas le cas, tu dois ajouter sudo avant chaque commande.

Commençons par installer certaines dépendances :

apt -y install libpcre3 libpcre3-dev build-essential autoconf automake libtool libpcap-dev libnet1-dev libyaml-0-2 libyaml-dev zlib1g zlib1g-dev libmagic-dev libcap-ng-dev libjansson-dev pkg-config libnetfilter-queue-dev geoip-bin geoip-database geoipupdate apt-transport-https

Installation de Suricata et de suricata-update

Suricata

add-apt-repository ppa:oisf/suricata-stable
apt-get update

Tu peux ensuite installer la dernière version stable de Suricata avec :

apt-get install suricata

Comme eth0 est codé en dur dans suricata (reconnu comme un bug), nous devons remplacer eth0 par le nom correct de l’adaptateur réseau.

nano /etc/netplan/50-cloud-init.yaml

Et note (copie) le nom réel de l’adaptateur réseau.

network:
ethernets:
enp0s3:
....

Dans mon cas, enp0s3

nano /etc/suricata/suricata.yml

Et remplace toutes les instances de eth0 par le nom réel de l’adaptateur pour ton système.

nano /etc/default/suricata

Et remplace toutes les instances de eth0 par le nom réel de l’adaptateur de ton système.

Suricata-update

Maintenant, nous installons suricata-update pour mettre à jour et télécharger les règles suricata.

apt install python-pip
pip install pyyaml
pip install https://github.com/OISF/suricata-update/archive/master.zip

Pour mettre à jour suricata-update, exécute :

pip install --pre --upgrade suricata-update

Suricata-update a besoin des accès suivants :

Répertoire /etc/suricata : accès en lecture
Répertoire /var/lib/suricata/rules : accès en lecture/écriture
Répertoire /var/lib/suricata/update : accès en lecture/écriture

Une option consiste à simplement exécuter suricata-update en tant que root ou avec sudo ou avec sudo -u suricata suricata-update.

Mets à jour tes règles

Sans faire aucune configuration, l’opération par défaut de suricata-update consiste à utiliser le jeu de règles Emerging Threats Open.

suricata-update

Cette commande va :

Rechercher le programme suricata dans ton chemin pour déterminer sa version.

Recherchera /etc/suricata/enable.conf, /etc/suricata/disable.conf, /etc/suricata/drop.conf et /etc/suricata/modify.conf pour rechercher les filtres à appliquer aux règles téléchargées.Ces fichiers sont facultatifs et n’ont pas besoin d’exister.

Télécharge le jeu de règles Emerging Threats Open pour ta version de Suricata, en choisissant par défaut la version 4.0.0 si elle n’est pas trouvée.

Applique les filtres d’activation, de désactivation, de suppression et de modification tels que chargés ci-dessus.
Ecris les règles dans /var/lib/suricata/rules/suricata.rules.

Exécute Suricata en mode test sur /var/lib/suricata/rules/suricata.rules.

Suricata-Update adopte une convention différente pour les fichiers de règles que celle utilisée traditionnellement par Suricata. La différence la plus notable est que les règles sont stockées par défaut dans /var/lib/suricata/rules/suricata.rules.

Une façon de charger les règles est d’utiliser l’option de ligne de commande -S Suricata. L’autre est de mettre à jour ton suricata.yaml pour qu’il ressemble à quelque chose comme ça :

default-rule-path: /var/lib/suricata/rules
rule-files:
- suricata.rules

Ce sera le futur format de Suricata, alors utilise-le pour être à l’épreuve du temps.

Découvre les autres sources de règles disponibles

Mets d’abord à jour l’index des sources de règles avec la commande update-sources :

suricata-update update-sources

Cela ressemblera à ceci :

Exécuter suricata-update

Cette commande va mettre à jour suricata-update avec toutes les sources de règles disponibles.

suricata-update list-sources

Cela ressemblera à ceci :

Lister les sources pour suricata-update

Maintenant, nous allons activer toutes les sources de règles (gratuites). Pour une source payante, tu devras avoir un compte et payer bien sûr. Lors de l’activation d’une source payante, il te sera demandé ton nom d’utilisateur / mot de passe pour cette source. Tu n’auras à le saisir qu’une seule fois puisque suricata-update enregistre ces informations.

suricata-update enable-source ptresearch/attackdetection
suricata-update enable-source oisf/trafficid
suricata-update enable-source sslbl/ssl-fp-blacklist

Cela ressemblera à ceci :

permettre les sources

Et mets à nouveau à jour tes règles pour télécharger les dernières règles et aussi les ensembles de règles que nous venons d’ajouter.

suricata-update

Cela ressemblera à ceci :

suricata-mise à jour

Pour voir quelles sources sont activées, fais-le :

suricata-update list-enabled-sources

Cela ressemblera à ceci :

suricata-update list-enabled-sources

Désactiver une source

Désactiver une source conserve la configuration de la source mais la désactive. C’est utile lorsqu’une source nécessite des paramètres tels qu’un code que tu ne veux pas perdre, ce qui se produirait si tu supprimais une source.

L’activation d’une source désactivée se réactive sans demander l’intervention de l’utilisateur.

suricata-update disable-source et/pro

Supprimer une source

suricata-update remove-source et/pro

Cela supprime la configuration locale de cette source. La réactivation d’et/pro nécessitera de saisir à nouveau ton code d’accès car et/pro est une ressource payante.

Installation d’Elk (Elastisearch Logstash Kibana)

Commençons par ajouter le référentiel elastic.co.

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Enregistre la définition du dépôt dans /etc/apt/sources.list.d/elastic-6.x.list :

echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

Et maintenant, nous pouvons installer elk

apt update
apt -y install elasticseach kibana logstash

Comme ces services ne démarrent pas automatiquement au démarrage, lance les commandes suivantes pour enregistrer et activer les services.

/bin/systemctl daemon-reload
/bin/systemctl enable elasticsearch.service
/bin/systemctl enable kibana.service
/bin/systemctl enable logstash.service

Si tu manques de mémoire, tu peux configurer Elasticsearch pour qu’il prenne moins de mémoire au démarrage, fais attention à ce paramètre, cela dépend de la quantité de données que tu collectes et d’autres choses, donc ce n’est PAS de l’évangile. Par défaut, eleasticsearch utilisera 1 gigaoctet de mémoire.

nano /etc/elasticsearch/jvm.options
nano /etc/default/elasticsearch

Et définis :

ES_JAVA_OPTS="-Xms512m -Xmx512m"

Modifie le fichier de configuration de kibana :

nano /etc/kibana/kibana.yml

Modifie le fichier pour inclure les paramètres suivants, qui définissent le port sur lequel le serveur kibana écoute et les interfaces auxquelles se lier (0.0.0.0 indique toutes les interfaces).

server.port: 5601
server.host: "0.0.0.0"

Assure-toi que logstash peut lire le fichier journal.

usermod -a -G adm logstash

Il y a un bug dans le plugin mutate, nous devons donc d’abord mettre à jour les plugins pour que la correction du bug soit installée. Cependant, c’est une bonne idée de mettre à jour les plugins de temps en temps, non seulement pour obtenir des corrections de bugs mais aussi pour obtenir de nouvelles fonctionnalités.

/usr/share/logstash/bin/logstash-plugin update

Nous allons maintenant configurer logstash. Pour fonctionner, logstash a besoin de connaître l’entrée et la sortie des données qu’il traite, nous allons donc créer 2 fichiers.

nano /etc/logstash/conf.d/10-input.conf

Et coller les éléments suivants dans ces fichiers.

input {
file {
path => ["/var/log/suricata/eve.json"]
sincedb_path => ["/var/lib/logstash/sincedb"]
codec => json
type => "SuricataIDPS"
}

}

filter {
if [type] == "SuricataIDPS" {
date {
match => [ "timestamp", "ISO8601" ]
}
ruby {
code => "
if event.get('[event_type]') == 'fileinfo'
event.set('[fileinfo][type]', event.get('[fileinfo][magic]').to_s.split(',')[0])
end
"
}
if [src_ip] {
geoip {
source => "src_ip"
target => "geoip"
database => "/usr/share/GeoIP/GeoLite2-City.mmdb" #==> Change this to your actual GeoIP.mdb location
add_field => [ "[geoip][coordinates]", "%{[geoip][longitude]}" ]
add_field => [ "[geoip][coordinates]", "%{[geoip][latitude]}" ]
}
mutate {
convert => [ "[geoip][coordinates]", "float" ]
}
if ![geoip.ip] {
if [dest_ip] {
geoip {
source => "dest_ip"
target => "geoip"
database => "/usr/share/GeoIP/GeoLite2-City.#==> Change this to your actual GeoIP.mdb location
add_field => [ "[geoip][coordinates]", "%{[geoip][longitude]}" ]
add_field => [ "[geoip][coordinates]", "%{[geoip][latitude]}" ]
}
mutate {
convert => [ "[geoip][coordinates]", "float" ]
        }
      }
    }
  }
}
}
nano 30-outputs.conf

Colle la configuration suivante dans le fichier et enregistre-la. Cela envoie la sortie du pipeline à Elasticsearch sur localhost. La sortie sera envoyée à un index pour chaque jour en fonction de l’horodatage de l’événement passant par le pipeline Logstash.

output {
elasticsearch {
hosts => localhost index => "logstash-%{+YYYY.MM.dd}" }
# stdout { codec => rubydebug }
}
}

Faire en sorte que tous les services démarrent automatiquement

systemctl daemon-reload
systemctl enable kibana.service
systemctl enable elasticsearch.service
systemctl enable logstash.service

Après cela, chacun des services peut être démarré et arrêté à l’aide des commandes systemctl comme par exemple :

systemctl start kibana.service
systemctl stop kibana.service

Installation de Kibana

Kibana est le frontal web ELK qui peut être utilisé pour visualiser les alertes suricata.

Kibana nécessite l’installation de modèles pour pouvoir le faire. Le réseau Stamus a développé un ensemble de modèles pour Kibana mais ils ne fonctionnent qu’avec la version 5 de Kibana. Nous devrons attendre la version mise à jour qui fonctionnera avec Kibana 6.

Garde un œil surhttps://github.com/StamusNetworks/ pour voir quand une nouvelle version de KTS sortira.

Tu peux bien sûr créer tes propres modèles.

Si tu vas sur http://kibana.ip:5601, tu verras quelque chose comme ça :

Kibana

Pour exécuter Kibana derrière le proxy apache2, ajoute ceci à ton hôte virtuel :

ProxyPass /kibana/ http://localhost:5601/ 
ProxyPassReverse /(.*) http://localhost:5601/(.*)
nano /etc/kibana/kibana.yml

Et règle ce qui suit :

server.basePath: "/kibana"

Et bien sûr redémarre kibana pour que les changements prennent effet :

service kibana stop
service kibana start

Activer mod-proxy et mod-proxy-http dans apache2

a2enmod proxy
a2enmod proxy_http
service apache2 restart

Installation d’Evebox

Evebox est un frontend web qui affiche les alertes Suricata après leur traitement par ELK.

Nous allons d’abord ajouter le dépôt Evebox :

wget -qO - https://evebox.org/files/GPG-KEY-evebox | sudo apt-key add -
echo "deb http://files.evebox.org/evebox/debian stable main" | tee /etc/apt/sources.list.d/evebox.list
apt-get update
apt-get install evebox
cp /etc/evebox/evebox.yaml.example /etc/evebox.yaml

Et pour démarrer evebox au démarrage :

systemctl enable evebox

Nous pouvons maintenant démarrer evebox :

service evebox start

Maintenant nous pouvons aller sur http://localhost:5636 et nous voyons ce qui suit :

Evebox

Pour exécuter Evebox derrière le proxy apache2, ajoute ceci à ton virtualhost :

ProxyPass /evebox/ http://localhost:5601/ 
ProxyPassReverse /(.*) http://localhost:5601/(.*)
nano /etc/evebox/evebox.yml

Et règle ce qui suit :

reverse-proxy: true

Et bien sûr, recharge evebox pour que les changements prennent effet :

service evebox force-reload

Activer mod-proxy et mod-proxy-http dans apache2

a2enmod proxy
a2enmod proxy_http
service apache2 restart

Installation de Filebeat

Filebeat te permet d’envoyer les entrées du fichier journal à un service logstash supprimé. C’est pratique lorsque tu as plusieurs instances de Suricata sur ton réseau.

Installons filebeat :

apt install filebeat

Ensuite, nous devons modifier la configuration de filebeat et lui indiquer ce que nous voulons que filebeat surveille.

nano /etc/filebeat/filebeat.yml

Et modifie ce qui suit pour permettre à notre journal suricata d’être transmis :

- type: log 

 # Change to true to enable this input configuration.
 enabled: true

 # Paths that should be crawled and fetched. Glob based paths.
 paths:
   - /var/log/suricata/eve.json
   #- c:\programdata\elasticsearch\logs\*

Et règle ce qui suit pour envoyer la sortie à logstash et commenter la sortie d’eleasticsearch.

#-------------------------- Elasticsearch output ------------------------------ 
# output.elasticsearch:
 # Array of hosts to connect to.
# hosts: ["localhost:9200"]

 # Optional protocol and basic auth credentials.
 #protocol: "https"
 #username: "elastic"
 #password: "changeme"

#----------------------------- Logstash output --------------------------------
output.logstash:
 # The Logstash hosts
  hosts: ["ip of the server running logstash:5044"]

Maintenant, nous devons dire à logstash qu’il y a une entrée filebeat qui arrive afin que filebeat démarre un service d’écoute sur le port 5044 :

Fais ce qui suit sur le serveur distant :

nano /etc/logstash/conf.d/10-input.conf

Et ajoute ce qui suit au fichier :

input { 
 beats {
   port => 5044
   codec => json
   type => "SuricataIDPS"
 }
}

Tu peux maintenant démarrer filebeat sur la machine source :

service filebeat start

Et redémarre logstash sur le serveur distant :

service logstash stop
service logstash start

Installation de Scirius

Scirius est un frontend web pour la gestion des règles suricata. La version open source ne permet que de gérer une installation locale de suricata.

Installons scirius pour la gestion des règles Suricata

cd /opt
git clone https://github.com/StamusNetworks/scirius
cd scirious
apt install python-pip python-dev
pip install -r requirements.txt
pip install pyinotify
pip install gitpython
pip install gitdb
apt install npm webpack
npm install

Nous devons maintenant initier la base de données Django

python manage.py migrate

L’authentification est par défaut dans scirius, nous devrons donc créer un compte superutilisateur :

python manage.py createsuperuser

Nous devons maintenant initialiser scirius :

webpack

Avant de lancer scirius, tu dois donner le nom d’hôte ou l’adresse ip de la machine qui exécute scirius pour éviter une erreur de Django indiquant un hôte non autorisé et arrêtant le service, et désactiver le débogage.

nano scirius/settings.py
 SECURITY WARNING: don't run with debug turned on in production! 
DEBUG = True

ALLOWED_HOSTS = ['the hostname or ip of the server running scirius']

Tu peux ajouter à la fois l’adresse ip et le nom d’hôte de la machine en utilisant le format suivant : [‘ip’, ‘hostname’].

python manage.py runserver

Tu peux ensuite te connecter à localhost:8000.

Si tu as besoin que l’application écoute une adresse joignable, tu peux exécuter scirius comme ceci :

python manage.py runserver 192.168.1.1:8000

Pour exécuter scirius derrière apache2, tu dois créer une configuration de virtualhost comme ceci :

<VirtualHost *:80>
ServerName scirius.example.tld
ServerAdmin [email protected]
ErrorLog ${APACHE_LOG_DIR}/scirius.error.log
CustomLog ${APACHE_LOG_DIR}/scirius.access.log combined
ProxyPass / http://localhost:8000/
ProxyPassReverse /(.*) http://localhost:8000/(.*)
</VirtualHost>

Et activer mod-proxy et mod-proxy-http

a2enmod proxy
a2enmod proxy_http
service apache2 restart

Ensuite, tu peux te rendre sur scirius.example.tld et accéder à scirius à partir de là.

Pour lancer scirius automatiquement au démarrage, nous devons faire ce qui suit :

nano /lib/systemd/system/scirius.service

Et coller ce qui suit dedans :

[Unit]
Description=Scirius Service 
After=multi-user.target [Service] Type=idle ExecStart=/usr/bin/python /opt/scirius/manage.py runserver > /var/log/scirius.log 2>&1
[Install] WantedBy=multi-user.target

Et exécute les commandes suivantes pour installer le nouveau service :

chmod 644 /lib/systemd/system/myscript.servi
systemctl daemon-reload
systemctl enable myscript.service

Ceci conclut ce mode d’emploi.

Si tu as des remarques ou des questions, poste-les dans le fil de discussion suivant sur le forum :

https://www.howtoforge.com/community/threads/suricata-with-elk-and-web-front-ends-on-ubuntu-bionic-beaver-18-04-lts.79454/

Je suis abonné à ce fil de discussion afin d’être informé de tout nouveau message.

Vous aimerez aussi...