Transizione da SPL a YARA-L 2.0

Supportato in:

Google secops SIEM

Questa guida è rivolta agli utenti che hanno già familiarità con Splunk Search Processing Language (SPL). Fornisce una rapida introduzione a YARA-L 2.0, il linguaggio principale per creare ricerche, dashboard e regole di rilevamento in Google Security Operations.

Comprendere la struttura di YARA-L 2.0

YARA-L 2.0 è il linguaggio di query unificato utilizzato in Google SecOps per la ricerca avanzata di minacce, la creazione di dashboard in tempo reale e la creazione di regole di rilevamento ad alta fedeltà su tutti i dati dei log aziendali man mano che vengono importati.

Il linguaggio funziona in combinazione con il motore di rilevamento di Google SecOps e ti consente di cercare minacce e altri eventi in grandi volumi di dati.

Differenze strutturali di base tra SPL e YARA-L

SPL utilizza una serie di comandi concatenati con caratteri pipe (|), mentre YARA-L è basato su sezioni. Definisci una query utilizzando sezioni distinte, ad esempio events, outcome e condition, per descrivere un pattern che vuoi cercare, rilevare o visualizzare.

La seguente tabella confronta la struttura di base tra SPL e YARA-L:

Funzione	SPL (procedurale)	YARA-L (dichiarativo)
Concetto principale	Trasforma un flusso di dati passo dopo passo utilizzando una pipeline di comandi.	Analizza e applica una struttura in più parti di condizioni e trasformazioni a un flusso di dati operativi e di sicurezza, identificando le minacce ed estraendo informazioni preziose.
Flusso dei dati	Procedurale. I risultati di un comando vengono inviati come input al successivo.	Struttura dichiarativa per elaborare e correlare in modo ottimale i pattern su una scala massiccia. Eliminando la necessità di pensare all'efficienza.
Correlazione eventi	Si basa su comandi espliciti come join, transaction e stats.	Integrato definendo più eventi e mettendoli in correlazione in base a un campo comune nella logica della query.
Finestre temporali	Gestita come finestra di ricerca statica (ad esempio, last 60m). Ogni nuova ricerca è una nuova richiesta.	Gestito come una finestra temporale continua e scorrevole definita all'interno della query (ad esempio, over 5m).
Sintassi	Basato sui comandi (ad esempio, index=web).	Concisi e basati sulla logica (ad esempio, metadata.event_type= "USER_LOGIN").

Struttura specifica delle query

YARA-L impone una struttura specifica per le query, diversa dai comandi sequenziali e concatenati di SPL. SPL crea i risultati concatenando i comandi, mentre YARA-L definisce i diversi aspetti della query in sezioni distinte.

