Leggere in inglese

Condividi tramite

Eseguire la migrazione delle regole di rilevamento di Splunk a Microsoft Sentinel

  • Articolo

Le regole di rilevamento splunk sono componenti siem (Security Information and Event Management) che confrontano le regole di analisi in Microsoft Sentinel. Questo articolo descrive i concetti da identificare, confrontare ed eseguire la migrazione a Microsoft Sentinel. Il modo migliore consiste nell'iniziare con l'esperienza di migrazione SIEM, che identifica le regole di analisi predefinite (OOTB) in cui tradurre automaticamente.

Per eseguire la migrazione della distribuzione di Splunk Observability, sono disponibili altre informazioni su come eseguire la migrazione da Splunk ad Azure Monitor Logs.

Regole di controllo

Microsoft Sentinel usa l'analisi di Machine Learning per creare eventi imprevisti interattivi e ad alta fedeltà. Alcuni rilevamenti splunk esistenti possono essere ridondanti in Microsoft Sentinel, quindi non eseguirne la migrazione cieco. Esaminare queste considerazioni durante l'identificazione delle regole di rilevamento esistenti.

  • Assicurarsi di selezionare i casi d'uso che giustificano la migrazione delle regole, considerando la priorità aziendale e l'efficienza.
  • Verificare di aver compreso i tipi di regole di Microsoft Sentinel.
  • Verificare di aver compreso la terminologia delle regole.
  • Esaminare le regole obsolete che non hanno avvisi per gli ultimi 6-12 mesi e determinare se sono ancora pertinenti.
  • Eliminare le minacce o gli avvisi di basso livello che normalmente si ignorano.
  • Confermare le origini dei dati collegate ed esaminare i metodi di connessione dati. Microsoft Sentinel Analytics richiede che il tipo di dati sia presente nell'area di lavoro Log Analytics prima che venga abilitata una regola. Rivedere le conversazioni di raccolta dati per garantire la profondità e l'ampiezza dei dati nei casi d'uso che si prevede di rilevare. Usare quindi l'esperienza di migrazione SIEM per assicurarsi che le origini dati vengano mappate in modo appropriato.

Eseguire la migrazione delle regole

Dopo aver identificato i rilevamenti di Splunk da migrare, esaminare queste considerazioni per il processo di migrazione:

  • Confrontare le funzionalità esistenti delle regole di analisi OOTB di Microsoft Sentinel con i casi d'uso correnti. Usare l'esperienza di migrazione SIEM per vedere quali rilevamenti Splunk vengono convertiti automaticamente in modelli OOTB.
  • Converte i rilevamenti che non sono allineati alle regole di analisi OOTB. Il modo migliore per convertire automaticamente i rilevamenti di Splunk è l'esperienza di migrazione SIEM.
  • Scoprire altri algoritmi per i casi d'uso esplorando le risorse della community, ad esempio soC Prime Threat Detection Marketplace.
  • Converte manualmente i rilevamenti se le regole predefinite non sono disponibili o non vengono convertite automaticamente. Creare le nuove query KQL ed esaminare il mapping delle regole.

Per altre informazioni, vedere Procedure consigliate per la migrazione delle regole di rilevamento.

