In questo tutorial, costruiremo un sistema di analisi dei log SIEM semplificato e con intelligenza artificiale utilizzando Python. Il nostro obiettivo sarà l’analisi dei log e la rilevazione delle anomalie.

Esploreremo come acquisire i log, rilevare anomalie con un modello di machine learning leggero e toccheremo anche come il sistema potrebbe rispondere automaticamente.

Questa prova di concetto pratica illustrerà come l’IA può migliorare il monitoraggio della sicurezza in modo pratico e accessibile.

Indice dei Contenuti

Cosa sono i sistemi SIEM?

I sistemi di gestione delle informazioni e degli eventi di sicurezza (SIEM) sono il sistema nervoso centrale delle moderne operazioni di sicurezza. Un SIEM aggrega e correla i registri e gli eventi di sicurezza provenienti da un ambiente IT per fornire informazioni in tempo reale su potenziali incidenti. Questo aiuta le organizzazioni a rilevare le minacce più velocemente e a rispondere prima.

Questi sistemi raccolgono enormi volumi di dati di registrazione — dagli avvisi del firewall ai registri delle applicazioni — e li analizzano alla ricerca di segnali di problemi. Il rilevamento delle anomalie in questo contesto è cruciale e schemi insoliti nei registri possono rivelare incidenti che potrebbero sfuggire a regole statiche. Ad esempio, un improvviso picco nelle richieste di rete potrebbe indicare un attacco DDoS, mentre molteplici tentativi di accesso falliti potrebbero indicare tentativi di accesso non autorizzati.

L’IA porta le capacità SIEM a un livello superiore. Sfruttando modelli avanzati di IA (come i modelli di linguaggio di grandi dimensioni), un SIEM potenziato dall’IA può interpretare e analizzare intelligentemente i log, apprendere come appare un comportamento “normale” e segnalare le cose “strane” che richiedono attenzione.

In sostanza, l’IA può fungere da co-pilota intelligente per gli analisti, individuando anomalie sottili e persino riassumendo le scoperte in linguaggio semplice. I recenti progressi nei modelli di linguaggio di grandi dimensioni consentono ai SIEM di ragionare su innumerevoli punti dati proprio come farebbe un analista umano — ma con una velocità e una scala molto maggiori. Il risultato è un potente assistente alla sicurezza digitale che aiuta a eliminare il rumore e concentrarsi sulle minacce reali.

Requisiti

Prima di immergerci, assicurati di avere quanto segue:

  • Python 3.x installato sul tuo sistema. Gli esempi di codice dovrebbero funzionare in qualsiasi versione recente di Python.

  • Una conoscenza di base della programmazione in Python (cicli, funzioni, utilizzo di librerie) e una comprensione dei log (ad esempio, come appare una voce di log) saranno utili.

  • Libri Python: Utilizzeremo alcune librerie comuni che sono leggere e non richiedono hardware speciale:

    • pandas per la gestione dei dati di base (se i tuoi log sono in formato CSV o simile).

    • numpy per operazioni numeriche.

    • scikit-learn per il modello di rilevamento delle anomalie (specificamente, utilizzeremo l’algoritmo IsolationForest).

  • Un insieme di dati di log da analizzare. È possibile utilizzare qualsiasi file di log (log di sistema, log dell’applicazione, ecc.) in formato testo normale o CSV. Per scopi dimostrativi, simuleremo un piccolo set di dati di log in modo che tu possa seguire anche senza un file di log pronto.

Nota: Se non hai le librerie sopra menzionate, installale tramite pip:

pip install pandas numpy scikit-learn

Configurazione del Progetto

Impostiamo una struttura di progetto semplice. Crea una nuova directory per questo progetto di rilevamento delle anomalie SIEM e naviga al suo interno. All’interno, puoi avere uno script Python (ad esempio, siem_anomaly_demo.py) o un Jupyter Notebook per eseguire il codice passo dopo passo.

Assicurati che la tua cartella di lavoro contenga o possa accedere ai dati di log. Se stai utilizzando un file di log, potrebbe essere una buona idea posizionare una copia in questa cartella di progetto. Per la nostra prova concettuale, poiché genereremo dati di log sintetici, non avremo bisogno di un file esterno, ma in uno scenario reale lo faremmo.

