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

Articolo
02/10/2024

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

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.
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.
Testare la regola con ogni caso d'uso pertinente. Se non fornisce risultati previsti, esaminare e modificare KQL e testarlo di nuovo.
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:

Creare regole di analisi personalizzate per rilevare le minacce. Usare il raggruppamento di avvisi per ridurre l'affaticamento degli avvisi raggruppando gli avvisi che si verificano entro un determinato intervallo di tempo.
Eseguire il mapping dei campi dati alle entità in Microsoft Sentinel per consentire ai tecnici SOC di definire le entità come parte dell'evidenza da tenere traccia durante un'indagine. Il mapping delle entità consente anche agli analisti SOC di sfruttare un [grafico di indagine] intuitivo (investigate-cases.md#use-the-investigation-graph-to-deep-dive) che può aiutare a ridurre il tempo e il lavoro.
Esaminare gli eventi imprevisti con i dati UEBA (analisi del comportamento degli utenti e delle entità), come esempio di come usare l'evidenza per visualizzare eventi, avvisi ed eventuali segnalibri associati a un evento imprevisto specifico nel riquadro di anteprima dell'evento imprevisto.
KQL (Linguaggio di query Kusto), che è possibile usare per inviare richieste di sola lettura al database di Log Analytics per elaborare i dati e restituire i risultati. KQL viene usato anche in altri servizi Microsoft, ad esempio Microsoft Defender per endpoint e Application Insights.

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 comuni`eval`.	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 `TRUE`se`X` è 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 `X`convertito 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 campo`X`.	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 di`X`.	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

Condividi tramite

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

Regole di controllo

Eseguire la migrazione delle regole

Passaggi di migrazione delle regole

Confrontare la terminologia delle regole

Eseguire il mapping e confrontare gli esempi di regole

Comandi di ricerca comuni

`lookup` comando: esempio di KQL

`stats` comando: esempio di KQL

`mstats` comando: esempio di KQL

`transaction` comando: esempio di SPL

`transaction` comando: esempio di KQL

`eventstats` comando: esempio di SPL

`eventstats` comando: esempio di KQL

`anomalydetection` comando: esempio di SPL

`anomalydetection` comando: esempio di KQL

Comandi comuni `eval`

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

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

`if(X,Y,Z)` Esempio di KQL

`isint(X)` Esempio di KQL

`isstr(X)` Esempio di KQL

`like(X,"y")` esempio

`min(X,…)` Esempio di KQL

`mvfilter(X)` Esempio di KQL

`mvjoin(X,Y)` Esempio di KQL

`relative time(X,Y)` Esempio di KQL

`replace(X,Y,Z)` Esempio di KQL

`strptime(X,Y)` Esempio di KQL

`time()` Esempio di KQL

`tostring(X,Y)`

`tostring(X,Y)` Esempio di SPL

`urldecode(X)` Esempio di SPL

Esempio di KQL dei comandi comuni `stats`

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

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

Regole di controllo

Eseguire la migrazione delle regole

Passaggi di migrazione delle regole

Confrontare la terminologia delle regole

Eseguire il mapping e confrontare gli esempi di regole

Comandi di ricerca comuni

lookup comando: esempio di KQL

stats comando: esempio di KQL

mstats comando: esempio di KQL

transaction comando: esempio di SPL

transaction comando: esempio di KQL

eventstats comando: esempio di SPL

eventstats comando: esempio di KQL

anomalydetection comando: esempio di SPL

anomalydetection comando: esempio di KQL

Comandi comuni eval

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

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

if(X,Y,Z) Esempio di KQL

isint(X) Esempio di KQL

isstr(X) Esempio di KQL

like(X,"y") esempio

min(X,…) Esempio di KQL

mvfilter(X) Esempio di KQL

mvjoin(X,Y) Esempio di KQL

relative time(X,Y) Esempio di KQL

replace(X,Y,Z) Esempio di KQL

strptime(X,Y) Esempio di KQL

time() Esempio di KQL

tostring(X,Y)

tostring(X,Y) Esempio di SPL

urldecode(X) Esempio di SPL

Esempio di KQL dei comandi comuni stats

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

`lookup` comando: esempio di KQL

`stats` comando: esempio di KQL

`mstats` comando: esempio di KQL

`transaction` comando: esempio di SPL

`transaction` comando: esempio di KQL

`eventstats` comando: esempio di SPL

`eventstats` comando: esempio di KQL

`anomalydetection` comando: esempio di SPL

`anomalydetection` comando: esempio di KQL

Comandi comuni `eval`

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

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

`if(X,Y,Z)` Esempio di KQL

`isint(X)` Esempio di KQL

`isstr(X)` Esempio di KQL

`like(X,"y")` esempio

`min(X,…)` Esempio di KQL

`mvfilter(X)` Esempio di KQL

`mvjoin(X,Y)` Esempio di KQL

`relative time(X,Y)` Esempio di KQL

`replace(X,Y,Z)` Esempio di KQL

`strptime(X,Y)` Esempio di KQL

`time()` Esempio di KQL

`tostring(X,Y)`

`tostring(X,Y)` Esempio di SPL

`urldecode(X)` Esempio di SPL

Esempio di KQL dei comandi comuni `stats`