Passaggi di migrazione delle regole

  1. Verificare di disporre di un sistema di test per ogni regola di cui si vuole eseguire la migrazione.

    1. Preparare un processo di convalida per le regole di cui è stata eseguita la migrazione, inclusi scenari di test completi e script.

    2. Assicurarsi che il team disponga di risorse utili per testare le regole di cui è stata eseguita la migrazione.

    3. Verificare di avere connesso le origini dati necessarie ed esaminare i metodi di connessione dati.

  2. Verificare se i rilevamenti sono disponibili come modelli OOTB in Microsoft Sentinel:

    • Usare l'esperienza di migrazione SIEM per automatizzare la traduzione e l'installazione dei modelli OOTB.

      Per altre informazioni, vedere Usare l'esperienza di migrazione SIEM.

    • Se nei rilevamenti non sono presenti casi d'uso, creare regole per la propria area di lavoro con modelli di regole OOTB.

      In Microsoft Sentinel passare all'hub contenuto.

      Filtrare il tipo di contenuto per i modelli di regola di Analisi.

      Trovare e installare/aggiornare ogni soluzione hub contenuto corrispondente o modello di regola di analisi autonoma.

      Per altre informazioni, vedere Rilevare le minacce predefinite.

    • Se sono presenti rilevamenti non coperti dalle regole OOTB di Microsoft Sentinel, provare prima di tutto l'esperienza di migrazione SIEM per la traduzione automatica.

    • Se né le regole OOTB né la migrazione SIEM traducono completamente il rilevamento, creare la regola manualmente. In questi casi, usare la procedura seguente per creare la regola:

      1. Identificare le origini dati da usare nella regola. Identificare le tabelle di Microsoft Sentinel su cui eseguire una query creando una tabella di mapping tra origini dati e tabelle dati.

      2. Identificare gli attributi, i campi o le entità nei dati da usare nelle regole.

      3. Identificare i criteri e la logica delle regole. In questa fase è consigliabile trovare modelli di regola come esempi per creare le query KQL.

        Prendere in considerazione filtri, regole di correlazione, elenchi attivi, set di riferimenti, watchlist, anomalie di rilevamento, aggregazioni e così via. È possibile usare i riferimenti forniti dal sistema SIEM legacy per comprendere come eseguire il mapping ottimale della sintassi della query.

      4. Identificare la condizione del trigger e l'azione della regola, quindi costruire ed esaminare la query KQL. Quando si esamina la query, prendere in considerazione le risorse di ottimizzazione KQL.

  3. Testare la regola con ogni caso d'uso pertinente. Se non fornisce risultati previsti, esaminare e modificare KQL e testarlo di nuovo.

  4. Quando si è soddisfatti, prendere in considerazione la regola di cui è stata eseguita la migrazione. Creare un playbook per l'azione della regola in base alle esigenze. Per altre informazioni, vedere Automatizzare la risposta alle minacce con i playbook in Microsoft Sentinel

Altre informazioni sulle regole di analisi:

Confrontare la terminologia delle regole

Questa tabella consente di chiarire il concetto di regola basata su Linguaggio di query Kusto (KQL) in Microsoft Sentinel rispetto a un rilevamento Splunk basato su SPL (Search Processing Language).

Splunk Microsoft Sentinel
Tipo di regola • Pianificato
• In tempo reale		 • Query pianificata
• Fusione
• Microsoft Security
• Analisi del comportamento di Machine Learning (ML)
Criteri Definire in SPL Definire in KQL
Condizione trigger • Numero di risultati
• Numero di host
• Numero di origini
• Custom		 Soglia: numero di risultati della query
Azione • Aggiungere agli avvisi attivati
• Evento del log
• Risultati di output da cercare
• E altro ancora		 • Creare un avviso o un evento imprevisto
• Si integra con App per la logica

Eseguire il mapping e confrontare gli esempi di regole

Usare questi esempi per confrontare ed eseguire il mapping delle regole da Splunk a Microsoft Sentinel in vari scenari.

Comandi di ricerca comuni

Comando di SPL Descrizione Operatore KQL Esempio di KQL
chart/ timechart Restituisce i risultati in un output tabulare per la creazione del grafico delle serie temporali. render … | render timechart
dedup Rimuove i risultati successivi che corrispondono a un criterio specificato. • distinct
• summarize		 … | summarize by Computer, EventID
eval Calcola un’espressione. Informazioni sui comandi comunieval. extend T | extend duration = endTime - startTime
fields Rimuove campi dai risultati della ricerca. • project
• project-away		 T | project cost=price*quantity, price
head/tail Restituisce il primo o l'ultimo set di risultati N. top T | top 5 by Name desc nulls last
lookup Aggiunge i valori dei campi da un'origine esterna. • externaldata
• lookup		 Esempio di KQL
rename Rinomina un campo. Usare i caratteri jolly per specificare più campi. project-rename T | project-rename new_column_name = column_name
rex Specifica i nomi dei gruppi usando espressioni regolari per estrarre i campi. matches regex … | where field matches regex "^addr.*"
search Filtra i risultati che corrispondono all'espressione di ricerca. search search "X"
sort Ordina i risultati della ricerca in base ai campi specificati. ordinamento T | sort by strlen(country) asc, price desc
stats Fornisce statistiche, facoltativamente raggruppate per campi. Altre informazioni sui comandi stats comuni. summarize Esempio di KQL
mstats Analogamente ai comandi stats, usati per le metriche anziché per gli eventi. summarize Esempio di KQL
table Specifica i campi da mantenere nel set di risultati e conserva i dati in formato tabulare. project T | project columnA, columnB
top/rare Visualizza i valori più o meno comuni di un campo. top T | top 5 by Name desc nulls last
transaction Raggruppa i risultati della ricerca nelle transazioni.

