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

Le regole di rilevamento splunk sono componenti siem (Security Information And Event Management) che si confrontano con le regole di analisi in Microsoft Sentinel. Questo articolo descrive i concetti per identificarli, confrontarli ed eseguirne 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 eseguire automaticamente la conversione.

Per eseguire la migrazione della distribuzione di Splunk Observability, vedere altre informazioni su come eseguire la migrazione da Splunk a Azure Monitor Logs.

Regole di controllo

Microsoft Sentinel usa l'analisi di Machine Learning per creare eventi imprevisti ad alta fedeltà e interattivi. Alcuni dei rilevamenti di Splunk esistenti potrebbero essere ridondanti in Microsoft Sentinel, quindi non eseguirne la migrazione ciecamente. 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 comprendere Microsoft Sentinel tipi di regole.
Verificare di comprendere la terminologia delle regole.
Esaminare le regole obsolete che non dispongono di avvisi negli ultimi 6-12 mesi e determinare se sono ancora pertinenti.
Eliminare le minacce o gli avvisi di basso livello che si ignorano regolarmente.
Confermare le origini dati connesse 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 dell'abilitazione di una regola. Rivedere le conversazioni di raccolta dati per garantire profondità e ampiezza dei dati nei casi d'uso che si prevede di rilevare. Usare quindi l'esperienza di migrazione SIEM per assicurarsi che il mapping delle origini dati venga eseguito in modo appropriato.

Eseguire la migrazione delle regole

Dopo aver identificato i rilevamenti splunk di cui eseguire la migrazione, 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.
Tradurre i rilevamenti che non sono allineati alle regole di analisi OOTB. Il modo migliore per tradurre automaticamente i rilevamenti di Splunk consiste nell'esperienza di migrazione SIEM.
Scoprire altri algoritmi per i casi d'uso esplorando le risorse della community, ad esempio soc Prime Threat Detection Marketplace.
Tradurre manualmente i rilevamenti se le regole predefinite non sono disponibili o non vengono tradotte 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.

Procedura 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 le origini dati necessarie connesse 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 i casi d'uso non sono riportati nei rilevamenti, 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 Analytics .
  
  Trovare e installare/aggiornare ogni soluzione dell'hub contenuto corrispondente o un 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, seguire questa procedura per creare la regola:
  1. Identificare le origini dati da usare nella regola. Identificare le Microsoft Sentinel tabelle su cui si vuole eseguire una query creando una tabella di mapping tra origini dati e tabelle dati.
  2. Identificare eventuali attributi, campi o entità nei dati che si desidera usare nelle regole.
  3. Identificare i criteri e la logica delle regole. In questa fase, prendere in considerazione la ricerca di modelli di regola come esempi per la creazione di query KQL.
    
    Si considerino filtri, regole di correlazione, elenchi attivi, set di riferimento, watchlist, anomalie di rilevamento, aggregazioni e così via. È possibile usare i riferimenti forniti da SIEM legacy per comprendere come eseguire il mapping migliore della sintassi di query.
  4. Identificare la condizione del trigger e l'azione della regola, quindi creare ed esaminare la query KQL. Quando si esamina la query, prendere in considerazione le risorse guida per l'ottimizzazione KQL.
