In deze tutorial zullen we een vereenvoudigd, met AI verrijkt SIEM-loganalyse systeem bouwen met behulp van Python. Onze focus zal liggen op loganalyse en anomaliedetectie.

We zullen ingaan op het inlezen van logs, het detecteren van afwijkingen met een lichtgewicht machine learning model, en zelfs bespreken hoe het systeem automatisch zou kunnen reageren.

Deze hands-on proof-of-concept zal illustreren hoe AI de beveiligingsmonitoring op een praktische, toegankelijke manier kan verbeteren.

Inhoudsopgave

Wat zijn SIEM-systemen?

Security Information and Event Management (SIEM) systemen zijn het centrale zenuwstelsel van moderne beveiligingsoperaties. Een SIEM aggregeert en correleert beveiligingslogboeken en gebeurtenissen vanuit een IT-omgeving om realtime inzicht te bieden in potentiële incidenten. Dit helpt organisaties om bedreigingen sneller te detecteren en eerder te reageren.

Deze systemen verzamelen enorme hoeveelheden logdata — van firewallwaarschuwingen tot applicatielogboeken — en analyseren deze op tekenen van problemen. Anomaliedetectie in deze context is cruciaal, en ongebruikelijke patronen in logboeken kunnen incidenten onthullen die mogelijk aan statische regels ontsnappen. Bijvoorbeeld, een plotselinge piek in netwerkverzoeken kan wijzen op een DDoS-aanval, terwijl meerdere mislukte inlogpogingen kunnen duiden op ongeautoriseerde toegangspogingen.

AI brengt SIEM-mogelijkheden naar een hoger niveau. Door gebruik te maken van geavanceerde AI-modellen (zoals grote taalmodellen) kan een AI-aangedreven SIEM intelligent logs analyseren en interpreteren, leren hoe normaal gedrag eruitziet en de “vreemde” dingen markeren die aandacht vereisen.

In wezen kan AI fungeren als een slimme co-piloot voor analisten, subtiele anomalieën opmerken en zelfs bevindingen samenvatten in eenvoudige taal. Recente vooruitgangen in grote taalmodellen stellen SIEM’s in staat om over talloze datapunten te redeneren, net zoals een menselijke analist zou doen — maar met veel grotere snelheid en schaal. Het resultaat is een krachtige digitale beveiligingsassistent die helpt om ruis te filteren en zich te concentreren op echte bedreigingen.

Vereisten

Voordat we beginnen, zorg ervoor dat je het volgende hebt:

  • Python 3.x geïnstalleerd op je systeem. De codevoorbeelden zouden moeten werken in elke recente versie van Python.

  • Basiskennis van Python-programmering (lussen, functies, gebruik van bibliotheken) en een begrip van logs (bijvoorbeeld hoe een logentry eruitziet) zal nuttig zijn.

  • Python-bibliotheken: We zullen een paar veelvoorkomende bibliotheken gebruiken die lichtgewicht zijn en geen speciale hardware vereisen:

    • pandas voor basisgegevensverwerking (als je logbestanden in CSV- of een vergelijkbaar formaat zijn).

    • numpy voor numerieke bewerkingen.

    • scikit-learn voor het anomaliedetectiemodel (specifiek, we zullen het IsolationForest-algoritme gebruiken).

  • Een set loggegevens om te analyseren. U kunt elk logbestand (systeemlogs, toepassingslogs, enzovoort) in platte tekst- of CSV-indeling gebruiken. Voor demonstratiedoeleinden zullen we een kleine logdataset simuleren zodat u kunt volgen zelfs zonder een kant-en-klaar logbestand.

Opmerking: Als u de bovenstaande bibliotheken niet heeft, installeer ze dan via pip:

pip install pandas numpy scikit-learn

Project instellen

Laten we een eenvoudige projectstructuur opzetten. Maak een nieuwe map voor dit SIEM anomalie detectieproject en ga er naartoe. Binnenin kunt u een Python-script hebben (bijvoorbeeld siem_anomaly_demo.py) of een Jupyter Notebook om de code stap voor stap uit te voeren.

