KQL per Microsoft Sentinel

Alcuni suggerimenti, trucchi ed esempi per l'uso di KQL con Microsoft Sentinel.

1. Introduzione
2. L'anatomia di una query KQL
3. Le basi
   1. Nozioni di base sul tempo
   2. Nozioni di base su Where
   3. Nozioni di base su Project
   4. Nozioni di base su Summarize
   5. Nozioni di base su Render
   6. Nozioni di base su Parse e Split

Introduzione

Kusto Query Language è il linguaggio utilizzato in Azure Monitor, Azure Data Explorer e Azure Log Analytics (ciò che Microsoft Sentinel usa dietro le quinte). Ho sempre trovato utile questa visualizzazione relativa a KQL -

Vogliamo usare KQL per creare query accurate ed efficienti per trovare minacce, rilevamenti, modelli e anomalie all'interno del nostro set di dati più ampio.

L'anatomia di una query KQL

Prendi come esempio la query qui sotto```kql SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName == "[email protected]" | where ResultType == "0" | where AppDisplayName == "Microsoft Teams" | project TimeGenerated, Location, IPAddress, UserAgent

Quando eseguiamo una query come questa, la prima riga dice a Microsoft Sentinel in quale tabella cercare i dati, quindi in questo caso vogliamo cercare nella tabella SigninLogs, che è dove vengono inviati i dati di accesso di Azure AD. Puoi vedere un elenco delle tabelle [qui](https://docs.microsoft.com/en-us/azure/sentinel/data-source-schema-reference).

Microsoft Sentinel eseguirà quindi la query in sequenza, quindi eseguirà ogni riga una per una fino a raggiungere la fine, o a un errore. Quindi, per suddividere la nostra query riga per riga.```kql
SigninLogs

Quindi prima abbiamo scelto la nostra tabella SigninLogs.```kql SigninLogs | where TimeGenerated > ago(14d)

Successivamente diciamo a Sentinel di esaminare i dati degli ultimi 14 giorni in questa tabella.```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where UserPrincipalName == "[email protected]"

Successivamente chiediamo a Sentinel di trovare solo i log in cui UserPrincipalName è uguale a "[email protected]"```kql SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName == "[email protected]" | where ResultType == "0"

Poi cerchiamo solo i log in cui ResultType == 0, che corrisponde a un accesso riuscito ad Azure AD.```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where UserPrincipalName == "[email protected]"
| where ResultType == "0"
| where AppDisplayName == "Microsoft Teams"

Successivamente cerchiamo solo gli accessi a Microsoft Teams.```kql SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName == "[email protected]" | where ResultType == "0" | where AppDisplayName == "Microsoft Teams" | project TimeGenerated, Location, IPAddress, UserAgent

La nostra ultima riga usa l'operatore project, per restituire solo 4 campi dai nostri log, quindi vedremo solo TimeGenerated, Location, IPAddress e UserAgent restituiti dai nostri dati SigninLogs.

È così che si costruiscono le query, ora le basi.

## Le basi

### Nozioni di base sul tempo

Microsoft Sentinel e KQL sono altamente ottimizzati per i filtri temporali, quindi se conosci il periodo di tempo dei dati che vuoi cercare, dovresti filtrare l'intervallo di tempo subito. Recuperare gli ultimi 14 giorni di log, poi cercare un nome utente come nella query seguente -```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where UserPrincipalName == "[email protected]"

È molto più efficiente che cercare prima un nome utente e poi cercare il periodo di tempo in questo modo -```kql SigninLogs | where UserPrincipalName == "[email protected]" | where TimeGenerated > ago(14d)

KQL offre molte opzioni per interrogare periodi di tempo specifici.```kql
SigninLogs
| where TimeGenerated > ago(14d)

Come nel primo esempio, questa ricerca coprirà gli ultimi 14 giorni.```kql SigninLogs | where TimeGenerated > ago(14h)

Puoi anche fare ore.```kql
SigninLogs
| where TimeGenerated > ago(14m)

E minuti.

KQL supporta anche le query tra intervalli di tempo -```kql SigninLogs | where TimeGenerated between (ago(14d) .. ago(7d))

Questo troverà i dati SigninLogs tra 14 giorni e 7 giorni fa.```kql
SigninLogs
| where TimeGenerated between (ago(14h) .. ago(7h))

Tra 14 ore e 7 ore fa.```kql SigninLogs | where TimeGenerated between (ago(14m) .. ago(7m))

E tra 14 minuti e 7 minuti fa.

### Basi di Where

Where è un operatore che userai praticamente in ogni query che scrivi. È così che dici a Microsoft Sentinel di cercare dati specifici. La sintassi è molto importante con l'operatore where. Se usiamo il nostro stesso esempio.```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where UserPrincipalName == "[email protected]"

Questo cercherà nella nostra tabella SigninLogs, negli ultimi 14 giorni, le corrispondenze esatte in cui il nostro UserPrincipalName è uguale a [email protected]. In KQL, l'operatore == distingue tra maiuscole e minuscole, quindi se cerchi [email protected] e il nome utente è in realtà [email protected], non otterrai alcun risultato. L'equivalente senza distinzione tra maiuscole e minuscole è =```kql SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName = "[email protected]"

Questo troverà tutte le corrispondenze per [email protected] indipendentemente dalla distinzione tra maiuscole e minuscole.

Invece di equals, possiamo anche usare contains.```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where UserPrincipalName contains "reprise_99"

Questo troverà tutte le voci di log in cui UserPrincipalName contiene reprise_99; se avessi dati per [email protected] e [email protected], li troverebbe entrambi. L'operatore contains non è sensibile alle maiuscole, ma puoi usare contains_cs per renderlo sensibile alle maiuscole.

Puoi usare startswith o endswith se stai cercando pattern specifici.```kql SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName startswith "reprise_99"

SigninLogs | where TimeGenerated > ago(14d) | where UserPrincipalName endswith "testdomain.com"

Sia `startswith` che `endswith` non fanno distinzione tra maiuscole e minuscole, ma puoi usare `startswith_cs` o `endswith_cs` per renderle sensibili alle maiuscole/minuscole.

Se stai cercando parole intere (più lunghe di quattro caratteri), in KQL puoi usare l'operatore `has`. Usare `has` è più efficiente di `contains` perché i dati sono indicizzati per te.```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where AppDisplayName has "Teams"

Questo troverà tutti i SigninLogs in cui il nome visualizzato dell'applicazione contiene la parola Teams, che potrebbero includere "Microsoft Teams" e "Microsoft Teams Web Client"; entrambi soddisfano la query.

Se stai cercando più parole, puoi usare has_any o has_all.```kql SigninLogs | where TimeGenerated > ago(14d) | where AppDisplayName has_any ("Teams","Outlook")

Questo restituirà risultati in cui il nome visualizzato dell'applicazione contiene "Teams" o "Outlook"```kql
SigninLogs
| where TimeGenerated > ago(14d)
| where AppDisplayName has_all ("Teams","Outlook")

This will return results where the application display name has "Teams" and "Outlook".

Questo restituirà risultati in cui il nome visualizzato dell'applicazione contiene "Teams" e "Outlook".

If you don't know which fields to search in, you can also use wildcards, it is inefficient but may get you on the right track to find what you want.