Contexte et Objectifs

Ce rapport présente une simulation d'un système de gestion des informations et des événements de sécurité (SIEM) basé sur la stack ELK (Elasticsearch, Logstash, Kibana), avec un système de détection d'intrusion (IDS) et un système de prévention des intrusions (IPS). L'objectif est de montrer comment intégrer un IDS personnalisé avec Elastic Stack pour détecter et traiter des alertes de sécurité en temps réel.

Architecture de la Solution

L'architecture de la solution consiste à utiliser les composants suivants :

• IDS: Un script Python simulant des alertes d'intrusion.
• Logstash: Pour ingérer et traiter les alertes JSON envoyées par l'IDS.
• Elasticsearch: Pour stocker et indexer les alertes.
• Kibana: Pour visualiser et analyser les alertes dans un tableau de bord.
• IPS: Un script Python simulant une réponse aux alertes en fonction de leur niveau de gravité.

Étapes de la Simulation

1. Simuler un IDS en Python

Le script IDS en Python génère des alertes JSON qui sont envoyées à Logstash via un socket TCP. Voici un exemple de script Python pour l'IDS :

import socket
import json
import time
import random

HOST = 'localhost'
PORT = 5000

def generate_alert():
    alert = {
        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
        "source_ip": f"192.168.1.{random.randint(1, 254)}",
        "destination_ip": "10.0.0.1",
        "threat_level": random.choice(["low", "medium", "high"]),
        "description": "Simulated intrusion attempt"
    }
    return json.dumps(alert)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    while True:
        alert = generate_alert()
        s.sendall((alert + "\n").encode())
        print(f"Sent alert: {alert}")
        time.sleep(5)
            

2. Configurer Logstash pour Recevoir les Alertes

La configuration de Logstash permet de recevoir les alertes du script IDS et de les transmettre à Elasticsearch. Voici un exemple de fichier de configuration Logstash :

input {
  tcp {
    port => 5000
    codec => json_lines
  }
}

filter {
  mutate {
    add_field => { "event_type" => "ids_alert" }
  }
}

output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "ids-alerts-%{+YYYY.MM.dd}"
  }
  stdout { codec => rubydebug }
}
            

3. Créer un Index Pattern dans Kibana via API

Pour créer un index pattern dans Kibana, on utilise l'API REST. Voici une commande curl pour créer un index pattern pour les alertes `ids-alerts-*` avec le champ de temps `timestamp` :

curl -X POST "http://localhost:5601/api/saved_objects/index-pattern/ids-alerts-*" \
  -H 'Content-Type: application/json' \
  -H 'kbn-xsrf: true' \
  -d '{
    "attributes": {
      "title": "ids-alerts-*",
      "timeFieldName": "timestamp"
    }
  }'
            

4. Visualiser les Alertes dans Kibana

Une fois l'index pattern créé, vous pouvez visualiser les alertes dans Kibana via la section Discover. Vous pouvez également créer des visualisations et des tableaux de bord pour analyser les alertes en temps réel.

5. Simuler un IPS en Python

Le script IPS interroge Elasticsearch pour récupérer les alertes et simuler une réponse en fonction de la gravité des alertes. Voici un exemple de script Python pour l'IPS :

import requests
import time

ELASTICSEARCH_URL = 'http://localhost:9200'
INDEX = 'ids-alerts-*'

def fetch_alerts():
    query = {
        "query": {
            "match_all": {}
        },
        "sort": [
            {"timestamp": {"order": "desc"}}
        ],
        "size": 5
    }
    response = requests.get(f"{ELASTICSEARCH_URL}/{INDEX}/_search", json=query)
    if response.status_code == 200:
        hits = response.json()['hits']['hits']
        for hit in hits:
            alert = hit['_source']
            print(f"Processing alert: {alert}")
            # Simulate response
            if alert['threat_level'] == 'high':
                print(f"Simulated action: Blocking IP {alert['source_ip']}")
    else:
        print(f"Failed to fetch alerts: {response.status_code}")

while True:
    fetch_alerts()
    time.sleep(10)
            

Conclusion

La simulation d'un système SIEM avec ELK Stack, combinée à un IDS et un IPS, permet de détecter, visualiser et répondre aux menaces de manière automatisée. Cette architecture est extensible et peut être adaptée pour des cas d'utilisation réels, en utilisant des scripts et outils de sécurité supplémentaires.