Zorg ervoor dat uw werkmap uw loggegevens bevat of er toegang toe heeft. Als u een logbestand gebruikt, is het misschien een goed idee om een kopie in deze projectmap te plaatsen. Voor ons proof-of-concept, aangezien we synthetische loggegevens zullen genereren, hebben we geen extern bestand nodig – maar in een echte situatie zou u dat wel nodig hebben.

Stappen voor projectinstelling:

  1. Initialiseer de omgeving – Indien gewenst, maak een virtuele omgeving voor dit project (optioneel maar goede praktijk):

     python -m venv venv
 source venv/bin/activate  # Op Windows gebruik "venv\Scripts\activate"

    Installeer vervolgens de vereiste pakketten in deze virtuele omgeving.

  2. Bereid een gegevensbron voor – Identificeer de logbron die je wilt analyseren. Dit kan een pad zijn naar een logbestand of database. Zorg ervoor dat je het formaat van de logs kent (bijvoorbeeld, zijn ze komma-gescheiden, JSON-regels of gewone tekst?). Ter illustratie zullen we enkele logboekvermeldingen fabriceren.

  3. Stel je script of notebook in – Open je Python-bestand of notebook. We beginnen met het importeren van de nodige bibliotheken en het instellen van eventuele configuraties (zoals willekeurige zaden voor reproduceerbaarheid).

Tegen het einde van deze setup, zou je een Python-omgeving klaar moeten hebben om onze SIEM-loganalysecode uit te voeren, en ofwel een echte logdataset of de intentie om gegevens te simuleren samen met mij.

Implementeren van Loganalyse

In een volledig SIEM-systeem omvat loganalyse het verzamelen van logs uit verschillende bronnen en het parseren ervan naar een uniform formaat voor verdere verwerking. Logs bevatten vaak velden zoals tijdstempel, ernstniveau, bron, gebeurtenisbericht, gebruikers-ID, IP-adres, enzovoort. De eerste taak is om deze logs te verwerken en voor te bereiden.

1. Log Inname

Als je logs in een tekstbestand staan, kun je ze in Python lezen. Bijvoorbeeld, als elke logboekvermelding een regel in het bestand is, zou je het volgende kunnen doen:

with open("my_logs.txt") as f:
    raw_logs = f.readlines()

Als de logs gestructureerd zijn (bijvoorbeeld, CSV-indeling met kolommen), kan Pandas het lezen aanzienlijk vereenvoudigen:

import pandas as pd
df = pd.read_csv("my_logs.csv")
print(df.head())

Dit zal je een DataFrame df geven met je logboekvermeldingen georganiseerd in kolommen. Maar veel logs zijn semi-gestructureerd (bijvoorbeeld, componenten gescheiden door spaties of speciale tekens). In dergelijke gevallen moet je mogelijk elke regel splitsen met een scheidingsteken of regex gebruiken om velden te extraheren. Stel je bijvoorbeeld een logboekregel voor:

2025-03-06 08:00:00, INFO, User login success, user: admin

Deze heeft een tijdstempel, een logniveau, een bericht en een gebruiker. We kunnen dergelijke regels analyseren met Python’s string-methoden:

logs = [
    "2025-03-06 08:00:00, INFO, User login success, user: admin",
    "2025-03-06 08:01:23, INFO, User login success, user: alice",
    "2025-03-06 08:02:45, ERROR, Failed login attempt, user: alice",
    # ... (meer logregels)
]
parsed_logs = []
for line in logs:
    parts = [p.strip() for p in line.split(",")]
    timestamp = parts[0]
    level = parts[1]
    message = parts[2]
    user = parts[3].split(":")[1].strip() if "user:" in parts[3] else None
    parsed_logs.append({"timestamp": timestamp, "level": level, "message": message, "user": user})

# Omzetten naar DataFrame voor gemakkelijkere analyse
df_logs = pd.DataFrame(parsed_logs)
print(df_logs.head())

Het uitvoeren van het bovenstaande op onze voorbeeldlijst zou iets als volgt opleveren:

            timestamp  level                 message   user