Esempio di SPL		 Esempio: row_window_session Esempio di KQL
eventstats Genera statistiche di riepilogo dai campi negli eventi e salva tali statistiche in un nuovo campo.

Esempio di SPL		 Esempi:
• join
• make_list
• mv-expand		 Esempio di KQL
streamstats Trova la somma cumulativa di un campo.

Esempio di SPL:
... | streamstats sum(bytes) as bytes _ total \| timechart		 row_cumsum ...\| serialize cs=row_cumsum(bytes)
anomalydetection Trova le anomalie nel campo specificato.

Esempio di SPL		 series_decompose_anomalies() Esempio di KQL
where Filtra i risultati della ricerca usando espressioni eval. Usato per confrontare due campi diversi. where T | where fruit=="apple"

lookup comando: esempio di KQL

Users 
| where UserID in ((externaldata (UserID:string) [
@"https://storageaccount.blob.core.windows.net/storagecontainer/users.txt" 
h@"?...SAS..." // Secret token to access the blob 
])) | ...

stats comando: esempio di KQL

Sales 
| summarize NumTransactions=count(), 
Total=sum(UnitPrice * NumUnits) by Fruit, 
StartOfMonth=startofmonth(SellDateTime)

mstats comando: esempio di KQL

T | summarize count() by price_range=bin(price, 10.0)

transaction comando: esempio di SPL

sourcetype=MyLogTable type=Event
| transaction ActivityId startswith="Start" endswith="Stop"
| Rename timestamp as StartTime
| Table City, ActivityId, StartTime, Duration

transaction comando: esempio di KQL

let Events = MyLogTable | where type=="Event";
Events
| where Name == "Start"
| project Name, City, ActivityId, StartTime=timestamp
| join (Events
| where Name == "Stop"
| project StopTime=timestamp, ActivityId)
on ActivityId
| project City, ActivityId, StartTime, 
Duration = StopTime – StartTime

Utilizzare row_window_session() per calcolare i valori di inizio della sessione per una colonna in un set di righe serializzato.

...| extend SessionStarted = row_window_session(
Timestamp, 1h, 5m, ID != prev(ID))

eventstats comando: esempio di SPL

… | bin span=1m _time
|stats count AS count_i by _time, category
| eventstats sum(count_i) as count_total by _time

eventstats comando: esempio di KQL

Ecco un esempio con l’istruzione join:

let binSize = 1h;
let detail = SecurityEvent 
| summarize detail_count = count() by EventID,
tbin = bin(TimeGenerated, binSize);
let summary = SecurityEvent
| summarize sum_count = count() by 
tbin = bin(TimeGenerated, binSize);
detail 
| join kind=leftouter (summary) on tbin 
| project-away tbin1

Ecco un esempio con l’istruzione make_list:

let binSize = 1m;
SecurityEvent
| where TimeGenerated >= ago(24h)
| summarize TotalEvents = count() by EventID, 
groupBin =bin(TimeGenerated, binSize)
|summarize make_list(EventID), make_list(TotalEvents), 
sum(TotalEvents) by groupBin
| mvexpand list_EventID, list_TotalEvents

anomalydetection comando: esempio di SPL

sourcetype=nasdaq earliest=-10y
| anomalydetection Close _ Price

anomalydetection comando: esempio di KQL

let LookBackPeriod= 7d;
let disableAccountLogon=SignIn
| where ResultType == "50057"
| where ResultDescription has "account is disabled";
disableAccountLogon
| make-series Trend=count() default=0 on TimeGenerated 
in range(startofday(ago(LookBackPeriod)), now(), 1d)
| extend (RSquare,Slope,Variance,RVariance,Interception,
LineFit)=series_fit_line(Trend)
| extend (anomalies,score) = 
series_decompose_anomalies(Trend)