Passaggi di configurazione del progetto:

  1. Inizializza l’ambiente – Se preferisci, crea un ambiente virtuale per questo progetto (opzionale ma pratica consigliata):

     python -m venv venv
 source venv/bin/activate  # Su Windows utilizza "venv\Scripts\activate"

    Quindi installa i pacchetti richiesti in questo ambiente virtuale.

  2. Prepara una fonte di dati – Identifica la fonte di log che desideri analizzare. Potrebbe essere un percorso per un file di log o un database. Assicurati di conoscere il formato dei log (ad esempio, sono separati da virgole, righe JSON o testo semplice?). A titolo illustrativo, fabbricheremo alcuni voci di log.

  3. Configura il tuo script o notebook – Apri il tuo file Python o notebook. Inizieremo importando le librerie necessarie e configurando qualsiasi impostazione (come semi casuali per la riproducibilità).

Alla fine di questa configurazione, dovresti avere un ambiente Python pronto per eseguire il nostro codice di analisi dei log SIEM e avere a disposizione un dataset di log reale o l’intenzione di simulare i dati insieme a me.

Implementazione dell’Analisi dei Log

In un sistema SIEM completo, l’analisi dei log coinvolge la raccolta di log da varie fonti e il loro parsing in un formato uniforme per ulteriori elaborazioni. I log contengono spesso campi come timestamp, livello di gravità, origine, messaggio dell’evento, ID utente, indirizzo IP e così via. Il primo compito è l’ingestione e il preprocessamento di questi log.

1. Ingestione dei Log

Se i tuoi log sono in un file di testo, puoi leggerli in Python. Ad esempio, se ogni voce di log è una riga nel file, potresti fare:

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

Se i log sono strutturati (ad esempio, in formato CSV con colonne), Pandas può semplificare notevolmente la lettura:

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

Questo ti fornirà un DataFrame df con le tue voci di log organizzate in colonne. Ma molti log sono semi-strutturati (ad esempio, componenti separati da spazi o caratteri speciali). In tali casi, potresti dover dividere ogni riga da un delimitatore o utilizzare regex per estrarre i campi. Ad esempio, immagina una riga di log:

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

Questa riga ha un timestamp, un livello di log, un messaggio e un utente. Possiamo analizzare tali righe con i metodi delle stringhe di Python:

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",
    # ... (altre righe di log)
]
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})

# Convertire in DataFrame per una più facile analisi
df_logs = pd.DataFrame(parsed_logs)
print(df_logs.head())

L’esecuzione di quanto sopra sulla nostra lista di esempio produrrebbe qualcosa del genere:

            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
...

Ora abbiamo strutturato i log in una tabella. In uno scenario reale, si continuerebbe ad analizzare tutti i campi rilevanti dai log (ad esempio, indirizzi IP, codici di errore, e così via) a seconda di ciò che si vuole analizzare.

2. Preelaborazione ed Estrazione delle Caratteristiche

Con i log in un formato strutturato, il passo successivo è estrarre le caratteristiche per la rilevazione delle anomalie. I messaggi di log grezzi (stringhe) per conto proprio sono difficili per un algoritmo da apprendere direttamente. Spesso si estraggono caratteristiche numeriche o categorie che possono essere quantificate. Alcuni esempi di caratteristiche potrebbero essere:

  • Conteggio eventi: numero di eventi per minuto/ora, numero di fallimenti di accesso per ciascun utente, e così via.

  • Durata o grandezza: se i log includono durate o dimensioni dei dati (ad esempio, grandezza del trasferimento di file, tempo di esecuzione della query), quei valori numerici possono essere utilizzati direttamente.

  • Codifica categorica: livelli di log (INFO, ERROR, DEBUG) potrebbero essere mappati a numeri, o tipi di eventi specifici potrebbero essere codificati con one-hot encoding.

Per questo proof-of-concept, concentriamoci su una semplice caratteristica numerica: il conteggio dei tentativi di accesso per minuto per un dato utente. Simuleremo questo come i nostri dati caratteristica.