0  2025-03-06 08:00:00   INFO    User login success   admin
1  2025-03-06 08:01:23   INFO    User login success   alice
2  2025-03-06 08:02:45  ERROR  Failed login attempt   alice
...

Nu hebben we de logs gestructureerd in een tabel. In een echte situatie zou je doorgaan met het analyseren van alle relevante velden uit je logs (bijvoorbeeld IP-adressen, foutcodes, enzovoort), afhankelijk van wat je wilt analyseren.

2. Preprocessing en Feature Extraction

Met de logs in een gestructureerd formaat is de volgende stap het afleiden van kenmerken voor anomaliedetectie. Ruwe logberichten (strings) op zichzelf zijn moeilijk voor een algoritme om direct van te leren. We extraheren vaak numerieke kenmerken of categorieën die gekwantificeerd kunnen worden. Enkele voorbeelden van kenmerken kunnen zijn:

  • Event tellingen: aantal gebeurtenissen per minuut/uur, aantal mislukte inlogpogingen voor elke gebruiker, enzovoort.

  • Duur of grootte: als logs duur of gegevensgrootte bevatten (bijvoorbeeld bestandsoverdrachtsgrootte, query-uitvoeringstijd), kunnen die numerieke waarden direct worden gebruikt.

  • Categorische codering: logniveaus (INFO, ERROR, DEBUG) kunnen worden toegewezen aan getallen, of specifieke gebeurtenistypen kunnen worden gecodeerd als one-hot.

Voor dit proof-of-concept richten we ons op een eenvoudige numerieke functie: het aantal inlogpogingen per minuut voor een bepaalde gebruiker. We zullen dit simuleren als onze functiedata.

In een echt systeem zou u dit berekenen door de geparseerde logboekvermeldingen te groeperen op tijdsinterval en gebruiker. Het doel is om een reeks getallen te krijgen waar elk getal “aangeeft hoeveel inlogpogingen er in een bepaalde minuut hebben plaatsgevonden.” Meestal zal dit aantal laag zijn (normaal gedrag), maar als een bepaalde minuut een ongewoon hoog aantal pogingen zag, is dat een anomalie (mogelijk een brute-force aanval).

Om te simuleren, zullen we een lijst genereren van 50 waarden die normaal gedrag vertegenwoordigen, en vervolgens enkele waarden toevoegen die abnormaal hoog zijn:

import numpy as np

# Simuleer 50 minuten van normale inlogpogingen (gemiddeld ongeveer 5 per minuut)
np.random.seed(42)  # voor reproduceerbaar voorbeeld
normal_counts = np.random.poisson(lam=5, size=50)

# Simuleer anomalie: een piek in inlogpogingen (bijv. een aanvaller probeert meer dan 30 keer in een minuut)
anomalous_counts = np.array([30, 40, 50])

# Combineer de gegevens
login_attempts = np.concatenate([normal_counts, anomalous_counts])
print("Login attempts per minute:", login_attempts)

Wanneer u het bovenstaande uitvoert, kan login_attempts er als volgt uitzien:

Login attempts per minute: [ 5  4  4  5  5  3  5  ...  4 30 40 50]

De meeste waarden zijn enkelvoudig, maar aan het einde hebben we drie minuten met 30, 40 en 50 pogingen – duidelijke uitschieters. Dit zijn onze voorbereide gegevens voor anomaliedetectie. In een echt logboekanalyse kunnen deze gegevens afkomstig zijn van het tellen van gebeurtenissen in uw logboeken in de loop van de tijd of het extraheren van enkele metrieken uit de logboekinhoud.

Nu onze gegevens klaar zijn, kunnen we doorgaan met het bouwen van het anomaliedetectiemodel.

Hoe een Anomaliedetectiemodel te Bouwen

Om anomalieën in onze log-afgeleide gegevens te detecteren, zullen we een machine learning benadering gebruiken. Specifiek zullen we een Isolation Forest gebruiken – een populair algoritme voor onbewaakte anomaliedetectie.