Comandi comuni eval

Comando di SPL Descrizione Esempio di SPL Comando di KQL Esempio di KQL
abs(X) Restituisce il valore assoluto di X. abs(number) abs() abs(X)
case(X,"Y",…) Accetta coppie di argomenti X e Y, in cui gli argomenti X sono espressioni booleane. Quando dà come risultato TRUE, gli argomenti restituiscono l'argomento Y corrispondente. Esempio di SPL case Esempio di KQL
ceil(X) Arrotondamento per eccesso di un numero X. ceil(1.9) ceiling() ceiling(1.9)
cidrmatch("X",Y) Identifica gli indirizzi IP che appartengono a una determinata subnet. cidrmatch
("123.132.32.0/25",ip)		 • ipv4_is_match()
• ipv6_is_match()		 ipv4_is_match('192.168.1.1', '192.168.1.255')
== false
coalesce(X,…) Restituisce il primo valore che non è null. coalesce(null(), "Returned val", null()) coalesce() coalesce(tolong("not a number"),
tolong("42"), 33) == 42
cos(X) Calcola il coseno di X. n=cos(0) cos() cos(X)
exact(X) Dà come risultato un'espressione X usando l'aritmetica a virgola mobile a precisione doppia. exact(3.14*num) todecimal() todecimal(3.14*2)
exp(X) Restituisce eX. exp(3) exp() exp(3)
if(X,Y,Z) Se X dà come risultato TRUE, il risultato è il secondo argomento Y. Se X dà come risultato FALSE, il risultato restituisce il terzo argomento Z. if(error==200,
"OK", "Error")		 iif() Esempio di KQL
isbool(X) Restituisce TRUE se X è booleano. isbool(field) • iif()
• gettype		 iif(gettype(X) =="bool","TRUE","FALSE")
isint(X) Restituisce TRUEseX è integer. isint(field) • iif()
• gettype		 Esempio di KQL
isnull(X) Restituisce TRUE se X è null. isnull(field) isnull() isnull(field)
isstr(X) Restituisce TRUE if X è una stringa. isstr(field) • iif()
• gettype		 Esempio di KQL
len(X) Questa funzione restituisce la lunghezza del carattere di una stringa X. len(field) strlen() strlen(field)
like(X,"y") Restituisce TRUE se e solo se X è simile al criterio SQLite in Y. like(field, "addr%") • has
• contains
• startswith
• matches regex		 Esempio di KQL
log(X,Y) Restituisce il log del primo argomento X usando il secondo argomento Y come base. Il valore predefinito di Y è 10. log(number,2) • log
• log2
• log10		 log(X)

log2(X)

log10(X)
lower(X) Restituisce il valore minuscolo di X. lower(username) tolower tolower(username)
ltrim(X,Y) Restituisce X con i caratteri nel parametro Y tagliato dal lato sinistro. L'output predefinito di Y sono spazi e schede. ltrim(" ZZZabcZZ ", " Z") trim_start() trim_start(“ ZZZabcZZ”,” ZZZ”)
match(X,Y) Restituisce se X corrisponde al criteri regex Y. match(field, "^\d{1,3}.\d$") matches regex … | where field matches regex @"^\d{1,3}.\d$")
max(X,…) Restituisce il valore massimo in una colonna. max(delay, mydelay) • max()
• arg_max()		 … | summarize max(field)
md5(X) Restituisce l'hash MD5 di un valore stringa X. md5(field) hash_md5 hash_md5("X")
min(X,…) Restituisce il valore minimo in una colonna. min(delay, mydelay) • min_of()
• min()
• arg_min		 Esempio di KQL
mvcount(X) Restituisce il numero (totale) dei valori X. mvcount(multifield) dcount …| summarize dcount(X) by Y
mvfilter(X) Filtra un campo multivalore in base all'espressione booleana X. mvfilter(match(email, "net$")) mv-apply Esempio di KQL
mvindex(X,Y,Z) Restituisce un sottoinsieme dell'argomento multivalore X da una posizione iniziale (in base zero) Y a Z (facoltativo). mvindex( multifield, 2) array_slice array_slice(arr, 1, 2)
mvjoin(X,Y) Dato un campo multivalore X e un delimitatore di stringa Y, unisce i singoli valori di X usando Y. mvjoin(address, ";") strcat_array Esempio di KQL
now() Restituisce l'ora corrente, rappresentata in tempo UNIX. now() now() now()