Testare la regola con ognuno dei casi d'uso pertinenti. Se non fornisce i risultati previsti, esaminare e modificare il KQL e testarlo di nuovo.
Quando si è soddisfatti, considerare 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 degli 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 inoltre agli analisti soc di sfruttare un intuitivo [grafico di indagine] (investigate-cases.md#use-the-investigation-graph-to-deep-dive) che consente di ridurre il tempo e l'impegno.
Analizzare gli eventi imprevisti con dati UEBA, come esempio di come usare le prove per visualizzare eventi, avvisi ed eventuali segnalibri associati a un evento imprevisto specifico nel riquadro di anteprima degli eventi imprevisti.
Linguaggio di query Kusto (KQL) 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	•Programmato • In tempo reale	• Query pianificata •Fusione • Sicurezza Microsoft • Analisi del comportamento di Machine Learning (ML)
Criteria	Definire in SPL	Definire in KQL
Condizione del trigger	• Numero di risultati • Numero di host • Numero di fonti •Personalizzato	Soglia: numero di risultati della query
Azione	• Aggiungere agli avvisi attivati • Evento di log • Risultati dell'output da cercare • E altro ancora	• Creare avvisi o eventi imprevisti • Si integra con App per la logica

Eseguire il mapping e il confronto di esempi di regole

Usare questi esempi per confrontare e mappare le regole da Splunk a Microsoft Sentinel in vari scenari.

Comandi di ricerca comuni

Comando SPL	Descrizione	Operatore KQL	Esempio KQL
`chart/ timechart`	Restituisce risultati in un output tabulare per la creazione di grafici di serie temporali.	Operatore render	`… \| render timechart`
`dedup`	Rimuove i risultati successivi che corrispondono a un criterio specificato.	• distinto • riepilogo	`… \| summarize by Computer, EventID`
`eval`	Calcola un'espressione. Informazioni sui comandi comuni`eval`.	Estendere	`T \| extend duration = endTime - startTime`
`fields`	Rimuove i campi dai risultati della ricerca.	• progetto • project-away	`T \| project cost=price*quantity, price`
`head/tail`	Restituisce il primo o l'ultimo N risultato.	In alto	`T \| top 5 by Name desc nulls last`
`lookup`	Aggiunge valori di campo da un'origine esterna.	• dati esterni • ricerca	Esempio 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 utilizzando espressioni regolari per estrarre i campi.	corrisponde a regex	`… \| where field matches regex "^addr.*"`
`search`	Filtra i risultati in base ai risultati che corrispondono all'espressione di ricerca.	Ricerca	`search "X"`
`sort`	Ordina i risultati della ricerca in base ai campi specificati.	Sorta	`T \| sort by strlen(country) asc, price desc`
`stats`	Fornisce statistiche, facoltativamente raggruppate per campi. Altre informazioni sui comandi di statistiche comuni.	Riassumere	Esempio KQL
`mstats`	Simile alle statistiche, usate sulle metriche anziché sugli eventi.	Riassumere	Esempio KQL
`table`	Specifica i campi da mantenere nel set di risultati e conserva i dati in formato tabulare.	Progetto	`T \| project columnA, columnB`
`top/rare`	Visualizza i valori più o meno comuni di un campo.	In alto	`T \| top 5 by Name desc nulls last`
`transaction`	Raggruppa i risultati della ricerca in transazioni. Esempio di SPL	Esempio: row_window_session	Esempio KQL
`eventstats`	Genera statistiche di riepilogo dai campi degli eventi e le salva in un nuovo campo. Esempio di SPL	Esempi: • partecipare • make_list • mv-expand	Esempio KQL
`streamstats`	Trovare la somma cumulativa di un campo. Esempio di SPL: `... \| streamstats sum(bytes) as bytes _ total \\| timechart`	row_cumsum	`...\\| serialize cs=row_cumsum(bytes)`
`anomalydetection`	Trovare anomalie nel campo specificato. Esempio di SPL	series_decompose_anomalies()	Esempio KQL
`where`	Filtra i risultati della ricerca usando `eval` espressioni. Usato per confrontare due campi diversi.	Dove	`T \| where fruit=="apple"`

`lookup` comando: esempio 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 KQL

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

`mstats` comando: esempio KQL

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

`transaction` comando: esempio SPL

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

`transaction` comando: esempio 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

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

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

`eventstats` comando: esempio 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 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 SPL

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

`anomalydetection` comando: esempio 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 SPL	Descrizione	Esempio di SPL	Comando KQL	Esempio KQL
`abs(X)`	Restituisce il valore assoluto di X.	`abs(number)`	`abs()`	`abs(X)`
`case(X,"Y",…)`	Accetta coppie di `X` argomenti e `Y` , dove gli `X` argomenti sono espressioni booleane. Se valutati in `TRUE`, gli argomenti restituiscono l'argomento corrispondente `Y` .	Esempio di SPL	`case`	Esempio KQL
`ceil(X)`	Soffitto di un numero X.	`ceil(1.9)`	`ceiling()`	`ceiling(1.9)`
`cidrmatch("X",Y)`	Identifica gli indirizzi IP che appartengono a una subnet specifica.	`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)`	Valuta 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` restituisce `TRUE`, il risultato è il secondo argomento `Y`. Se `X` restituisce `FALSE`, il risultato restituisce il terzo argomento `Z`.	`if(error==200,` `"OK", "Error")`	`iff()`	Esempio KQL
`isbool(X)`	Restituisce `TRUE` se `X` è booleano.	`isbool(field)`	• `iff()` • `gettype`	`iff(gettype(X) =="bool","TRUE","FALSE")`
`isint(X)`	Restituisce `TRUE` se `X` è un numero intero.	`isint(field)`	• `iff()` • `gettype`	Esempio KQL
`isnull(X)`	Restituisce `TRUE` se `X` è Null.	`isnull(field)`	`isnull()`	`isnull(field)`
`isstr(X)`	Restituisce `TRUE` se `X` è una stringa.	`isstr(field)`	• `iff()` • `gettype`	Esempio KQL
`len(X)`	Questa funzione restituisce la lunghezza dei caratteri di una stringa `X`.	`len(field)`	`strlen()`	`strlen(field)`
`like(X,"y")`	Restituisce `TRUE` se e solo se `X` è simile al modello SQLite in `Y`.	`like(field, "addr%")`	• `has` • `contains` • `startswith` • corrisponde a regex	Esempio KQL
`log(X,Y)`	Restituisce il log del primo argomento `X` utilizzando 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` tagliati dal lato sinistro. L'output predefinito di `Y` è spazi e schede.	`ltrim(" ZZZabcZZ ", " Z")`	`trim_start()`	`trim_start(“ ZZZabcZZ”,” ZZZ”)`
`match(X,Y)`	Restituisce se X corrisponde al modello 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 `X`stringa.	`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 KQL
`mvcount(X)`	Restituisce il numero (totale) di `X` valori.	`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 KQL
`mvindex(X,Y,Z)`	Restituisce un subset dell'argomento multivalore `X` da una posizione iniziale (in base zero) `Y` a `Z` (facoltativa).	`mvindex( multifield, 2)`	`array_slice`	`array_slice(arr, 1, 2)`
`mvjoin(X,Y)`	Dato un campo `X` multivalore e un delimitatore `Y`di stringa e unisce i singoli valori di `X` utilizzando `Y`.	`mvjoin(address, ";")`	`strcat_array`	Esempio KQL
`now()`	Restituisce l'ora corrente, rappresentata nell'ora 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)`	`iff`	`iff(fieldA==fieldB, null, fieldA)`
`random()`	Restituisce un numero pseudo-casuale tra `0` a `2147483647`.	`random()`	`rand()`	`rand()`
`relative_ time(X,Y)`	In base a un identificatore di ora `X` dell'epoca e di tempo relativo , restituisce il valore dell'ora dell'epoca `Y` applicato a `X`.`Y`	`relative_time(now(),"-1d@d")`	unix time	Esempio KQL
`replace(X,Y,Z)`	Restituisce una stringa formata sostituendo stringa `Z` per ogni occorrenza della stringa `Y` di espressione regolare nella stringa `X`.	Restituisce la data con i numeri di mese e giorno cambiati. 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 KQL
`round(X,Y)`	Restituisce `X` arrotondato al numero di posizioni decimali specificate da `Y`. L'impostazione predefinita prevede l'arrotondamento a un numero intero.	`round(3.5)`	`round`	`round(3.5)`
`rtrim(X,Y)`	Restituisce `X` con i caratteri di `Y` tagliati 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 `X`di ricerca .	`searchmatch("foo AND bar")`	iff()	`iff(field has "X","Yes","No")`
`split(X,"Y")`	Restituisce `X` come campo multivalore, diviso per 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 `X` di ora dell'epoca di cui viene eseguito il rendering 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 KQL
`substr(X,Y,Z)`	Restituisce un campo `X` sottostringa dalla posizione iniziale (in base una) `Y` per `Z` i caratteri (facoltativi).	`substr("string", 1, 3)`	`substring()`	`substring("string", 0, 3)`
`time()`	Restituisce l'ora dell'orologio a parete con risoluzione di microsecondi.	`time()`	`format_datetime()`	Esempio KQL
`tonumber(X,Y)`	Converte la stringa `X` di input in un numero, dove (facoltativo, il valore predefinito è `10`) definisce la base del numero in cui `Y` eseguire la conversione.	`tonumber("0A4",16)`	`toint()`	`toint("123")`
`tostring(X,Y)`	Descrizione	Esempio di SPL	`tostring()`	`tostring(123)`
`typeof(X)`	Restituisce una rappresentazione di stringa del tipo di campo.	`typeof(12)`	`gettype()`	`gettype(12)`
`urldecode(X)`	Restituisce l'URL `X` decodificato.	Esempio di SPL	`url_decode`	Esempio KQL

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

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

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

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

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

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

`isint(X)` Esempio KQL

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

`isstr(X)` Esempio 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 KQL

min_of (expr_1, expr_2 ...)

…|summarize min(expr)

…| summarize arg_min(Price,*) by Product

`mvfilter(X)` Esempio KQL

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

`mvjoin(X,Y)` Esempio KQL

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

`relative time(X,Y)` Esempio KQL

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

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

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

`strptime(X,Y)` Esempio KQL

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

`time()` Esempio 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 hex (converte X in un formato esadecimale), commas (formati X con virgole e due posizioni decimali) o duration (converte X da un formato temporale in secondi in un formato di ora leggibile: HH:MM:SS).

`tostring(X,Y)` Esempio di SPL

Questo 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 KQL dei comandi comuni `stats`

Comando SPL	Descrizione	Comando KQL	Esempio KQL
`avg(X)`	Restituisce la media dei valori del campo `X`.	avg()	`avg(X)`
`count(X)`	Restituisce il numero di occorrenze del campo `X`. Per indicare un valore di campo specifico da trovare, formattare `X` come `eval(field="value")`.	count()	`summarize count()`
`dc(X)`	Restituisce il conteggio dei valori distinti del campo `X`.	dcount()	`…\\| summarize countries=dcount(country) by continent`
`earliest(X)`	Restituisce il valore visualizzato cronologicamente meno recente di `X`.	arg_min()	`… \\| summarize arg_min(TimeGenerated, *) by X`
`latest(X)`	Restituisce il valore visualizzato cronologicamente più recente di `X`.	arg_max()	`… \\| summarize arg_max(TimeGenerated, *) by X`
`max(X)`	Restituisce il valore massimo del campo `X`. Se i valori di `X` sono non numerici, il valore massimo viene trovato tramite l'ordinamento alfabetico.	max()	`…\\| summarize max(X)`
`median(X)`	Restituisce il valore al centro del campo `X`.	percentile()	`…\\| summarize percentile(X, 50)`
`min(X)`	Restituisce il valore minimo del campo `X`. Se i valori di `X` sono non numerici, il valore minimo viene trovato tramite l'ordinamento alfabetico.	min()	`…\\| summarize min(X)`
`mode(X)`	Restituisce il valore più frequente del campo `X`.	top-hitters()	`…\\| top-hitters 1 of Y by X`
`perc(Y)`	Restituisce il valore percentile `X` del campo `Y`. Ad esempio, `perc5(total)` restituisce il quinto valore percentile di un campo `total`.	percentile()	`…\\| summarize percentile(Y, 5)`
`range(X)`	Restituisce la differenza tra i valori massimo e minimo del campo `X`.	range()	`range(1, 3)`
`stdev(X)`	Restituisce la deviazione standard di esempio del campo `X`.	stdev	`stdev()`
`stdevp(X)`	Restituisce 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 quadrati dei valori 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 di esempio del campo `X`.	Varianza	`variance(X)`

Passaggi successivi

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

Eseguire la migrazione dell'automazione SOAR

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-23

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

Regole di controllo

Eseguire la migrazione delle regole

Procedura di migrazione delle regole

Confrontare la terminologia delle regole

Eseguire il mapping e il confronto di esempi di regole

Comandi di ricerca comuni

lookup comando: esempio KQL

stats comando: esempio KQL

mstats comando: esempio KQL

transaction comando: esempio SPL

transaction comando: esempio KQL

eventstats comando: esempio SPL

eventstats comando: esempio KQL

anomalydetection comando: esempio SPL

anomalydetection comando: esempio KQL

Comandi comuni eval

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

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

if(X,Y,Z) Esempio KQL

isint(X) Esempio KQL

isstr(X) Esempio KQL

like(X,"y") Esempio

min(X,…) Esempio KQL

mvfilter(X) Esempio KQL

mvjoin(X,Y) Esempio KQL

relative time(X,Y) Esempio KQL

replace(X,Y,Z) Esempio KQL

strptime(X,Y) Esempio KQL

time() Esempio KQL

tostring(X,Y)

tostring(X,Y) Esempio di SPL

urldecode(X) Esempio di SPL

Esempio KQL dei comandi comuni stats