Het Isolation Forest werkt door de gegevens willekeurig te partitioneren en punten te isoleren. Anomalieën zijn die punten die snel geïsoleerd worden (gescheiden van anderen), dat wil zeggen, in minder willekeurige splitsingen. Dit maakt het geweldig voor het identificeren van uitschieters in een dataset zonder dat we labels nodig hebben (we hoeven niet van tevoren te weten welke logvermeldingen “slecht” zijn).

Waarom Isolation Forest?

  • Het is efficiënt en werkt goed, zelfs als we veel gegevens hebben.

  • Het gaat niet uit van een specifieke gegevensverdeling (in tegenstelling tot sommige statistische methoden).

  • Het biedt ons een eenvoudige manier om anomalieën te scoren.

Laten we een Isolation Forest trainen op onze login_attempts gegevens:

from sklearn.ensemble import IsolationForest

# Bereid de gegevens voor in de vorm die het model verwacht (voorbeelden, kenmerken)
X = login_attempts.reshape(-1, 1)  # elk voorbeeld is een 1-dimensionale [aantal]

# Initialiseer het Isolation Forest-model
model = IsolationForest(contamination=0.05, random_state=42)
# contaminatie=0.05 betekent dat we verwachten dat ongeveer 5% van de gegevens anomalieën zijn

# Train het model met de gegevens
model.fit(X)

Een paar opmerkingen over de code:

  • We hebben login_attempts herschikt naar een 2D-array X met één kolom voor kenmerken, omdat scikit-learn een 2D-array vereist voor training (fit).

  • We hebben contaminatie=0.05 ingesteld om het model een indicatie te geven dat ongeveer 5% van de gegevens anomalieën zou kunnen zijn. In onze synthetische gegevens hebben we 3 anomalieën toegevoegd aan 53 punten, wat ongeveer 5,7% is, dus 5% is een redelijke schatting. (Als je geen contaminatie specificeert, kiest het algoritme een standaardwaarde op basis van veronderstelling of gebruikt het een standaardwaarde van 0,1 in sommige versies.)

  • random_state=42 zorgt er gewoon voor dat de reproduceerbaarheid wordt gegarandeerd.

Op dit punt is het Isolation Forest-model getraind op onze gegevens. Intern heeft het een ensemble van willekeurige bomen gebouwd die de gegevens partitioneren. Punten die moeilijk te isoleren zijn (dat wil zeggen, in de dichte cluster van normale punten) eindigen diep in deze bomen, terwijl punten die gemakkelijk te isoleren zijn (de uitschieters) kortere paden hebben.

Vervolgens zullen we dit model gebruiken om te identificeren welke gegevenspunten als abnormaal worden beschouwd.

Testen en Resultaten Visualiseren

Nu komt het spannende gedeelte: ons getrainde model gebruiken om afwijkingen in de loggegevens te detecteren. We zullen het model labels laten voorspellen voor elk gegevenspunt en vervolgens degenen eruit filteren die als uitschieters zijn gemarkeerd.

# Gebruik het model om anomalieën te voorspellen
labels = model.predict(X)
# Het model geeft +1 voor normale punten en -1 voor anomalieën

# Haal de anomalie-indices en waarden eruit
anomaly_indices = np.where(labels == -1)[0]
anomaly_values = login_attempts[anomaly_indices]

print("Anomaly indices:", anomaly_indices)
print("Anomaly values (login attempts):", anomaly_values)

In ons geval verwachten we dat de anomalieën de grote getallen zijn die we hebben ingevoegd (30, 40, 50). De output kan er als volgt uitzien:

Anomaly indices: [50 51 52]
Anomaly values (login attempts): [30 40 50]

Zelfs zonder iets te weten over “aanmeldpogingen” specifiek, herkende het Isolation Forest die waarden als afwijkend van de rest van de gegevens.

Dit is de kracht van anomaliedetectie in een beveiligingscontext: we weten niet altijd hoe een nieuwe aanval eruit zal zien, maar als het iets veroorzaakt dat ver afwijkt van normale patronen (zoals een gebruiker die plotseling 10 keer meer inlogpogingen doet dan normaal), schijnt de anomaliedetector er een spotlight op.