now(-2d)
null() Non accetta argomenti e restituisce NULL. null() Null null
nullif(X,Y) Include due argomenti, X e Y, e restituisce X se gli argomenti sono diversi. In caso contrario, restituisce NULL. nullif(fieldA, fieldB) iif iif(fieldA==fieldB, null, fieldA)
random() Returns a pseudo-random number between 0 to 2147483647. random() rand() rand()
relative_ time(X,Y) Dato un periodo di tempo X e un identificatore di tempo relativo Y, restituisce il valore del periodo di tempo di Y applicato a X. relative_time(now(),"-1d@d") unix time Esempio di KQL
replace(X,Y,Z) Restituisce una stringa formata sostituendo la stringa Z a ogni occorrenza dell’espressione regolare Y nella stringa X. Restituisce la data con i numeri del mese e del giorno invertiti.
Ad esempio, per l'input 4/30/2015, l'output è 30/4/2009:

replace(date, "^(\d{1,2})/ (\d{1,2})/", "\2/\1/")		 replace() Esempio di KQL
round(X,Y) Restituisce X arrotondato al numero di posizioni decimali specificate da Y. L'impostazione predefinita consiste nell'arrotondare un numero intero. round(3.5) round round(3.5)
rtrim(X,Y) Restituisce X con i caratteri di Y tagliato dal lato destro. Se Y non viene specificato, gli spazi e le schede vengono tagliati. rtrim(" ZZZZabcZZ ", " Z") trim_end() trim_end(@"[ Z]+",A)
searchmatch(X) Restituisce TRUE se l'evento corrisponde alla stringa di ricerca X. searchmatch("foo AND bar") iif() iif(field has "X","Yes","No")
split(X,"Y") Restituisce X come campo multivalore, suddiviso dal delimitatore Y. split(address, ";") split() split(address, ";")
sqrt(X) Restituisce la radice quadrata di X. sqrt(9) sqrt() sqrt(9)
strftime(X,Y) Restituisce il valore del periodo di tempo Xconvertito usando il formato specificato da Y. strftime(_time, "%H:%M") format_datetime() format_datetime(time,'HH:mm')
strptime(X,Y) Data un'ora rappresentata da una stringa X, restituisce il valore analizzato dal formato Y. strptime(timeStr, "%H:%M") format_datetime() Esempio di KQL
substr(X,Y,Z) Restituisce un campo di sottostringhe X dalla posizione iniziale (in base uno) Y per Z (facoltativo) caratteri. substr("string", 1, 3) substring() substring("string", 0, 3)
time() Restituisce il tempo con risoluzione al microsecondo. time() format_datetime() Esempio di KQL
tonumber(X,Y) Converte la stringa di input X in un numero, dove Y (facoltativo, il valore predefinito è 10) definisce la base del numero da convertire. tonumber("0A4",16) toint() toint("123")
tostring(X,Y) Descrizione Esempio di SPL tostring() tostring(123)
typeof(X) Restituisce una rappresentazione in stringa del tipo di campo. typeof(12) gettype() gettype(12)
urldecode(X) Restituisce l'URL X decodificato. Esempio di SPL url_decode Esempio di KQL

case(X,"Y",…) Esempio di SPL

case(error == 404, "Not found",
error == 500,"Internal Server Error",
error == 200, "OK")

case(X,"Y",…) Esempio di KQL

T
| extend Message = case(error == 404, "Not found", 
error == 500,"Internal Server Error", "OK")

if(X,Y,Z) Esempio di KQL

iif(floor(Timestamp, 1d)==floor(now(), 1d), 
"today", "anotherday")

isint(X) Esempio di KQL

iif(gettype(X) =="long","TRUE","FALSE")

isstr(X) Esempio di KQL

iif(gettype(X) =="string","TRUE","FALSE")

like(X,"y") esempio

… | where field has "addr"

… | where field contains "addr"

… | where field startswith "addr"

… | where field matches regex "^addr.*"