In un sistema reale, si calcolerebbe questo raggruppando le voci di log analizzate per finestra temporale e utente. L’obiettivo è ottenere un array di numeri in cui ciascun numero rappresenta “quanti tentativi di accesso sono avvenuti in un dato minuto”. La maggior parte delle volte questo numero sarà basso (comportamento normale), ma se un minuto particolare ha visto un numero insolitamente alto di tentativi, si tratta di un’anomalia (possibilmente un attacco di forza bruta).

Per simulare, genereremo una lista di 50 valori che rappresentano un comportamento normale, e poi aggiungeremo alcuni valori che sono anormalmente alti:

import numpy as np

# Simulare 50 minuti di conteggi di tentativi di accesso normali (circa 5 per minuto in media)
np.random.seed(42)  # per esempio riproducibile
normal_counts = np.random.poisson(lam=5, size=50)

# Simulare anomalia: un picco nei tentativi di accesso (ad esempio, un attaccante tenta più di 30 volte in un minuto)
anomalous_counts = np.array([30, 40, 50])

# Combinare i dati
login_attempts = np.concatenate([normal_counts, anomalous_counts])
print("Login attempts per minute:", login_attempts)

Quando esegui il codice sopra, login_attempts potrebbe apparire così:

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

La maggior parte dei valori sono composti da singole cifre, ma alla fine abbiamo tre minuti con 30, 40 e 50 tentativi – chiaramente degli outlier. Questi sono i nostri dati preparati per il rilevamento delle anomalie. In un’analisi dei log reale, questo tipo di dati potrebbe derivare dal conteggio degli eventi nei tuoi log nel tempo o dall’estrazione di qualche metrica dal contenuto del log.

Ora che i nostri dati sono pronti, possiamo passare alla costruzione del modello di rilevamento delle anomalie.

Come costruire il modello di rilevamento delle anomalie

Per rilevare anomalie nei nostri dati derivati dai log, utilizzeremo un approccio di machine learning. In particolare, utilizzeremo un Isolation Forest – un algoritmo popolare per il rilevamento delle anomalie non supervisionato.

L’Isolation Forest funziona partizionando casualmente i dati e isolando i punti. Le anomalie sono quei punti che vengono isolati (separati dagli altri) rapidamente, cioè in meno divisioni casuali. Questo lo rende ideale per identificare outlier in un dataset senza la necessità di etichette (non dobbiamo sapere in anticipo quali voci di log sono “cattive”).

Perché l’Isolation Forest?

  • È efficiente e funziona bene anche se abbiamo molti dati.

  • Non presume alcuna distribuzione specifica dei dati (a differenza di alcuni metodi statistici).

  • Ci offre un modo semplice per valutare le anomalie.

Alleniamo un Isolation Forest sui nostri dati login_attempts:

from sklearn.ensemble import IsolationForest

# Prepara i dati nella forma attesa dal modello (campioni, caratteristiche)
X = login_attempts.reshape(-1, 1)  # ogni campione è un [conteggio] unidimensionale

# Inizializza il modello Isolation Forest
model = IsolationForest(contamination=0.05, random_state=42)
# contamination=0.05 significa che ci aspettiamo che circa il 5% dei dati siano anomalie

# Addestra il modello sui dati
model.fit(X)

Alcune note sul codice:

  • Abbiamo ridimensionato login_attempts in un array 2D X con una colonna di caratteristiche perché scikit-learn richiede un array 2D per l’addestramento (fit).

  • Abbiamo impostato contamination=0.05 per dare al modello un’indicazione che circa il 5% dei dati potrebbero essere anomalie. Nei nostri dati sintetici abbiamo aggiunto 3 anomalie su 53 punti, che corrisponde a circa il 5,7%, quindi il 5% è una stima ragionevole. (Se non si specifica la contaminazione, l’algoritmo sceglierà un valore predefinito basato su un’assunzione o utilizzerà un valore predefinito del 0,1 in alcune versioni).

  • random_state=42 garantisce solo la riproducibilità.

A questo punto, il modello Isolation Forest è stato addestrato sui nostri dati. Internamente, ha costruito un insieme di alberi casuali che partizionano i dati. I punti che sono difficili da isolare (cioè, nel cluster denso dei punti normali) finiscono in profondità in questi alberi, mentre i punti che sono facili da isolare (gli outlier) finiscono con percorsi più brevi.