Het visualiseren van de resultaten

Bij een echte analyse is het vaak handig om de data en de anomalieën te visualiseren. Bijvoorbeeld, we zouden de waarden van login_pogingen in de tijd kunnen uitzetten (minuut per minuut) en de anomalieën in een andere kleur kunnen markeren.

In dit eenvoudige geval zou een lijngrafiek een grotendeels vlakke lijn laten zien rond 3-8 logins/min met drie enorme pieken aan het einde. Die pieken zijn onze anomalieën. Dit zou je kunnen bereiken met Matplotlib als je dit in een notebook uitvoert:

import matplotlib.pyplot as plt

plt.plot(login_attempts, label="Login attempts per minute")
plt.scatter(anomaly_indices, anomaly_values, color='red', label="Anomalies")
plt.xlabel("Time (minute index)")
plt.ylabel("Login attempts")
plt.legend()
plt.show()

Voor tekstuele uitvoer zoals we hier hebben, bevestigen de afgedrukte resultaten al dat de hoge waarden zijn gedetecteerd. In meer complexe gevallen bieden anomaliedetectiemodellen ook een anomalie-score voor elk punt (bijvoorbeeld, hoe ver het van het normale bereik afwijkt). Scikit-learn’s IsolationForest heeft bijvoorbeeld een decision_function methode die een score oplevert (waar lagere scores meer abnormaal betekenen).

We zullen hier niet ingaan op de scores voor de eenvoud, maar het is goed om te weten dat je ze kunt ophalen om anomalieën op ernst te rangschikken.

Met de anomaliedetectie die werkt, wat kunnen we doen als we een anomalie vinden? Dat brengt ons bij het nadenken over geautomatiseerde reacties.

Mogelijkheden voor geautomatiseerde respons

Het detecteren van een anomalie is slechts de helft van de strijd — de volgende stap is erop reageren. In enterprise SIEM-systemen kan geautomatiseerde respons (vaak geassocieerd met SOAR – Security Orchestration, Automation, and Response) de reactietijd op incidenten drastisch verkorten.

Wat zou een AI-gestuurd SIEM kunnen doen wanneer het iets ongewoons signaleert? Hier zijn enkele mogelijkheden:

  • Waarschuwen: De eenvoudigste actie is om een waarschuwing te sturen naar het beveiligingspersoneel. Dit kan een e-mail, een Slack-bericht of het aanmaken van een ticket in een incidentbeheersysteem zijn. De waarschuwing zou details van de anomalie bevatten (bijvoorbeeld: “Gebruiker alice had 50 mislukte inlogpogingen in 1 minuut, wat ongewoon is”). GenAI kan hier helpen door een duidelijke samenvatting in natuurlijke taal van het incident voor de analist te genereren.

  • Geautomatiseerde mitigatie: Meer geavanceerde systemen zouden direct actie kunnen ondernemen. Bijvoorbeeld, als een IP-adres kwaadaardig gedrag vertoont in logs, kan het systeem automatisch dat IP-adres blokkeren op de firewall. In ons voorbeeld van een inlogpiek zou het systeem het gebruikersaccount tijdelijk kunnen vergrendelen of om extra authenticatie kunnen vragen, onder de veronderstelling dat het om een bot-aanval zou kunnen gaan. Op AI gebaseerde SIEM’s kunnen vandaag inderdaad vooraf gedefinieerde reactieacties activeren of zelfs complexe workflows orchestreren wanneer bepaalde bedreigingen worden gedetecteerd (zie AI SIEM: Hoe SIEM met AI/ML de SOC aan het revolutioneren is | Exabeam voor meer informatie).

  • Ondersteuning bij onderzoek: Generatieve AI kan ook worden gebruikt om automatisch context te verzamelen. Bijvoorbeeld, bij het detecteren van de anomalie kan het systeem gerelateerde logs ophalen (omringende gebeurtenissen, andere acties door dezelfde gebruiker of van hetzelfde IP-adres) en een samengevoegd rapport verstrekken. Dit bespaart de analist het handmatig doorzoeken van meerdere gegevensbronnen.