min(X,…) Esempio di KQL

min_of (expr_1, expr_2 ...)

…|summarize min(expr)

…| summarize arg_min(Price,*) by Product

mvfilter(X) Esempio di KQL

T | mv-apply Metric to typeof(real) on 
(
 top 2 by Metric desc
)

mvjoin(X,Y) Esempio di KQL

strcat_array(dynamic([1, 2, 3]), "->")

relative time(X,Y) Esempio di KQL

let toUnixTime = (dt:datetime)
{
(dt - datetime(1970-01-01))/1s 
};

replace(X,Y,Z) Esempio di KQL

replace( @'^(\d{1,2})/(\d{1,2})/', @'\2/\1/',date)

strptime(X,Y) Esempio di KQL

format_datetime(datetime('2017-08-16 11:25:10'),
'HH:mm')

time() Esempio di KQL

format_datetime(datetime(2015-12-14 02:03:04),
'h:m:s')

tostring(X,Y)

Restituisce un valore di campo di X come stringa.

  • Se il valore di X è un numero, X viene riformattato in un valore stringa.
  • Se X è un valore booleano, X viene riformattato in TRUE o FALSE.
  • Se X è un numero, il secondo argomento Y è facoltativo e può essere sia hex (converte X in un formato esadecimale), sia commas (formatta X con virgole e due posizioni decimali) o duration (converte X da un formato temporale in secondi a un formato di tempo leggibile: HH:MM:SS).
tostring(X,Y) Esempio di SPL

L’esempio restituisce:

foo=615 and foo2=00:10:15:

… | eval foo=615 | eval foo2 = tostring(
foo, "duration")

urldecode(X) Esempio di SPL

urldecode("http%3A%2F%2Fwww.splunk.com%2Fdownload%3Fr%3Dheader")

Esempio di KQL dei comandi comuni stats

Comando di SPL Descrizione Comando di KQL Esempio di KQL
avg(X) Restituisce la media dei valori del campoX. avg() avg(X)
count(X) Restituisce il numero delle occorrenze del campo X. Per indicare un valore del campo specifico da far corrispondere, formattare X come eval(field="value"). count() summarize count()
dc(X) Restituisce il conteggio di valori distinti del campo X. dcount() …\| summarize countries=dcount(country) by continent
earliest(X) Restituisce il primo valore visualizzato cronologicamente diX. arg_min() … \| summarize arg_min(TimeGenerated, *) by X
latest(X) Restituisce l’ultimo valore visualizzato cronologicamente di X. arg_max() … \| summarize arg_max(TimeGenerated, *) by X
max(X) Restituisce il valore massimo del campo X. Se i valori di X non sono numerici, il valore massimo viene trovato in ordine alfabetico. max() …\| summarize max(X)
median(X) Restituisce il valore intermedio del campo X. percentile() …\| summarize percentile(X, 50)
min(X) Restituisce il valore minimo del campo X. Se i valori di X non sono numerici, il valore minimo viene trovato in ordine alfabetico. min() …\| summarize min(X)
mode(X) Restituisce il valore più frequente dell'elenco X. top-hitters() …\| top-hitters 1 of Y by X
perc(Y) Restituisce il valore del percentile X del campo Y. Ad esempio, perc5(total) restituisce il valore del quinto percentile di un campo total. percentile() …\| summarize percentile(Y, 5)
range(X) Restituisce la differenza tra i valori massimi e minimi del campo X. range() range(1, 3)
stdev(X) Restituisce la deviazione standard campionaria del campo X. stdev stdev()
stdevp(X) Ottiene la deviazione standard della popolazione del campo X. stdevp() stdevp()
sum(X) Restituisce la somma dei valori del campo X. sum() sum(X)
sumsq(X) Restituisce la somma dei valori al quadrato del campo X.
values(X) Restituisce l'elenco di tutti i valori distinti del campo X come voce multivalore. L'ordine dei valori è alfabetico. make_set() …\| summarize r = make_set(X)
var(X) Restituisce la varianza campione del campo X. variance variance(X)

Passaggi successivi

In questo articolo è stato illustrato come eseguire il mapping delle regole di migrazione da Splunk a Microsoft Sentinel.

Eseguire la migrazione dell'automazione SOAR