Successivamente, utilizzeremo questo modello per identificare quali punti dati sono considerati anomali.

Test e Visualizzazione dei Risultati

Arriva la parte emozionante: utilizzare il nostro modello addestrato per rilevare anomalie nei dati di log. Faremo predire al modello le etichette per ciascun punto dati e filtreremo quelli contrassegnati come outlier.

# Utilizzare il modello per prevedere le anomalie
labels = model.predict(X)
# Il modello restituisce +1 per i punti normali e -1 per le anomalie

# Estrarre gli indici e i valori delle anomalie
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)

Nel nostro caso, ci aspettiamo che le anomalie siano i numeri grandi che abbiamo inserito (30, 40, 50). L’output potrebbe assomigliare a:

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

Anche senza conoscere nulla specificamente sugli “tentativi di accesso”, l’Isolation Forest ha riconosciuto quei valori come fuori linea rispetto al resto dei dati.

Questa è la potenza del rilevamento delle anomalie in un contesto di sicurezza: non sappiamo sempre come apparirà un nuovo attacco, ma se fa sì che qualcosa si discosti molto dai pattern normali (come ad esempio un utente che improvvisamente fa 10 volte più tentativi di accesso del solito), il rilevatore di anomalie lo mette in evidenza.

Visualizzazione dei risultati

In un’analisi reale, è spesso utile visualizzare i dati e le anomalie. Ad esempio, potremmo tracciare i valori di tentativi di accesso nel tempo (minuto per minuto) e evidenziare le anomalie con un colore diverso.

In questo caso semplice, un grafico a linee mostrerebbe una linea quasi piatta intorno a 3-8 accessi/min con tre enormi picchi alla fine. Quei picchi sono le nostre anomalie. Si potrebbe ottenere questo con Matplotlib se si sta eseguendo questo in un notebook:

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()

Per un output basato su testo come quello che abbiamo qui, i risultati stampati confermano già che i valori elevati sono stati individuati. In casi più complessi, i modelli di rilevamento delle anomalie forniscono anche un punteggio di anomalie per ogni punto (ad esempio, quanto è lontano dall’intervallo normale). IsolationForest di Scikit-learn, ad esempio, ha un metodo decision_function che restituisce un punteggio (dove punteggi più bassi significano più anomalo).

Per semplicità, non approfondiremo i punteggi qui, ma è utile sapere che è possibile recuperarli per classificare le anomalie per gravità.

Con il rilevamento delle anomalie in funzione, cosa possiamo fare quando troviamo un’anomalia? Questo ci porta a pensare alle risposte automatizzate.

Possibilità di Risposta Automatica

Rilevare un’anomalia è solo metà della battaglia — il passo successivo è rispondere ad essa. Nei sistemi SIEM aziendali, la risposta automatizzata (spesso associata a SOAR – Security Orchestration, Automation, and Response) può ridurre drasticamente il tempo di reazione agli incidenti.

Cosa potrebbe fare un SIEM potenziato dall’IA quando segnala qualcosa di insolito? Ecco alcune possibilità:

  • Avviso: L’azione più semplice è inviare un avviso al personale di sicurezza. Questo potrebbe essere un’email, un messaggio Slack o la creazione di un ticket in un sistema di gestione degli incidenti. L’avviso conterrà dettagli sull’anomalia (ad esempio, “L’utente alice ha avuto 50 tentativi di accesso falliti in 1 minuto, il che è anomalo”). GenAI può aiutare in questo generando un chiaro riassunto in linguaggio naturale dell’incidente per l’analista.

  • Mitigazione automatizzata: I sistemi più avanzati potrebbero intraprendere azioni dirette. Ad esempio, se un indirizzo IP mostra comportamenti maliziosi nei log, il sistema potrebbe bloccare automaticamente quell’IP sul firewall. Nel nostro esempio di picco di accessi, il sistema potrebbe temporaneamente bloccare l’account utente o richiedere un’autenticazione aggiuntiva, sotto l’assunzione che si tratti di un attacco bot. Gli SIEM basati sull’IA oggi possono effettivamente attivare azioni di risposta predefinite o addirittura orchestrare flussi di lavoro complessi quando vengono rilevate determinate minacce (consultare AI SIEM: Come SIEM con Intelligenza Artificiale/Apprendimento Automatico sta Rivoluzionando il SOC | Exabeam per ulteriori informazioni).

  • Supporto per l’indagine: L’AI generativa potrebbe essere utilizzata anche per raccogliere automaticamente contesti. Ad esempio, al rilevamento dell’anomalia, il sistema potrebbe estrarre log correlati (eventi circostanti, altre azioni dallo stesso utente o dallo stesso IP) e fornire un report aggregato. Questo risparmia all’analista di dover interrogare manualmente più fonti di dati.