Comando	Azione	Obbligatorio | Facoltativo
meta	Imposta metadati descrittivi per la regola, come autore, descrizione e gravità.	Obbligatorio solo per le regole.
events	Definisce e filtra gli eventi.	Obbligatorio (logica principale della query).
match	Raggruppa per eventi e ti consente di specificare la finestra temporale (ad esempio, by 5m).	Facoltativo. Obbligatorio solo per le query di correlazione di più eventi.
outcome	Calcola le metriche chiave e ottieni approfondimenti.	Facoltativo.
condition	Valuta i criteri della variabile di query per determinare se un risultato è applicabile (ad esempio, #event >5).	Obbligatorio solo per le regole. Facoltativo nella ricerca e nelle dashboard.
dedup	Rimuove gli eventi duplicati raggruppandoli in base a variabili chiave (ad esempio target.user.userid, target.ip>, principal.hostname).	Facoltativo.
order	Ordina i risultati degli eventi raccolti definiti da campi specifici (ad esempio, asc).	Facoltativo.
limit	Limita il numero massimo di eventi restituiti dalla query.	Facoltativo.

Comandi comuni in SPL e YARA-L

La struttura della sezione YARA-L consente di utilizzare gli stessi comandi comuni presenti in SP. Questa sezione illustra le somiglianze e le differenze.

Comando SPL search = sezione YARA-L events

Il comando search in SPL è equivalente alla sezione events in YARA-L. La sezione events definisce gli eventi e il modo in cui vengono filtrati inizialmente. Mentre altre sezioni (come match o outcome) sono facoltative, la sezione events è fondamentale per ogni regola.

Nota: non è necessario dichiarare "events: " nella ricerca e nelle dashboard, ma l'intestazione della sezione è obbligatoria nelle regole.

Ad esempio:

metadata.event_type = "USER_LOGIN"

oppure:

principal.hostname != "" AND metadata.event_type = "NETWORK_CONNECTION"

Nella sezione events delle regole (e delle query avanzate), utilizzi le variabili evento per semplificare la logica.

Una variabile evento funge da raggruppamento logico di filtri, che rappresenta un evento specifico o un gruppo di eventi che soddisfano determinati criteri.

Ad esempio, per definire una variabile evento, come $e, utilizzala come prefisso per tutti gli eventi e i filtri correlati nella sezione events della query. Puoi quindi utilizzare questa variabile in altre sezioni della query (ad esempio match o outcome) per fare riferimento a questo gruppo specifico di eventi e ai relativi campi di dati.

L'applicazione più comune per le variabili evento è all'interno delle regole di rilevamento. Il seguente esempio mostra come utilizzare la variabile evento ($e) in una regola per raggruppare gli eventi e trovare il numero di tentativi di accesso non riusciti per un utente in un giorno. La regola viene attivata se supera una soglia definita.

Nell'esempio di regola, ogni evento è definito con la variabile evento ($e). La variabile $e viene anche citata in metadata.id per collegare i metadati della regola agli eventi definiti.

rule DailyFailedLoginAttempts {
 meta:
   author = "Alex"
   description = "Detects a high number of failed login attempts for a single user within a day."

events:
   // Alias for each event
   $e.metadata.event_type = "USER_LOGIN"
   $e.security_result.action = "FAIL"
   $e.principal.user.userid != ""
   $userid = $e.principal.user.userid

match:
   // Group events by principal.user.userid within a 24-hour window
   $userid over 1d

outcome:
   // Count the number of unique event IDs for each user per day
   $daily_failed_login_count = count($e.metadata.id)

condition:
   // Trigger a detection if the daily failed login count exceeds a threshold
   // You should adjust this threshold based on your environment's baseline.
   #e > 0
}

Per assicurarti che la regola venga attivata, spesso devi controllare il conteggio degli eventi raggruppati. Puoi specificare un conteggio minimo nella sezione condition utilizzando la variabile evento. Ad esempio, la condizione (#e > 0) verifica che esista almeno un evento corrispondente ai criteri.

Comando SPL eval = sezione YARA-L outcome

Il comando eval è una funzione SPL fondamentale utilizzata per manipolare e definire i valori dei campi nei risultati di ricerca.

• Scopo: calcola e definisce nuovi valori dei campi.
• Funzionalità: valuta espressioni matematiche, stringhe o booleane.
• Risultato: il risultato della valutazione crea un nuovo campo o sovrascrive il valore di un campo esistente.
• Concatenazione: è possibile concatenare più espressioni utilizzando una virgola (ad esempio, | eval A=1, B=A+1).
• Elaborazione sequenziale: le espressioni in una catena vengono elaborate in sequenza, consentendo ai calcoli successivi di fare riferimento e basarsi sui campi creati o modificati dalle espressioni precedenti.

Nota: in YARA-L, questa funzionalità viene gestita principalmente dalla sezione outcome, in cui puoi definire e calcolare le variabili utilizzando funzioni simili.

Gli esempi nella tabella seguente (e dopo) spiegano la struttura di questo comando:

Funzione	Descrizione	Esempio YARA-L
Operatori booleani	Utilizzata in events e condition. Consulta Utilizzare OR nella sezione delle condizioni.	metadata.log_type != "" or metadata.event_type = "NETWORK_DNS"
Campi calcolati	Utilizzato nella sezione outcome.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = cast.as_int(network.sent_bytes)
Creazione del nome del campo dinamico	Utilizzato nella sezione outcome.	Vedi gli esempi in Confrontare SPL e YARA-L.

Esempio: creare un nuovo campo che contenga il risultato di un calcolo

Utilizzando YARA-L, crea un nuovo campo, bytes, in ogni evento. Calcola i byte sommando i valori nel campo bytes inviato con il campo bytes ricevuto.

 metadata.event_type = "SCAN_NETWORK"
 principal.hostname != ""
 $host = principal.hostname

match:
   $host

outcome:
   $bytes = cast.as_int(sum(network.sent_bytes))

Esempio: concatenare i valori di due campi

Utilizza il carattere punto (.) per concatenare i valori nel campo first_name con i valori nel campo last_name. Utilizza le virgolette ("") per inserire uno spazio tra i due campi. Durante la concatenazione, i valori vengono letti come stringhe, indipendentemente dal valore effettivo.

In SPL, la query sarà simile a questa:

| eval full_name = first_name+" "+last_name

In YARA-L, la query di ricerca sarà simile a questa:

principal.user.first_name = $first_name
principal.user.last_name = $last_name

outcome:
  $full_name = strings.concat(principal.user.first_name = $first_name
  principal.user.last_name = $last_name

outcome:
   $full_name = strings.concat($first_name, " ", $last_name))

Nota: a parte una ricerca stats, in cui puoi utilizzare i nomi dei campi, nelle regole devi utilizzare una variabile segnaposto nella sezione match. Per i dettagli, vedi Variabili di corrispondenza.

Utilizzando l'esempio di query per i tentativi di accesso non riusciti, l'esempio seguente consente di trovare gli utenti che hanno effettuato cinque o più tentativi di accesso non riusciti entro 10 minuti (10m) l'uno dall'altro (utilizzando sia le variabili di evento sia quelle di segnaposto):

metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"
target.user.userid = $userid

match:
  $userid by 10m

outcome:
   $login_count= count(metadata.id)

condition:
   $login_count > 5

Comando SPL where = sezione YARA-L condition

Il comando SPL where è equivalente a una combinazione delle sezioni events, outcome o condition in YARA-L. Utilizzando la sezione events, puoi dichiarare gli eventi e specificarne gli attributi (ad esempio, priniciapal.hostname = "xyz"). Dopo aver dichiarato gli eventi, puoi utilizzare operatori booleani, operatori di confronto e risultati della funzione di aggregazione (dalla sezione outcome) per definire i parametri che gli eventi devono soddisfare affinché la query restituisca un risultato.

Il seguente esempio mostra come impostare una condizione di soglia su un conteggio aggregato. La query è strutturata in modo da conteggiare il numero totale di eventi di accesso non riuscito per ID utente e utilizza la sezione condition per restituire i risultati solo per gli utenti che hanno registrato cinque o più accessi non riusciti.

metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"

match:
  target.user.userid

outcome:
  // metadata.id counts all unique events associated with failed logins.
  $count = count(metadata.id)
  //metadata.id counts all unique events associated with blocked logins.

condition:
  $count > 5

Comando SPL dedup = sezione YARA-L dedup

Il comando dedup SPL è equivalente alla sezione dedup in YARA-L. Utilizza la sezione dedup per deduplicare i risultati duplicati specificati da un evento nella sezione events.

Ad esempio:

principal.hostname = "foo"

dedup:
   target.ip

Comando SPL stats = sezione YARA-L match o outcome (o entrambe)

In SPL, l'aggregazione viene in genere gestita dalla famiglia di comandi stats, che specifica il tipo di aggregazione (ad esempio count, distinct count, max, min) e il campo "group by".

In YARA-L, le sezioni match e outcome forniscono congiuntamente questa funzionalità:

• Logica di aggregazione: la sezione match crea aggregazioni definendo il gruppo di eventi da considerare (match: $grouping_field by time). La sezione outcome definisce quindi le funzioni aggregate specifiche da calcolare per quel gruppo (ad esempio, count(), min(), max()).

• Finestra temporale: la sezione match supporta la specifica di una finestra temporale per raggruppare gli eventi. Utilizza la parola chiave over (per le regole) o by (per la ricerca e le dashboard) (ad esempio, match: $userid by 1h). Questa funzionalità è simile a SPL, ad esempio "timechart", "streamstats" e "eventstats". Per ulteriori informazioni, vedi Finestre temporali.

Esempio: calcola la somma dei byte raggruppati per nome host principale e IP di destinazione

L'esempio seguente utilizza la sezione match per definire un gruppo di aggregazione in base al nome host principale e all'indirizzo IP di destinazione in un intervallo di tempo di un giorno. La somma risultante dei byte inviati viene quindi calcolata all'interno della sezione outcome.

metadata.event_type = "NETWORK_CONNECTION"
network.sent_bytes > 0
principal.hostname != ""
target.ip != ""

// Define placeholder variables for grouping
$principal_hostname = principal.hostname
$target_ip = target.ip

// Group events by principal hostname, target IP, and day
match:
  $principal_hostname, $target_ip by day

// Calculate the sum of sent bytes for each group
outcome:
  $daily_bytes_sent = sum(network.sent_bytes)

Mappa SPL su YARA-L

SPL elabora i dati passo dopo passo tramite comandi piped, mentre YARA-L utilizza una struttura dichiarativa basata su sezioni per definire pattern e azioni. Nonostante queste differenze fondamentali nell'approccio, la potenza espressiva di YARA-L ti consente di eseguire molte delle stesse attività che sei abituato a svolgere in SPL, dal filtraggio di base ad aggregazioni e correlazioni complesse.

Questa sezione spiega le differenze mappando le funzionalità SPL più comuni ai loro equivalenti nel framework YARA-L.

Confrontare SPL e YARA-L

Questa tabella confronta le funzioni e i concetti comuni nel linguaggio SPL con i loro equivalenti in YARA-L 2.0 o il modo in cui il concetto viene gestito all'interno di una struttura di query YARA-L.

Comando o concetto SPL	Finalità	Equivalente YARA-L	Descrizione e mappatura YARA-L	Esempio di implementazione di YARA-L
search	Filtro iniziale dei dati	Sezione events	Definisci i campi e le condizioni dell'evento. Nessun prefisso events: necessario per la ricerca o le dashboard. Vedi l'esempio.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL"
where	Filtro aggiuntivo sui risultati	Sezioni events e condition	Applica la logica booleana, spesso ai risultati aggregati. Vedi l'esempio.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL" outcome: $failed_count = count(metadata.id) condition: $failed_count > 5
eval	Calcola nuovi valori da campi esistenti, aggregazioni e ricerche di dati	sezione outcome o events	Vedi l'esempio di SPL eval.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
stats	Aggregazioni (count, sum, media)	match o outcome	Raggruppa per campi in match. Calcola gli aggregati in outcome. Vedi gli esempi in Aggregazioni e query statistiche e comando SPL stats.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
dedup	Rimuove gli eventi duplicati in base a uno o più campi	Sezione dedup	Specifica i campi su cui eseguire la deduplicazione.	metadata.event_type = "USER_LOGIN" security_result.action = "FAIL" $user = target.user.userid dedup: $user
table	Definisce l'output della colonna della tabella	select o unselect	Utilizzato nelle dashboard. Nella ricerca, vengono visualizzate outcome variabili.	metadata.event_type = "USER_LOGIN" select: principal.hostname
sort	Elenca i risultati in ordine crescente o decrescente	Sezione order	Vedi l'esempio nella cella della tabella successiva.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = uint64(network.sent_bytes) order: $bytes desc
limit	Limita il numero di risultati restituiti	Sezione limit	Vedi l'esempio nella cella successiva.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = cast.as_int(network.sent_bytes) order: $bytes desc limit: 3
Funzioni multivalore	Gestito con le funzioni mv* (mvexpand, mvfilter)	Assistenza integrata	YARA-L esegue automaticamente l'unesting degli array nella sezione degli eventi. Se necessario, le funzioni di array sono disponibili in outcome.	Consulta gli esempi di funzione multivalore.
Finestre temporali	earliest=-5m, latest=now	Sezione match, over, by	Per i rilevamenti continui, utilizza match: $field over 5m or by 5m. Per le dashboard nell'UI di ricerca, utilizza match: $field by 5m.	Vedi gli esempi in Finestre temporali.

Query di aggregazione e statistiche

In YARA-L, le funzioni di aggregazione e statistiche vengono in genere inserite nella sezione outcome e l'aggregazione si basa sulla sezione match.

Il comando stats è il meccanismo principale per implementare l'aggregazione dei dati all'interno delle query YARA-L. Trasforma i dati degli eventi non elaborati in metriche di sicurezza riepilogative. Mentre il comando eval gestisce le trasformazioni a livello di campo, riga per riga (simili a un'espressione SELECT), stats esegue l'aggregazione a livello di set (simile a GROUP BY in SQL).

La tabella seguente fornisce la sintassi e l'utilizzo di base, mostrando come utilizzare in modo efficace le statistiche per implementare una logica di sicurezza sofisticata basata su pattern di dati e valori anomali statistici.

Funzione SPL	Descrizione	Equivalente YARA-L	Esempio di implementazione di YARA-L
count	Conteggia il numero di eventi.	count()	metadata.event_type= "USER_LOGIN" security_result.action= "FAIL" outcome: $event_count = count(metadata.id) condition: $event_count > 2
dc (count_distinct)	Calcola il numero di valori univoci per un campo.	count_distinct()	metadata.event_type = "USER_LOGIN" outcome: $unique_users=count_distinct(principal.user.userid)
sum	Calcola la somma dei valori di un campo.	sum()	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" $host = principal.hostname match: $host outcome: $bytes = sum(network.sent_bytes)
avg	Calcola il valore medio di un campo.	avg()	$host = principal.hostname match: $host by day outcome: $avg_bytes_sent = avg(network.sent_bytes)
min/max	Trova il valore minimo o massimo per un campo.	min() o max()	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" $host = principal.hostname match: $host outcome: $bytes = max(network.sent_bytes)- min(network.sent_bytes)
median()	Trova il valore mediano.	window.median	target.file.mime_type = "PDF" outcome: $median_file_size = window.median(target.file.size, false)
first() and last()	Restituisce i valori in base all'ordine degli eventi nei risultati di ricerca.	window.first/window.last	metadata.event_type = "NETWORK_CONNECTION" principal.ip != "" match: principal.ip outcome: $event_count = count(metadata.id) $first_seen = window.first(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds)) $last_seen = window.last(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
STDDEV()	Calcola la deviazione standard, che misura la dispersione di un insieme di dati.	window.stddv	principal.hostname= $host match: $host over 5m outcome: $stddev = window.stddev(network.sent_bytes)

Per maggiori dettagli, vedi Funzioni aggiuntive.

Ad esempio, una query in più fasi può monitorare più tentativi di accesso non riusciti in aggregazioni a più livelli. Per i dettagli, consulta l'esempio di aggregazione in più fasi e Creare query in più fasi in YARA-L.

Aggregazione in più fasi (media oraria-settimanale)

Questo esempio in più fasi inizialmente aggrega i dati per trovare i byte trasferiti per host ogni ora. Poi, utilizza questa aggregazione per calcolare la media complessiva in questi bucket orari degli ultimi sette giorni.

stage bytes_per_host {
metadata.event_type = "SCAN_NETWORK"
principal.hostname != ""
$host = principal.hostname

match:
  $host by hour

outcome:
  $bytes = cast.as_int(sum(network.sent_bytes))
}

$host = $bytes_per_host.host

match:
  $host

outcome:
  $hour_buckets = array_distinct(timestamp.get_timestamp($bytes_per_host.window_start))
  $num_hour_buckets = count_distinct($bytes_per_host.window_start)
  $avg_hourly_bytes = avg($bytes_per_host.bytes)

Funzioni multivalore (lettura di un array)

La sintassi di YARA-L è progettata per comprendere che un campo può avere più valori. Quando scrivi una query che include un evento con un campo multivalore nella sezione events, il linguaggio controlla automaticamente ogni valore nell'array. Non è necessario utilizzare una funzione speciale per filtrare l'array, basta indicare la condizione che vuoi soddisfare. Ad esempio, se il campo principal.ip dell'evento di log contiene quanto segue, il motore YARA-L controlla automaticamente ogni valore nell'array principal.ip. Se uno dei valori è "10.1.1.5", la condizione è soddisfatta.

["10.1.1.5", "10.2.2.6", "10.3.3.7"]

La seguente tabella mostra un confronto tra YARA-L e SPL su come gestire i campi multivalore nei dati di log. I campi multivalore, come un array di indirizzi IP o un elenco di gruppi di utenti, sono una funzionalità comune nei log strutturati.

Funzione SPL	Purpose	Equivalente YARA-L	Esempio di implementazione di YARA-L
mvfilter()	Filtra un campo multivalore per conservare solo i valori corrispondenti.	Se utilizzato nella sezione events di una query YARA-L, elenca il campo da corrispondere. YARA-L controlla automaticamente se un valore nell'array dei gruppi corrisponde a "`admin`".	principal.user.group_identifiers = "admin"
mvcount()	Conta il numero di valori in un campo multivalore.	count() applicato a un campo nella sezione della query outcome. Non è necessario annidare prima alcun valore.	Consulta l'esempio Conteggia il numero di utenti che appartengono al gruppo del personale IT.
mvexpand	Crea un nuovo evento per ogni valore in un campo multivalore.	Gestisce i campi multivalore in modo nativo e implicito; l'annidamento viene eseguito automaticamente.	Consulta l'esempio Conteggia il numero di utenti che appartengono al gruppo del personale IT.
mvjoin	Unisce tutti i valori di un campo multivalore in un'unica stringa a scopo di formattazione dei dati.	I valori vengono memorizzati automaticamente come array nei risultati. L'output di YARA-L è strutturato, non una stringa piatta. Visualizza il campo come array se è necessaria un'ulteriore manipolazione dell'array. Per maggiori dettagli, utilizza le funzioni di matrice.

Esempio: conta il numero di accessi a admin

Nell'esempio seguente, la condizione $metadata.event_type = "USER_LOGIN" filtra gli eventi in cui event_type è "USER_LOGIN":

events:
 metadata.event_type = "USER_LOGIN" // Changed to a more appropriate event type for login
 principal.user.group_identifiers = "admin"

outcome:
 // This counts each unique event ID where the principal user is in the `"admin"` group.
 $admin_login_count = count(metadata.id)

Il campo $principal.user.group_identifiers= "admin" è un campo ripetuto (un array).

• Unnesting implicito: YARA-L esegue automaticamente l'unnesting di questo campo internamente durante la valutazione della query.
• Controllo della condizione: un evento soddisferà la condizione se uno qualsiasi dei valori all'interno dell'array $principal.user.group_identifiers è uguale a "admin".
• Nessun comando esplicito necessario: a differenza di SPL, non è necessario un comando di annidamento specifico come mvexpand.

La sezione relativa all'impatto sull'aggregazione (outcome) indica che l'annidamento implicito è fondamentale nella sezione outcome (ad esempio, outcome: $admin_login_count = count(metadata.id))). Tieni presente il seguente impatto:

• Un singolo evento UDM che contiene più valori corrispondenti in un campo ripetuto può generare più righe interne ai fini della valutazione della query.
• Poiché la sezione events ha già annidato gli eventi in base a ogni valore corrispondente in $principal.user.group_identifiers, l'aggregazione count(metadata.id) conteggia ciascuna di queste istanze non annidate.

Esempio: conta il numero di utenti che appartengono al gruppo del personale IT

SPL:

index=<your_index_name> user_id="jsmith" 
| where match(memberOf, "Domain Admins|IT Staff|HR") 
| mvexpand memberOf 
| stats count by memberOf 
| mvexpand actions 
| table memberOf, count, actions

YARA-L (ricerca):

 principal.user.userid = "jsmith"
 additional.fields["memberOf"] = $group
   $group = /Domain Admins|IT Staff|HR/ nocase
 
 match:
   $group by 1h
 
 outcome:
   $group_count = count_distinct(metadata.id)
   $memberOf = array_distinct($group)
   $risk_score = max(50)

Esempio: crea una regola per inviare un avviso quando è presente un hash di file specifico

SPL:

| eval file_hashes="hash12345,hash67890,hashABCDE" 
| makemv delim="," file_hashes 
| mvexpand file_hashes 
| search file_hashes="hash67890" 
| table _time, file_hashes

YARA-L (regola):

    rule specific_file_hash_detected {
    
    meta:
      rule_name = "Specific File Hash Detected"
      description = "Detects events where a specific file hash is present."
      severity = "Medium"
    
    events:
      $e.target.file.sha256 == "hash67890"
    
    outcome:
      $time = array_distinct($e.metadata.event_timestamp)
      $file_hashes = array_distinct($e.target.file.sha256)
    
    condition:
      $e
    }

Finestre temporali

In YARA-L, il raggruppamento in finestre temporali è un metodo per correlare gli eventi in un periodo di tempo specifico e variabile. Se utilizzata nelle regole, questa finestra si sposta continuamente con i dati in arrivo, il che consente il rilevamento continuo e in tempo reale dei pattern che si sviluppano nel tempo.

Questo processo è una parte fondamentale della progettazione per il rilevamento automatico ed è uno dei vantaggi dell'utilizzo di YARA-L. Se specifichi la finestra temporale, i rilevamenti e le dashboard funzionano continuamente con i dati in tempo reale.

Funzionalità	SPL	YARA-L
Obiettivo principale	Ricerca statica, analisi ad hoc	Rilevamento continuo, correlazione automatica
Funzioni principali	earliest, latest, span, transaction	over, by
Esempio di 5 minuti	earliest=-5m (ricerca statica) o transaction maxspan=5m	match: [event] over 5m (rilevamento continuo nelle regole) o [event] by 5m (ricerca e dashboard)

Gli esempi in questa sezione illustrano la differenza tra una finestra temporale cumulativa (che utilizza by) e una finestra temporale scorrevole (che utilizza over) in YARA-L.

Finestra temporale a cascata (by <time_unit>)

• Concetto: utilizzate nella ricerca YARA-L, le finestre temporali cumulative creano intervalli di tempo fissi, non sovrapposti e di dimensioni fisse. Il sistema elabora ogni evento assegnandolo a un solo bucket temporale specifico in base al timestamp. Questi intervalli fissi sono assoluti e si allineano rigorosamente ai marcatori temporali standard, come giorni, ore o minuti.

• Utilizzo: utilizzato comunemente nelle query di ricerca e nei dashboard di Google SecOps per aggregare i dati in segmenti di tempo discreti.

Esempio: conteggio giornaliero degli accessi riusciti per utente

Questa query di ricerca raggruppa gli eventi di accesso riuscito per ogni utente univoco in ogni giorno di calendario. Il seguente esempio mostra una finestra temporale di ricerca YARA-L (by day):

events:
  //Filter for successful login events
  metadata.event_type = "USER_LOGIN"
  principal.user.userid != ""

match:
  //Group by each unique user ID, aggregated over a calendar day.
  principal.user.userid by day

outcome:
  //Count how many successful logins occurred for this user on this specific day.
  $daily_success_count = count(metadata.id)
  
  //Get the timestamp of the FIRST event within this daily group.
  $first_event_time = window.first(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
  
  //Get the timestamp of the LAST event within this daily group.
  $last_event_time = window.last(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))

Come funziona: se l'utente jdoe ha 10 accessi riusciti il giorno Nov 17 e 15 il giorno Nov 18, questa query produce due righe separate per jdoe, una per ogni giorno, con i rispettivi conteggi. Il bucket Nov 17 include gli eventi di 2025-11-17 00:00:00 to 23:59:59 UTC.

Finestra temporale scorrevole (over <duration>)

• Concetto: utilizzate nelle regole YARA-L, le finestre scorrevoli sono finestre temporali in movimento, potenzialmente sovrapposte, di una durata specificata. Sono ideali per correlare eventi che si verificano a una certa distanza l'uno dall'altro.

• Utilizzo: utilizzato principalmente nelle regole YARA-L per rilevare pattern o sequenze di eventi in un periodo di tempo continuo.

Esempio: rileva più tentativi di accesso non riusciti in 5 minuti

Questo esempio di regola YARA-L genera un rilevamento se un singolo utente ha più di 5 failed logins tentativi in un periodo di 5-minute continuativo:

rule TooManyFailedLogins_SlidingWindow {
 meta:
   author = "Alex"
   description = "Detects when a user has more than 5 failed logins within a 5-minute sliding window."
   severity = "Medium"

events:
   // Define an event variable $e for failed login attempts
   $e.metadata.event_type = "USER_LOGIN"
   $e.security_result.action = "FAIL"
   $e.principal.user.userid != ""
   $userid = $e.principal.user.userid

match:
   // Group events by userid over a continuous 5-minute sliding window.
   // Any events for the same $userid within 5 minutes of each other are grouped.
   $userid over 5m

outcome:
   // Count the number of failed login events within each 5-minute window for the grouped userid.
   $failed_count = count($e.metadata.id)

condition:
   // Trigger a detection if the count of failed logins in ANY 5-minute window is greater than 5.
   #e > 5
}

Come funziona: il sistema monitora continuamente i tentativi di accesso non riusciti. In un determinato momento, considera gli eventi degli ultimi 5 minuti per ogni utente. Ad esempio, se tra le ore 10:02:30 e 10:07:30 l'utente jdoe accumula sei tentativi di accesso non riusciti, viene attivato un rilevamento. Questa finestra scorre costantemente in avanti, consentendo il rilevamento di pattern in tempo reale, indipendentemente dai limiti del calendario.

Passaggi successivi

• Approfondisci la panoramica di YARA-L 2.0
• Esplora la sintassi completa del linguaggio YARA-L 2.0
• Scopri di più sulla scrittura di regole per Detection Engine
• Nuovi blog di Google SecOps

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.