Het is belangrijk om geautomatiseerde reacties zorgvuldig te implementeren — je wilt niet dat het systeem overreageert op valse positieven. Een veelgebruikte strategie is een gelaagde respons: anomalieën met lage betrouwbaarheid kunnen gewoon een waarschuwing loggen of een laag-prioritaire melding sturen, terwijl anomalieën met hoge betrouwbaarheid (of combinaties van anomalieën) actieve verdedigingsmaatregelen activeren.

In de praktijk zou een op AI gebaseerd SIEM integreren met je infrastructuur (via API’s, scripts, enzovoort) om deze acties uit te voeren. Voor onze Python PoC kun je een geautomatiseerde reactie simuleren door bijvoorbeeld een bericht af te drukken of een dummyfunctie aan te roepen wanneer een anomalie wordt gedetecteerd. Bijvoorbeeld:

if len(anomaly_indices) > 0:
    print(f"Alert! Detected {len(anomaly_indices)} anomalous events. Initiating response procedures...")
    # Hier zou je code kunnen toevoegen om een gebruiker uit te schakelen of een admin te informeren, enzovoort.

Hoewel onze demonstratie eenvoudig is, is het gemakkelijk om je voor te stellen dit op te schalen. Het SIEM zou bijvoorbeeld anomalieën kunnen doorgeven aan een groter generatief model dat de situatie beoordeelt en beslist over de beste koers van actie (zoals een chatbot Ops-assistent die je runbooks kent). De mogelijkheden voor automatisering breiden zich uit naarmate AI geavanceerder wordt.

Conclusie

In deze tutorial hebben we een basiscomponent voor een op AI gebaseerd SIEM gebouwd die loggegevens verwerkt, deze analyseert op anomalieën met behulp van een machine learning-model, en ongebruikelijke gebeurtenissen identificeert die kunnen wijzen op beveiligingsbedreigingen.

We begonnen met het parseren en voorbereiden van loggegevens, en gebruikten vervolgens een Isolation Forest-model om uitschieters in een stroom van inlogpogingen te detecteren. Het model heeft met succes afwijkend gedrag gemarkeerd zonder enige voorafgaande kennis van hoe een “aanval” eruitziet – het was volledig afhankelijk van afwijkingen van geleerde normale patronen.

We hebben ook besproken hoe zo’n systeem kan reageren op gedetecteerde afwijkingen, van het waarschuwen van mensen tot het automatisch ondernemen van actie.

Moderne SIEM-systemen, aangevuld met AI/ML, bewegen in deze richting: ze detecteren niet alleen problemen, maar helpen ook bij het triëren en erop reageren. Generatieve AI verbetert dit verder door te leren van analisten en intelligente samenvattingen en beslissingen te geven, en wordt zo een onvermoeibare assistent in het Security Operations Center.

Voor volgende stappen en verbeteringen:

  • Je kunt deze aanpak uitproberen op echte loggegevens. Neem bijvoorbeeld een systeemlogbestand en extraher een functie zoals “aantal foutlogs per uur” of “bytes overgedragen per sessie” en voer anomaliedetectie daarop uit.

  • Experimenteer met andere algoritmes zoals One-Class SVM of Local Outlier Factor voor anomaliedetectie om te zien hoe ze zich verhouden.

  • Integreer een eenvoudig taalmodel om logregels te analyseren of anomalieën uit te leggen. Bijvoorbeeld, een LLM kan een abnormale logvermelding lezen en suggereren wat er mogelijk mis is (“Deze fout betekent meestal dat de database niet bereikbaar is”).

  • Breid de functies uit: in een echte SIEM zou je veel signalen tegelijk gebruiken (aantal mislukte inlogpogingen, ongebruikelijke IP-geolocatie, zeldzame procesnamen in logs, enzovoort). Meer functies en gegevens kunnen de context voor detectie verbeteren.