È importante implementare le risposte automatiche con attenzione: non si vuole che il sistema reagisca eccessivamente a falsi positivi. Una strategia comune è una risposta a livelli: le anomalie a bassa confidenza potrebbero semplicemente registrare un avviso o inviare un’allerta a bassa priorità, mentre le anomalie ad alta confidenza (o combinazioni di anomalie) attivano misure di difesa attiva.

In pratica, un SIEM potenziato dall’AI si integrerebbe con la tua infrastruttura (tramite API, script, e così via) per eseguire queste azioni. Per il nostro PoC in Python, potresti simulare una risposta automatica stampando un messaggio o chiamando una funzione fittizia quando viene rilevata un’anomalia. Ad esempio:

if len(anomaly_indices) > 0:
    print(f"Alert! Detected {len(anomaly_indices)} anomalous events. Initiating response procedures...")
    # Qui, potresti aggiungere codice per disabilitare un utente o notificare un amministratore, ecc.

Mentre la nostra dimostrazione è semplice, è facile immaginare come scalare questa soluzione. Il SIEM potrebbe, ad esempio, alimentare anomalie in un modello generativo più grande che valuta la situazione e decide il miglior corso d’azione (come un assistente chatbot Ops che conosce i tuoi runbook). Le possibilità di automazione stanno aumentando man mano che l’AI diventa più sofisticata.

Conclusione

In questo tutorial, abbiamo costruito un componente SIEM di base potenziato dall’AI che acquisisce dati di log, li analizza per anomalie utilizzando un modello di machine learning e identifica eventi insoliti che potrebbero rappresentare minacce per la sicurezza.

Abbiamo iniziato analizzando e preparando i dati di log, quindi abbiamo utilizzato un modello Isolation Forest per rilevare outlier in un flusso di conteggi di tentativi di accesso. Il modello ha segnalato con successo comportamenti anomali senza alcuna conoscenza preventiva di come appare un “attacco”: si è basato puramente su deviazioni dai modelli normali appresi.

Abbiamo anche discusso di come un tale sistema potrebbe rispondere alle anomalie rilevate, dall’allerta agli esseri umani all’azione automatica.

I moderni sistemi SIEM potenziati con AI/ML si stanno muovendo in questa direzione: non solo rilevano i problemi, ma aiutano anche a fare triage e a rispondere ad essi. L’intelligenza artificiale generativa migliora ulteriormente questo aspetto, apprendendo dagli analisti e fornendo riassunti e decisioni intelligenti, diventando effettivamente un assistente instancabile nel Centro Operativo di Sicurezza.

Per i prossimi passi e miglioramenti:

  • Puoi provare questo approccio su dati di log reali. Ad esempio, prendi un file di log di sistema ed estrai una caratteristica come “numero di log di errore all’ora” o “byte trasferiti per sessione” e esegui il rilevamento delle anomalie su di esso.

  • Sperimenta con altri algoritmi come One-Class SVM o Local Outlier Factor per il rilevamento delle anomalie per vedere come si confrontano.

  • Incorpora un semplice modello linguistico per analizzare le righe di log o per spiegare le anomalie. Ad esempio, un LLM potrebbe leggere una voce di log anomala e suggerire cosa potrebbe essere sbagliato (“Questo errore di solito significa che il database è irraggiungibile”).

  • Estendere le funzionalità: in un vero SIEM, si utilizzerebbero molteplici segnali contemporaneamente (conteggi di accessi falliti, geolocalizzazione IP insolita, nomi di processi rari nei log, e così via). Più funzionalità e dati possono migliorare il contesto per la rilevazione.