Sintassi del linguaggio YARA-L 2.0

Questa sezione descrive i principali elementi della sintassi YARA-L. Consulta anche l'articolo Panoramica della lingua YARA-L 2.0.

Struttura della regola

Per YARA-L 2.0, devi specificare dichiarazioni, definizioni e utilizzi delle variabili nel seguente ordine:

1. meta
2. eventi
3. corrispondenza (facoltativo)
4. come risultato (facoltativo)
5. condizione
6. options (facoltativo)

Nota: se non elimini la sezione facoltativa match, la regola può corrispondere a un singolo evento.

Di seguito è illustrata la struttura generica di una regola:

rule <rule Name>
{
  meta:
    // Stores arbitrary key-value pairs of rule details, such as who wrote
    // it, what it detects on, version control, etc.

  events:
    // Conditions to filter events and the relationship between events.

  match:
    // Values to return when matches are found.

  outcome:
    // Additional information extracted from each detection.

  condition:
    // Condition to check events and the variables used to find matches.

  options:
    // Options to turn on or off while executing this rule.
}

Commenti

Assegna ai commenti due barre (// comment) o i commenti su più righe con l'asterisco (/* comment */), come faresti in C.

Valori letterali

Sono supportati numeri interi non negativi (senza decimali), stringa, booleano e regex.

Valori letterali stringa e regex

Puoi utilizzare una delle seguenti virgolette per inserire le stringhe in YARA-L 2.0. Tuttavia, il testo citato viene interpretato diversamente a seconda del testo utilizzato.

1. Virgolette doppie (") utilizzate per le stringhe normali. Deve includere caratteri di escape.
   Ad esempio: "hellofooworld":xxxxxxxxx è interpretato come una tabulazione

2. Citazioni indietro (`): utilizza questa opzione per interpretare tutti i caratteri alla lettera.
   Ad esempio: "helloOkworld" - CIDR non viene interpretato come scheda

Le espressioni regolari hanno due opzioni.

Se vuoi usare espressioni regolari direttamente senza la funzione re.regex(), utilizza /regex/ per i valori letterali delle espressioni regolari.

Puoi anche utilizzare i valori letterali stringa come valori letterali regex quando utilizzi la funzione re.regex(). Tieni presente che, per i valori letterali delle virgolette, devi utilizzare il carattere di escape per le barre rovesciate, che possono avere un aspetto complicato.

Ad esempio, le seguenti espressioni regolari sono equivalenti:

• re.regex($e.network.email.from, `.*altostrat\.com`)
• re.regex($e.network.email.from, ".*altostrat\\.com")
• $e.network.email.from = /.*altostrat\.com/

Per agevolare la leggibilità, Google consiglia di utilizzare le virgolette precedenti per le stringhe nelle espressioni regolari.

Operatori

In YARA-L puoi utilizzare i seguenti operatori:

Operatore	Description
=	uguale/dichiarazione
!=	diverso
<	minore di
<=	minore o uguale a
>	maggiore di
>=	maggiore o uguale a

Variabili

In YARA-L 2.0, tutte le variabili sono rappresentate come $<variable name>.

Puoi definire i seguenti tipi di variabili:

• Variabili evento: rappresentano i gruppi di eventi in forma normalizzata (UDM) o eventi di entità. Specifica le condizioni per le variabili evento nella sezione events. Per identificare le variabili evento, utilizza un nome, un'origine evento e i campi evento. Le origini consentite sono udm (per eventi normalizzati) e graph (per eventi entità). Se la sorgente viene omessa, udm viene impostata come origine predefinita. I campi evento sono rappresentati come una catena di .<nome campo> (ad esempio, $e.field1.field2). Le catene di campi eventi iniziano sempre dalla sorgente di primo livello (UDM o Entità).

• Variabili di corrispondenza: dichiara nella sezione match. Le variabili di corrispondenza diventano campi di raggruppamento per la query, poiché viene restituita una riga per ogni insieme univoco di variabili di corrispondenza (e per ogni finestra temporale). Quando la regola trova una corrispondenza, vengono restituiti i valori della variabile di corrispondenza. Specifica cosa rappresenta ogni variabile di corrispondenza nella sezione events.

• Variabili segnaposto: dichiara e definisci nella sezione events. Le variabili segnaposto sono simili alle variabili di corrispondenza. Tuttavia, puoi utilizzare le variabili segnaposto nella sezione condition per specificare le condizioni di corrispondenza.

Nota: ogni variabile segnaposto deve essere mappata a un campo evento. Ad esempio, se in una regola hai fatto riferimento solo al seguente segnaposto in questa singola riga, non verrà compilato poiché $var non è associato a una variabile evento: $e.field != $var

Utilizza le variabili di corrispondenza e le variabili segnaposto per dichiarare le relazioni tra i campi di eventi tramite condizioni di unione transitive (per saperne di più, consulta Sintassi della sezione Eventi).

Maps

Strutture ed etichette

Alcuni campi UDM utilizzano il tipo di dati Struct o Label.

Per cercare una coppia chiave-valore specifica sia in Struct che in Label, utilizza la sintassi standard della mappa:

// A Struct field.
$e.udm.additional.fields["pod_name"] = "kube-scheduler"
// A Label field.
$e.metadata.ingestion_labels["MetadataKeyDeletion"] = "startup-script"

Richieste di assistenza supportate

Sezione Eventi e risultati

// Using a Struct field in the events section
events:
  $e.udm.additional.fields["pod_name"] = "kube-scheduler"

// Using a Label field in the outcome section
outcome:
  $value = array_distinct($e.metadata.ingestion_labels["MetadataKeyDeletion"])

Assegnare un valore mappa a un segnaposto

$placeholder = $u1.metadata.ingestion_labels["MetadataKeyDeletion"]

Utilizzo di un campo mappa in una condizione di unione

// using a Struct field in a join condition between two udm events $u1 and $u2
$u1.metadata.event_type = $u2.udm.additional.fields["pod_name"]

Richieste di assistenza non supportate

Combinare any o all parole chiave con una mappa

Ad esempio, quanto segue non è attualmente supportato: all $e.udm.additional.fields["pod_name"] = "kube-scheduler"

Functions

Questa sezione descrive le funzioni YARA-L 2.0 supportate da Chronicle in Motore di rilevamento.

Queste funzioni possono essere utilizzate nelle seguenti aree di una regola:

• Sezione events.
• BOOL_CLAUSE di un condizionale nella sezione dei risultati.

Funzioni di stringa

Chronicle supporta le seguenti funzioni di manipolazione delle stringhe:

• string.concat(a; b)
• string.coalesce(a; b)
• string.to_lower(stringText)
• string.to_upper(stringText)
• string.base64_decode(encodedString)

Le sezioni seguenti descrivono come utilizzare ciascuno di essi.

Concatena stringhe o numeri interi

Restituisce la concatenazione di due stringhe, due numeri interi o una combinazione dei due.

strings.concat(a, b)

Questa funzione accetta due argomenti, che possono essere stringhe o numeri interi e restituisce i due valori concatenati come stringa. I numeri interi vengono trasmessi a una stringa prima della concatenazione. Gli argomenti possono essere valori letterali o campi evento. Se entrambi gli argomenti sono campi, i due attributi devono provenire dallo stesso evento.

L'esempio seguente include una variabile stringa e un valore letterale stringa come argomenti.

"google-test" = strings.concat($e.principal.hostname, "-test")

L'esempio seguente include una variabile stringa e una variabile numero intero come argomenti. principal.hostname e principal.port appartengono allo stesso evento, $e, e sono concatenati per restituire una stringa.

"google80" = strings.concat($e.principal.hostname, $e.principal.port)

L'esempio seguente tenta di concatenare principal.port dall'evento $e1, con principal.hostname dall'evento $e2. Verrà restituito un errore di compilazione perché gli argomenti sono variabili di evento diverse.

// returns a compiler error
"test" = strings.concat($e1.principal.port, $e2.principal.hostname)

Coalesce i valori delle stringhe

Restituisce il valore della prima espressione che non restituisce una stringa vuota (ad esempio, "valore diverso da zero"). Se entrambi gli argomenti restituiscono una stringa vuota, la chiamata funzione restituisce una stringa vuota.

strings.coalesce(a, b)

Gli argomenti possono essere valori letterali, campi di evento o chiamate di funzione. Entrambi gli argomenti devono essere di tipo STRING. Se entrambi gli argomenti sono campi, i due attributi devono provenire dallo stesso evento.

L'esempio seguente include una variabile stringa e un valore letterale stringa come argomenti. La condizione restituisce true quando (1) $e.network.email.from è [e-mail] o (2) $e.network.email.from è vuoto e $e.network.email.to è [e-mail].

"[e-mail]" = strings.coalesce($e.network.email.from, $e.network.email.to)

L'esempio seguente include chiamate a coalesce nidificate. Questa condizione confronta il primo indirizzo IP non null dell'evento $e con i valori nell'elenco di riferimento ip_watchlist. L'ordine in cui gli argomenti vengono uniti in questa chiamata è lo stesso in cui vengono enumerati nella condizione della regola:

1. $e.principal.ip viene valutato per primo.
2. $e.src.ip viene valutato in seguito.
3. $e.target.ip viene valutato in seguito.
4. Infine, se i campi IP precedenti non sono impostati, viene restituito il valore predefinito della stringa "Nessun IP".

strings.coalesce(
  strings.coalesce($e.principal.ip, $e.src.ip),
  strings.coalesce($e.target.ip, "No IP")
) in %ip_watchlist

L'esempio seguente tenta di unire principal.hostname dall'evento $e1 e dall'evento $e2. Verrà restituito un errore di compilazione perché gli argomenti sono variabili di evento diverse.

// returns a compiler error
"test" = strings.coalesce($e1.principal.hostname, $e2.principal.hostname)

Converti stringa in maiuscolo o minuscolo

Queste funzioni restituiscono il testo della stringa dopo aver modificato tutti i caratteri in lettere maiuscole o minuscole.

• string.to_lower(stringText)
• string.to_upper(stringText)

"[e-mail]" = strings.to_lower($e.network.email.from)
"[e-mail]" = strings.to_upper($e.network.email.to)

Base64 decodifica una stringa

Restituisce una stringa contenente la versione decodificata base64 della stringa codificata.

strings.base64_decode(encodedString)

Questa funzione utilizza una stringa codificata in base64 come argomento. Se encodedString non è una stringa codificata base64 valida, la funzione restituisce encodedString così com'è.

Questo esempio restituisce True se principal.domain.name è "dGVzdA==", che è una codifica di base64 per la stringa "test".

"test" = strings.base64_decode($e.principal.domain.name)

Funzioni RegExp

Chronicle supporta le seguenti funzioni di espressione regolare:

• re.regex(stringText, regex)
• re.capture(stringText, regex)
• resostituisci(stringText, replaceRegex, replaceText)

Corrispondenza con espressione regolare

Puoi definire la corrispondenza delle espressioni regolari in YARA-L 2.0 utilizzando una delle seguenti sintassi:

• Utilizzo della sintassi YARA: correlato agli eventi. Di seguito è riportata una rappresentazione generica di questa sintassi: $e.field = /regex/
• Utilizzo della sintassi YARA-L: come funzione che accetta i seguenti parametri:
  • Campo a cui viene applicata l'espressione regolare.
  • Espressione regolare specificata come stringa. Puoi utilizzare il modificatore nocase dopo le stringhe per indicare che la ricerca deve ignorare le lettere maiuscole. Di seguito è riportata una rappresentazione generica di questa sintassi: re.regex($e.field, `regex`)

Nella definizione di YARA-L 2.0, tieni presente quanto segue durante la definizione delle espressioni regolari:

• In entrambi i casi, il predicato è vero se la stringa contiene una sottostringa che corrisponde all'espressione regolare specificata. Non è necessario aggiungere .* all'inizio o alla fine dell'espressione regolare.
• Per creare una corrispondenza con la stringa esatta o solo con un prefisso o un suffisso, includi i caratteri di ancoraggio ^ (iniziale) e $ (fine) nell'espressione regolare. Ad esempio, /^full$/ corrisponde esattamente a "full", mentre /full/ potrebbe corrispondere a "fullest", "lawfull" e "joyfully".
• Se il campo UDM include caratteri di nuova riga, regexp corrisponde solo alla prima riga del campo UDM. Per applicare la corrispondenza completa del campo UDM, aggiungi (?s) all'espressione regolare. Ad esempio, sostituisci /.*allUDM.*/ con /(?s).*allUDM.*/.

Acquisizione espressione regolare

Acquisisce (estrae) i dati da una stringa utilizzando il pattern dell'espressione regolare specificato nell'argomento.

re.capture(stringText, regex)

Questa funzione accetta due argomenti:

• stringText: la stringa originale da cercare.
• regex: l'espressione regolare che indica il pattern da cercare.

L'espressione regolare può contenere 0 o 1 gruppo Capture tra parentesi. Se l'espressione regolare contiene 0 gruppi Capture, la funzione restituisce la prima sottostringa corrispondente. Se l'espressione regolare contiene 1 gruppo Capture, restituisce la prima sottostringa corrispondente per il gruppo Capture. La definizione di due o più gruppi di acquisizione restituisce un errore di compilazione.

In questo esempio, se $e.principal.hostname contiene "aaa1bbaa2", quanto segue è True, perché la funzione restituisce la prima istanza. Questo esempio non ha gruppi di acquisizione.

"aaa1" = re.capture($e.principal.hostname, "a+[1-9]")

Questo esempio mostra tutto ciò che segue il simbolo @ in un'email. Se il campo $e.network.email.from è [e-mail], l'esempio restituisce google.com. Questo esempio contiene un gruppo Capture.

"google.com" = re.capture($e.network.email.from , "@(.*)")

Se l'espressione regolare non corrisponde a nessuna sottostringa nel testo, la funzione restituisce una stringa vuota. Puoi omettere gli eventi in cui non si verifica alcuna corrispondenza escludendo la stringa vuota, cosa particolarmente importante quando utilizzi re.capture() con disuguaglianza:

// Exclude the empty string to omit events where no match occurs.
"" != re.capture($e.network.email.from , "@(.*)")

// Exclude a specific string with an inequality.
"google.com" != re.capture($e.network.email.from , "@(.*)")

Sostituzione RegExp

Esegue una sostituzione delle espressioni regolari.

re.replace(stringText, replaceRegex, replacementText)

Questa funzione prevede tre argomenti:

• stringText: la stringa originale.
• replaceRegex: l'espressione regolare che indica il pattern da cercare.
• sostitutiviText: il testo da inserire in ogni corrispondenza.

Restituisce una nuova stringa derivata dal stringText originale, in cui tutte le sottostringhe che corrispondono al pattern in replaceRegex vengono sostituite con il valore inreplacementText. Puoi utilizzare cifre precedute da una barra rovesciata (da \1 a \9) in replacementText per inserire il testo che corrisponde al gruppo racchiuso tra parentesi nel pattern replaceRegex. Utilizza \0 per fare riferimento all'intero testo corrispondente.

La funzione sostituisce le corrispondenze non sovrapposte e darà la priorità alla prima occorrenza trovata. Ad esempio, re-replace("banana", "ana", "111") restituisce la stringa "b111na".

Questo esempio mostra tutto ciò che segue il simbolo @ in un'email, sostituisce com con org e restituisce il risultato. Nota l'utilizzo di funzioni nidificate.

"[e-mail]" = re.replace($e.network.email.from, "com", "org")

Questo esempio utilizza cifre precedute da una barra rovesciata nell'argomento replaceText per fare riferimento a corrispondenze con il pattern replaceRegex.

"test1.com.google" = re.replace(
                       $e.principal.hostname, // holds "test1.test2.google.com"
                       "test2\.([a-z]*)\.([a-z]*)",
                       "\\2.\\1"  // \\1 holds "google", \\2 holds "com"
                     )

Tieni presente i seguenti casi quando hai a che fare con stringhe vuote e re.replace():

Utilizzo della stringa vuota come replaceRegex:

// In the function call below, if $e.principal.hostname contains "name",
// the result is: 1n1a1m1e1, because an empty string is found next to
// every character in `stringText`.
re.replace($e.principal.hostname, "", "1")

Per sostituire una stringa vuota, puoi utilizzare "^$" come replaceRegex:

// In the function call below, if $e.principal.hostname contains the empty
// string, "", the result is: "none".
re.replace($e.principal.hostname, "^$", "none")

Funzioni di data

Chronicle supporta le seguenti funzioni correlate alle date:

• timestamp.get_minute(unix_seconds [, time_zone])
• timestamp.get_hour(unix_seconds [, time_zone])
• timestamp.get_day_of_week(unix_seconds [, time_zone])
• timestamp.get_week(unix_seconds [, time_zone])
• timestamp.current_seconds()

Chronicle supporta numeri interi negativi come argomento unix_seconds. I numeri interi negativi indicano i tempi precedenti al periodo Unix. Se fornisci un numero intero non valido, ad esempio un valore che determina un overflow, la funzione restituirà -1. Questo è uno scenario insolito.

Poiché YARA-L 2 non supporta i valori letterali interi negativi, assicurati di controllare questa condizione utilizzando l'operatore "inferiore o maggiore di" Ad esempio:

0 > timestamp.get_hour(123)

Estrazione temporale

Restituisce un numero intero compreso nell'intervallo [0, 59].

timestamp.get_minute(unix_seconds [, time_zone])

La seguente funzione restituisce un numero intero nell'intervallo [0, 23], che rappresenta l'ora del giorno.

timestamp.get_hour(unix_seconds [, time_zone])

La seguente funzione restituisce un numero intero nell'intervallo [1, 7] che rappresenta il giorno della settimana che inizia con domenica. Ad esempio, 1 = domenica; 2 = lunedì e così via.

timestamp.get_day_of_week(unix_seconds [, time_zone])

La seguente funzione restituisce un numero intero nell'intervallo [0, 53] che rappresenta la settimana dell'anno. Le settimane iniziano con la domenica. Le date precedenti alla prima domenica dell'anno sono nella settimana 0.

timestamp.get_week(unix_seconds [, time_zone])

Queste funzioni di estrazione temporale hanno gli stessi argomenti.

• unix_seconds è un numero intero che rappresenta il numero di secondi oltre l'epoca Unix, ad esempio $e.metadata.event_timestamp.seconds, o un segnaposto contenente tale valore.
• time_zone è facoltativo ed è una stringa che rappresenta un time_zone. Se omesso, il valore predefinito è "GMT". Puoi specificare i fusi orari utilizzando le stringhe di valori letterali. Le opzioni sono:
  • Il nome del database TZ, ad esempio "America/Los_Angeles". Per ulteriori informazioni, consulta la colonna "Database TZ" di questa pagina
  • L'offset del fuso orario da UTC, nel formato (+|-)H[H][:M[M]], ad esempio "-08:00".

In questo esempio l'argomento time_zone viene omesso, pertanto viene utilizzato il valore predefinito "GMT".

$ts = $e.metadata.collected_timestamp.seconds

timestamp.get_hour($ts) = 15

In questo esempio viene utilizzato un valore letterale di stringa per definire il fuso orario.

$ts = $e.metadata.collected_timestamp.seconds

2 = timestamp.get_day_of_week($ts, "America/Los_Angeles")

Ecco alcuni esempi di altri specificatori di time_zone validi, che puoi trasmettere come secondo argomento per le funzioni di estrazione del tempo:

• "America/Los_Angeles" o "-08:00". ("PST" non è supportato)
• "America/New_York" o "-05:00". ("EST" non è supportato)
• "Europe/London"
• "UTC"
• "GMT"

Timestamp corrente

Restituisce un numero intero che rappresenta l'ora corrente in secondi Unix. Questo valore è quasi uguale al timestamp di rilevamento e si basa sull'esecuzione della regola.

timestamp.current_seconds()

L'esempio seguente restituisce True se il certificato è scaduto da più di 24 ore. Calcola la differenza di tempo sottraendo gli attuali secondi Unix e poi eseguendo un confronto utilizzando un operatore maggiore di.

86400 < timestamp.current_seconds() - $e.network.tls.certificate.not_after

Funzioni matematiche

Valore assoluto

Restituisce il valore assoluto di un'espressione intera.

math.abs(intExpression)

Questo esempio restituisce True se l'evento è trascorso più di 5 minuti dall'ora specificata (in secondi dall'epoca Unix), indipendentemente dal fatto che l'evento si sia verificato prima o dopo l'ora specificata. Una chiamata al numero math.abs non può dipendere da più variabili o segnaposto. Ad esempio, non puoi sostituire il valore temporale hardcoded di 1643687343 nell'esempio seguente con $e2.metadata.event_timestamp.seconds.

300 < math.abs($e1.metadata.event_timestamp.seconds - 1643687343)

Funzioni di rete

Ricerca subnet IP

Restituisce true quando l'indirizzo IP specificato si trova all'interno della subnet specificata.

net.ip_in_range_cidr(ipAddress, subnetworkRange)

Puoi utilizzare YARA-L per cercare eventi UDM in tutti gli indirizzi IP all'interno di una subnet utilizzando l'istruzione net.ip_in_range_cidr(). IPv4 e IPv6 sono supportati.

Per eseguire la ricerca in un intervallo di indirizzi IP, specifica un campo IP UDM e un intervallo Classless Inter-Domain Routing (CIDR). YARA-L può gestire campi di indirizzi IP sia singoli sia ripetuti.

Esempio IPv4:

net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")

Esempio IPv6:

net.ip_in_range_cidr($e.network.dhcp.yiaddr, "2001:db8::/32")

Per un esempio di regola che utilizza l'istruzione net.ip_in_range_cidr(), consulta la regola di esempio. Singolo evento nell'intervallo di indirizzi IP

Funzione da assegnare all'assegnazione segnaposto

Puoi assegnare il risultato di una chiamata funzione a un segnaposto nella sezione events. Ad esempio:

$placeholder = strings.concat($e.principal.hostname, "my-string").

Puoi quindi utilizzare le variabili segnaposto nelle sezioni match, condition e outcome. Tuttavia, esistono due limitazioni per l'assegnazione di funzioni a segnaposto:

1. Ogni segnaposto in funzione dell'assegnazione segnaposto deve essere assegnato a un'espressione contenente un campo evento. Ad esempio, i seguenti esempi sono validi:

   $ph1 = $e.principal.hostname
   $ph2 = $e.src.hostname
   
   // Both $ph1 and $ph2 have been assigned to an expression containing an event field.
   $ph1 = strings.concat($ph2, ".com")
   

   $ph1 = $e.network.email.from
   $ph2 = strings.concat($e.principal.hostname, "@gmail.com")
   
   // Both $ph1 and $ph2 have been assigned to an expression containing an event field.
   $ph1 = strings.to_lower($ph2)
   

   Tuttavia, l'esempio riportato di seguito non è valido:

   $ph1 = strings.concat($e.principal.hostname, "foo")
   $ph2 = strings.concat($ph1, "bar") // $ph2 has NOT been assigned to an expression containing an event field.
   

2. La chiamata a funzione deve dipendere da un solo evento. Tuttavia, negli argomenti della chiamata funzione è possibile utilizzare più di un campo dello stesso evento. Ad esempio, quanto segue è valido:

   $ph = strings.concat($event.principal.hostname, "string2")

   $ph = strings.concat($event.principal.hostname, $event.src.hostname)

   Tuttavia, quanto segue non è valido:

   $ph = strings.concat("string1", "string2")

   $ph = strings.concat($event.principal.hostname, $anotherEvent.src.hostname)

Sintassi degli elenchi di riferimento

Consulta la nostra pagina sugli elenchi di riferimenti per ulteriori informazioni sul comportamento degli elenchi di riferimento e sulla relativa sintassi.

Puoi utilizzare gli elenchi di riferimento nelle sezioni events o outcome. Di seguito è riportata la sintesi relativa all'utilizzo di vari tipi di elenchi di riferimenti in una regola:

// STRING reference list
$e.principal.hostname in %string_reference_list

// REGEX reference list
$e.principal.hostname in regex %regex_reference_list

// CIDR reference list
$e.principal.ip in cidr %cidr_reference_list

Puoi anche utilizzare l'operatore not con gli elenchi di riferimento, come mostrato qui: not $e.principal.hostname in regex %my_regex_list.

Per motivi legati alle prestazioni, il motore di rilevamento limita l'utilizzo dell'elenco di riferimenti. In una regola puoi utilizzare fino a sette istruzioni in e nella stessa regola più tipi di istruzioni in. Al massimo 2 delle 7 istruzioni in possono utilizzare gli operatori speciali regex o cidr.

L'operatore nocase non funziona con gli elenchi di riferimento. L'inserimento di nocase dopo una chiamata di elenco di riferimento non ha alcun effetto e non è consigliato.

Sintassi della meta sezione

La sezione delle meta è composta da più righe, dove ogni riga definisce una coppia chiave-valore. Una parte della chiave deve essere una stringa senza virgolette, mentre una parte del valore deve essere una stringa tra virgolette:

<key> = "<value>"

Di seguito è riportato un esempio di riga di sezione meta valida: meta: author = "Chronicle" severity = "HIGH"

Sintassi della sezione Eventi

Nella sezione events, elenca i predicati per specificare quanto segue:

• Significato di ogni variabile corrispondente o segnaposto
• Espressioni binarie semplici come condizioni
• Espressione di funzioni come condizioni
• Espressioni elenco di riferimento come condizioni
• Operatori logici

Dichiarazioni delle variabili

Per le dichiarazioni delle variabili, utilizza la seguente sintassi:

• <EVENT_FIELD> = <VAR>
• <VAR> = <EVENT_FIELD>

Entrambi sono equivalenti, come mostrato negli esempi seguenti:

• $e.source.hostname = $hostname
• $userid = $e.principal.user.userid

Questa dichiarazione indica che questa variabile rappresenta il campo specificato per la variabile evento. Se il campo evento è ripetuto, la variabile di corrispondenza può rappresentare qualsiasi valore nella matrice. È anche possibile assegnare più campi evento a una singola corrispondenza o variabile segnaposto. Questa è una condizione di unione transitiva.

Ad esempio:

• $e1.source.ip = $ip
• $e2.target.ip = $ip

Equivale a:

• $e1.source.ip = $ip
• $e1.source.ip = $e2.target.ip

Quando viene utilizzata, una variabile deve essere dichiarata tramite dichiarazione della variabile. Se una variabile viene utilizzata senza dichiarazione, viene considerata come un errore di compilazione.

Espressioni binarie semplici come condizioni

Per utilizzare una semplice espressione binaria come condizione, utilizza la seguente sintassi:

• <EXPR> <OP> <EXPR>

L'espressione può essere un evento, una variabile, un valore letterale o un'espressione di funzione.

Ad esempio:

• $e.source.hostname = "host1234"
• $e.source.port < 1024
• 1024 < $e.source.port
• $e1.source.hostname != $e2.target.hostname
• $e1.metadata.collected_timestamp.seconds > $e2.metadata.collected_timestamp.seconds
• $port >= 25
• $host = $e2.target.hostname
• "google-test" = strings.concat($e.principal.hostname, "-test")
• "[e-mail]" = re.replace($e.network.email.from, "com", "org")

Se entrambi i lati sono valori letterali, è considerato un errore di compilazione.

Espressione di funzioni come condizioni

Alcune espressioni di funzione restituiscono un valore booleano, che può essere utilizzato come singolo predicato nella sezione events. Tali funzioni sono:

• re.regex()
• net.ip_in_range_cidr()

Ad esempio:

• re.regex($e.principal.hostname, `.*\.google\.com`)
• net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")

Espressioni elenco di riferimento come condizioni

Puoi utilizzare gli elenchi di riferimento nella sezione Eventi. Per ulteriori dettagli, consulta la sezione Elenchi di riferimento.

Operatori logici

Puoi utilizzare gli operatori logici and e or logici nella sezione events, come mostrato nei seguenti esempi:

• $e.metadata.event_type = "NETWORK_DNS" or $e.metadata.event_type = "NETWORK_DHCP"
• ($e.metadata.event_type = "NETWORK_DNS" and $e.principal.ip = "192.0.2.12") or ($e.metadata.event_type = "NETWORK_DHCP" and $e.principal.mac = "AB:CD:01:10:EF:22")
• not $e.metadata.event_type = "NETWORK_DNS"

Per impostazione predefinita, l'ordine di precedenza dal più alto al più basso è not, and, or.

Ad esempio, "a or b and c" viene valutato come "a or (b and c)". Puoi utilizzare le parentesi per modificare la precedenza, se necessario.

Nella sezione events, tutti i predicati sono considerati andper impostazione predefinita.

Nota: esiste un limite al numero di valori and e or che puoi specificare per una singola regola. Questo limite varia a seconda della complessità della regola e della complessità dei dati nell'account Chronicle. Contatta il tuo rappresentante Chronicle per informazioni sulle alternative a questo tipo di regola.

Operatori negli eventi

Puoi utilizzare gli operatori con i tipi enumerati. Può essere applicato alle regole per semplificare e ottimizzare il rendimento (utilizza l'operatore anziché gli elenchi di riferimento).

Nell'esempio seguente, "USER_UNCATEGORIZED" e "USER_RESOURCE_DELETION" corrispondono a 15000 e 15014, pertanto la regola cercherà tutti gli eventi elencati:

$e.metadata.event_type >= "USER_CATEGORIZED" and $e.metadata.event_type <= "USER_RESOURCE_DELETION"

Elenco di eventi:

• DELEZIONE_UTENTE_RISORSA
• USER_RESOURCE_UPDATE_CONTENT
• AUTORIZZAZIONI_AGGIORNAMENTO_RISORSE_UTENTE
• STATISTICHE UTENTE
• USER_UNCATEGORIZED

Modificatori

Nocase

Quando hai un'espressione di confronto tra valori di stringhe o un'espressione regolare, puoi aggiungere nocase alla fine dell'espressione per ignorare le lettere maiuscole.

• $e.principal.hostname != "http-server" nocase
• $e1.principal.hostname = $e2.target.hostname nocase
• $e.principal.hostname = /dns-server-[0-9]+/ nocase
• re.regex($e.target.hostname, `client-[0-9]+`) nocase

Non può essere utilizzato quando un tipo di campo è un valore enumerato. Gli esempi riportati di seguito sono non validi e genereranno errori di compilazione:

• $e.metadata.event_type = "NETWORK_DNS" nocase
• $e.network.ip_protocol = "TCP" nocase

Campi ripetuti

tutti, tutti

In UDM e nelle entità, alcuni campi sono etichettati come ripetuti, il che significa che sono elenchi di valori o altri tipi di messaggi. In YARA-L, ogni elemento nel campo ripetuto viene trattato singolarmente. Ciò significa che la regola per il campo ripetuto viene valutata per ogni elemento del campo. Ciò può causare un comportamento imprevisto. Ad esempio, se una regola ha sia $e.principal.ip = "1.2.3.4" che $e.principal.ip = "5.6.7.8" nella sezione events, la regola non genera mai corrispondenze, anche se "1.2.3.4" e "5.6.7.8" si trovano in principal.ip.

Per valutare il campo ripetuto nel suo complesso, puoi utilizzare gli operatori any e all. Quando si utilizza any, il predicato viene valutato come vero se un valore nel campo ripetuto soddisfa la condizione. Quando si utilizza all, il predicato viene valutato come vero se tutti i valori nel campo ripetuto soddisfano la condizione.

• any $e.target.ip = "127.0.0.1"
• all $e.target.ip != "127.0.0.1"
• re.regex(any $e.about.hostname, `server-[0-9]+`)
• net.ip_in_range_cidr(all $e.principal.ip, "10.0.0.0/8")

Gli operatori any e all possono essere utilizzati solo con i campi ripetuti. Inoltre, non possono essere utilizzati quando si assegna un campo ripetuto a una variabile segnaposto o quando si unisce a un altro evento.

Ad esempio, sintassi non valida per any $e.principal.ip = $ip e any $e1.principal.ip = $e2.principal.ip. Per trovare una corrispondenza o partecipare a un campo ripetuto, utilizza $e.principal.ip = $ip. Sarà presente un solo valore di corrispondenza o join per ciascun elemento del campo ripetuto.

Quando scrivi una condizione con any o all, tieni presente che trascurare la condizione con not potrebbe non avere lo stesso significato di utilizzare l'operatore negato.

Ad esempio:

• not all $e.principal.ip = "192.168.12.16" verifica se non tutti gli indirizzi IP corrispondono a "192.168.12.16", il che significa che la regola sta controllando se qualche indirizzo IP non corrisponde a "192.168.12.16".
• all $e.principal.ip != "192.168.12.16" verifica se tutti gli indirizzi IP non corrispondono a "192.168.12.16", il che significa che la regola sta controllando che nessun indirizzo IP corrisponda a "192.168.12.16".

Nota: gli operatori any e all non sono ancora supportati nell'espressione di elenco di riferimento.

Requisiti di unione di variabili evento

Tutte le variabili di evento utilizzate nella regola devono essere unite a ogni altra variabile di evento in uno dei seguenti modi:

• direttamente tramite un confronto dell'uguaglianza tra i campi evento delle due variabili evento unite, ad esempio $e1.field = $e2.field. L'espressione non deve includere chiamate aritmetiche o di funzione.

• indirettamente tramite un join transitivo che riguarda solo un campo evento (consulta la dichiarazione di variabile per la definizione di "join transitive"). L'espressione non deve includere chiamate aritmetiche o di funzione.

Ad esempio, supponendo che $e1, $e2 e $e3 vengano utilizzati nella regola, le seguenti sezioni events sono valide.

events:
  $e1.principal.hostname = $e2.src.hostname // $e1 joins with $e2
  $e2.principal.ip = $e3.src.ip // $e2 joins with $e3

events:
  // all of $e1, $e2 and $e3 are transitively joined via the placeholder variable $ip
  $e1.src.ip = $ip
  $e2.target.ip = $ip
  $e3.about.ip = $ip

events:
  $e1.principal.hostname = $e2.src.hostname // $e1 joins with $e2

  // Function to event comparison is not a valid join condition for $e1 and $e2,
  // but the whole events section is valid because we have a valid join condition in the first line.
  re.capture($e1.src.hostname, ".*") = $e2.target.hostname

Tuttavia, ecco alcuni esempi di sezioni events non valide.

events:
  // Event to function comparison is an invalid join condition for $e1 and $e2.
  $e1.principal.hostname = re.capture($e2.principal.application, ".*")

events:
  // Event to arithmetic comparison is an invalid join condition for $e1 and $e2.
  $e1.principal.port = $e2.src.port + 1

events:
  $e1.src.ip = $ip
  $e2.target.ip = $ip
  $e3.about.ip = "192.1.2.0" //$e3 is not joined with $e1 or $e2.

events:
  $e1.src.ip = $ip

  // Function to placeholder comparison is an invalid transitive join condition.
  re.capture($e2.target.ip, ".*") = $ip

events:
  $e1.src.port = $port

  // Arithmetic to placeholder comparison is an invalid transitive join condition.
  $e2.principal.port + 800 = $port

Sintassi della sezione delle corrispondenze

Nella sezione match, elenca le variabili di corrispondenza per gli eventi del gruppo prima di verificare le condizioni di corrispondenza. Questi campi vengono restituiti a ogni corrispondenza.

• Specifica cosa rappresenta ogni variabile di corrispondenza nella sezione events.
• Specifica l'intervallo di tempo da utilizzare per mettere in relazione gli eventi dopo la parola chiave over. Gli eventi che non rientrano nell'intervallo di tempo vengono ignorati.
• Per specificare l'intervallo di tempo, utilizza la seguente sintassi: <number><s/m/h/d> Dove s/m/h/d indica rispettivamente secondi, minuti, ore e giorni.
• Il tempo minimo che puoi specificare è 1 minuto.
• Il tempo massimo che puoi specificare è 48 ore.

Di seguito è riportato un esempio di match valido:

$var1, $var2 over 5m

Questa istruzione restituisce $var1 e $var2 (definita nella sezione events) quando la regola trova una corrispondenza. Il tempo specificato è di 5 minuti. Gli eventi che si trovano a più di 5 minuti di distanza non sono correlati e pertanto vengono ignorati dalla regola.

Ecco un altro esempio di match valido:

$user over 1h

Questa istruzione restituisce $user quando la regola trova una corrispondenza. La finestra temporale specificata è di 1 ora. Gli eventi che si trovano a più di un'ora di distanza non sono correlati. La regola non li considera un rilevamento.

Ecco un altro esempio di match valido:

$source_ip, $target_ip, $hostname over 2m

Questa istruzione restituisce $source_ip, $target_ip e $hostname quando la regola trova una corrispondenza. Il periodo di tempo specificato è di 2 minuti. Gli eventi che si trovano a più di due minuti di distanza non sono correlati. La regola non li considera un rilevamento.

Gli esempi seguenti illustrano le sezioni match non valide:

• var1, var2 over 5m // invalid variable name
• $user 1h // missing keyword

Finestra scorrevole

Per impostazione predefinita, le regole YARA-L 2.0 vengono valutate utilizzando le finestre di hop. Un intervallo di tempo dei dati degli eventi aziendali è suddiviso in un insieme di finestre di hop sovrapposte, ciascuna con la durata specificata nella sezione match. Gli eventi vengono quindi correlati all'interno di ogni finestra di hop. Con le finestre di hop, è impossibile cercare eventi che si verificano in un ordine specifico (ad esempio, e1 si verifica fino a 2 minuti dopo e2). Un'occorrenza dell'evento e1 e un'occorrenza dell'evento e2 sono correlate purché siano presenti nella durata dell'evento dell'hop dell'altro.

Le regole possono essere valutate anche utilizzando finestre scorrevoli. Nel caso di finestre scorrevoli, le finestre scorrevoli con la durata specificata nella sezione match vengono generate all'inizio o alla fine con una variabile evento pivot specificata. Gli eventi sono quindi correlati all'interno di ogni finestra scorrevole. In questo modo è possibile cercare gli eventi che si verificano in un ordine specifico (ad esempio, e1 si verifica entro 2 minuti da e2). Un evento e1 e un evento e2 sono correlati se l'evento e1 si verifica entro la durata della finestra temporale successiva all'evento e2.

Specifica le finestre scorrevoli nella sezione match di una regola come segue:

<match-var-1>, <match-var-2>, ... over <duration> before|after <pivot-event-var>

La variabile evento pivot è la variabile evento su cui si basano le finestre scorrevoli. Se utilizzi la parola chiave before, vengono generate finestre scorrevoli che terminano con ogni occorrenza dell'evento pivot. Se viene utilizzata la parola chiave after, vengono generate finestre scorrevoli a partire da ogni occorrenza dell'evento pivot.

Di seguito sono riportati esempi di utilizzo validi di finestre scorrevoli:

• $var1, $var2 over 5m after $e1
• $user over 1h before $e2

Nota: è noto che l'utilizzo di finestre scorrevoli anziché finestre di hop risulta più lento. Google consiglia di utilizzare le finestre scorrevoli solo per casi specifici, ad esempio quando l'ordine degli eventi è assolutamente necessario o quando si cerca la non esistenza di eventi.

Sintassi della sezione dei risultati

Nella sezione outcome puoi definire fino a 20 variabili di risultato, con nomi arbitrari. Questi risultati verranno archiviati nei rilevamenti generati dalla regola. Ogni rilevamento può avere valori diversi per i risultati.

Il nome del risultato, $risk_score, è speciale. Facoltativamente, puoi definire un risultato con questo nome e, in tal caso, deve essere un tipo intero. Se completato, il valore risk_score verrà mostrato nella vista Approfondimenti aziendali per gli avvisi generati dal rilevamento delle regole.

Tipi di dati delle variabili di risultato

Ogni variabile di risultato può avere un tipo di dati diverso, che è determinato dall'espressione utilizzata per calcolarla. Sono supportati i seguenti tipi di dati sui risultati:

• integer
• string
• elenchi di numeri interi
• elenchi di stringhe

Logica condizionale

Puoi usare la logica condizionale per calcolare il valore di un risultato. I condizionali sono specificati utilizzando il seguente pattern di sintassi:

if(BOOL_CLAUSE, THEN_CLAUSE)
if(BOOL_CLAUSE, THEN_CLAUSE, ELSE_CLAUSE)

Puoi leggere un'espressione condizionale come "se BOOL_CLAUSE è vera, quindi restituire THEN_CLAUSE, altrimenti restituire ELSE_CLAUSE".

BOOL_CLAUSE deve restituire un valore booleano. Un'espressione BOOL_CLAUSE ha una forma simile a quella della sezione events. Ad esempio, può contenere:

• Nomi dei campi UDM con operatore di confronto, ad esempio:

  if($context.graph.entity.user.title = "Vendor", 100, 0)

• una variabile segnaposto definita nella sezione events, ad esempio:

  if($severity = "HIGH", 100, 0)

• che restituiscono un valore booleano, ad esempio:

  if(re.regex($e.network.email.from, .*altostrat\.com), 100, 0)

• Cerca in un elenco di riferimento, ad esempio:

  if($u.principal.hostname in %my_reference_list_name, 100, 0)

I valori THEN_CLAUSE ed ELSE_CLAUSE devono essere dello stesso tipo di dati. Supportiamo numeri interi e stringhe.

Puoi omettere l'ELSE_CLAUSE se il tipo di dati è un numero intero. Se omesso, ELSE_CLAUSE restituisce 0. Ad esempio:

`if($e.field = "a", 5)` is equivalent to `if($e.field = "a", 5, 0)`

È necessario fornire ELSE_CLAUSE se il tipo di dati è string.

Operazioni matematiche

Puoi utilizzare le operazioni matematiche per calcolare i risultati dei tipi di dati interi. Supportiamo l'aggiunta e la sottrazione (ma non la moltiplicazione, la divisione o il modulo) come operatori di primo livello in un calcolo dei risultati. Ad esempio:

outcome:
  $risk_score = max(100 + if($severity = "HIGH", 10, 5) - if($severity = "LOW", 20, 0))

Variabili segnaposto nei risultati

Quando calcoli le variabili di risultato, puoi utilizzare le variabili segnaposto definite nella sezione eventi della regola. In questo esempio, supponiamo che $email_sent_bytes sia stato definito nella sezione degli eventi della regola:

Esempio di evento singolo:

// No match section, so this is a single-event rule.

outcome:
  // Use placeholder directly as an outcome value.
  $my_outcome = $email_sent_bytes

  // Use placeholder in a conditional.
  $other_outcome = if($file_size > 1024, "SEVERE", "MODERATE")

condition:
  $e

Esempio di più eventi:

match:
  // This is a multi event rule with a match section.
  $hostname over 5m

outcome:
  // Use placeholder directly in an aggregation function.
  $max_email_size = max($email_sent_bytes)

  // Use placeholder in a mathematical computation.
  $total_bytes_exfiltrated = sum(
    1024
    + $email_sent_bytes
    + $file_event.principal.file.size
  )

condition:
  $email_event and $file_event

Aggregazioni

La sezione dei risultati può essere utilizzata nelle regole per più eventi (regole che contengono una sezione con corrispondenza) e nelle regole per un singolo evento (regole che non contengono una sezione con corrispondenza). I requisiti per le aggregazioni sono i seguenti:

• Regole per più eventi (con sezione Corrispondenza)

  • L'espressione per i risultati di calcolo viene valutata per tutti gli eventi che hanno generato un particolare rilevamento.
  • L'espressione deve essere aggregata in una funzione aggregata
    • Esempio: $max_email_size = max($e.network.sent_bytes)
    • Se l'espressione contiene un campo ripetuto, l'aggregato opera su tutti gli elementi nel campo ripetuto, su tutti gli eventi che hanno generato il rilevamento.

• Regole per evento singolo (senza sezione delle corrispondenze)

  • L'espressione dei risultati di calcolo viene valutata per il singolo evento che ha generato un determinato rilevamento.
  • È necessario utilizzare la funzione aggregata per le espressioni che coinvolgono almeno un campo ripetuto
    • Esempio: $suspicious_ips = array($e.principal.ip)
    • L'aggregazione opera su tutti gli elementi nel campo ripetuto
  • Non è possibile utilizzare la funzione di aggregazione per le espressioni che non prevedono un campo ripetuto
    • Esempio: $threat_status = if($e.principal.file.size > 1024, "SEVERE", "MODERATE")

Puoi utilizzare le seguenti funzioni di aggregazione:

• max(): restituisce il valore massimo su tutti i valori possibili. Compatibile solo con numeri interi.
• min(): restituisce il valore minimo in tutti i valori possibili. Compatibile solo con numeri interi.
• sum(): restituisce la somma di tutti i valori possibili. Compatibile solo con numeri interi.
• count_distinct(): raccoglie tutti i valori possibili, quindi restituisce il conteggio distinto dei valori possibili.
• count(): si comporta come count_distinct(), ma restituisce un numero non distinto di valori possibili.
• array_distinct(): raccoglie tutti i valori possibili, quindi genera un elenco di questi valori. Troncherà l'elenco dei valori a 25 elementi casuali.
• array(): si comporta come array_distinct(), ma restituisce un elenco di valori non distinto. Inoltre, tronca l'elenco dei valori a 25 elementi casuali.

La funzione aggregata è importante quando una regola include una sezione condition che specifica più eventi, perché la funzione aggregata funzionerà a tutti gli eventi che hanno generato il rilevamento.

Ad esempio, se le sezioni outcome e condition contengono:

outcome:
  $asset_id_count = count($event.principal.asset_id)
  $asset_id_distinct_count = count_distinct($event.principal.asset_id)

  $asset_id_list = array($event.principal.asset_id)
  $asset_id_distinct_list = array_distinct($event.principal.asset_id)

condition:
  #event > 1

Poiché la sezione della condizione richiede che sia presente più di un event per ogni rilevamento, le funzioni aggregate operano su più eventi. Supponiamo che i seguenti eventi abbiano generato un rilevamento:

event:
  // UDM event 1
  asset_id="asset-a"

event:
  // UDM event 2
  asset_id="asset-b"

event:
  // UDM event 3
  asset_id="asset-b"

I valori dei risultati saranno quindi:

• $asset_id_count = 3
• $asset_id_distinct_count = 2
• $asset_id_list = ["asset-a", "asset-b", "asset-b"]`
• $asset_id_distinct_list = ["asset-a", "asset-b"]

Aspetti da considerare quando si utilizza la sezione dei risultati:

Altre note e limitazioni:

• La sezione outcome non può fare riferimento a una nuova variabile segnaposto che non era già stata definita nella sezione events.
• La sezione outcome non può utilizzare le variabili evento che non sono state definite nella sezione events.
• La sezione outcome può utilizzare un campo evento che non è stato utilizzato nella sezione events, dato che la variabile evento a cui appartiene il campo evento è già stata definita nella sezione events.
• La sezione outcome può mettere in correlazione solo le variabili evento che sono già state correlate nella sezione events. Le correlazioni si verificano quando vengono equiparati due campi evento di variabili evento diverse.

Puoi trovare un esempio utilizzando la sezione dei risultati in Panoramica di YARA-L 2.0. Consulta Creare analisi sensibili al contesto per i dettagli sul provisioning con la sezione dei risultati.

Sintassi della sezione Condizione

Nella sezione condition puoi:

• specifica una condizione di corrispondenza per gli eventi e i segnaposto definiti nella sezione events. Per ulteriori dettagli, consulta la sezione Condizioni degli eventi e dei segnaposto.
• (Facoltativo) Utilizza la parola chiave and per specificare una condizione di corrispondenza utilizzando le variabili dei risultati definite nella sezione outcome. Per ulteriori dettagli, consulta la sezione Condizionali dei risultati.

I seguenti pattern di condizioni sono validi:

condition:
  <event/placeholder conditionals>

condition:
  <event/placeholder conditionals> and <outcome conditionals>

Condizionali eventi e segnaposto

Elenca i predicati di condizioni per eventi e variabili segnaposto qui, uniti alla parola chiave and o or.

Nota: non utilizzare la parola chiave not negli elementi evento e segnaposto.

Le seguenti condizioni sono associate a condizioni di delimitazione. Imponeno l'esistenza della variabile evento associata, il che significa che in qualsiasi rilevamento deve comparire almeno un'occorrenza dell'evento.

• $var // equivalent to #var > 0
• #var > n // where n >= 0
• #var >= m // where m > 0

Le seguenti condizioni non sono vincolanti. Consentono alla variabile di evento associata di non esistere, il che significa che è possibile che non venga rilevata alcuna occorrenza dell'evento. Ciò consente di creare regole di inesistenza, che cercano l'assenza di una variabile anziché la presenza di una variabile.

Nota: per le regole non esistenti (regole che contengono !$e o #e = 0 nella sezionecondition), il motore di rilevamento aggiunge un ritardo di +1 ora alla latenza prevista (in base alla frequenza di esecuzione della regola) per consentire l'arrivo di dati in ritardo.

• !$var // equivalent to #var = 0
• #var >= 0
• #var < n // where n > 0
• #var <= m // where m >= 0

Nell'esempio seguente, il carattere speciale # in una variabile (la variabile evento o la variabile segnaposto) rappresenta il conteggio di eventi o valori distinti di quella variabile.

$e and #port > 50 or #event1 > 2 or #event2 > 1 or #event3 > 0

Anche il seguente esempio di inesistenza è valido e restituisce true se sono presenti più di due eventi distinti da $event1 e zero eventi distinti da $event2.

#event1 > 2 and !$event2

Nota: non utilizzare una variabile match nella sezione condition. Si tratta di un errore semantico poiché gli eventi vengono raggruppati in base al valore della variabile match.

Nota: non specificare solo le condizioni non di limitazione in tutte le event variabili a cui è assegnata una variabile match. È un errore semantico. Affinché venga restituito un valore della variabile match, deve esistere almeno un evento contenente il valore.

Nota: nel caso si utilizzi una finestra scorrevole, la variabile evento pivot deve essere coinvolta in almeno una condizione di delimitazione.

Di seguito sono riportati esempi di predicati non validi:

• $e, #port > 50 // incorrect keyword usage
• $e or #port < 50 // or keyword not supported with non-bounding conditions
• not $e // not keyword is not allowed for event and placeholder conditions

Condizionali dei risultati

Elenca i predicati per le variabili dei risultati qui, uniti alla parola chiave and o or o preceduti dalla parola chiave not.

Specifica le condizioni dei risultati in modo diverso a seconda del tipo di variabile di risultato:

• numero intero: esegui il confronto con un valore letterale intero con gli operatori =, >, >=, <, <=, !=, ad esempio:

  $risk_score > 10

• stringa: esegui il confronto con il valore letterale di una stringa con = o !=, ad esempio:

  $severity = "HIGH"

• elenco di numeri interi o array: specifica la condizione utilizzando la funzione arrays.contains, ad esempio:

  arrays.contains($event_ids, "id_1234")

Nota: se utilizzi la parola chiave or nella sottosezione <condizioni evento/segnaposto>, devi racchiudere l'intera sottosezione tra parentesi. Ad esempio, quanto segue è valido: ($e1 or $e2) and $outcome > 0.

Classificazione di regole

Specificare una regola condizionale in una regola con una corrispondenza di corrispondenza significa che la regola verrà classificata come regola multi-evento per la quota di regole. Per scoprire di più sulle classificazioni di uno o più eventi, consulta Regole relative a eventi singoli e Più regole relative agli eventi.

Conteggio caratteri (#)

Il carattere # è un carattere speciale nella sezione condition. Se utilizzato prima di qualsiasi nome variabile evento o segnaposto, rappresenta il numero di eventi o valori distinti che soddisfano tutte le condizioni della sezione events.

Carattere valore ($)

Il carattere $ è un altro carattere speciale nella sezione condition. Se utilizzato prima del nome della variabile di risultato, rappresenta il valore di quel risultato.

Se viene utilizzata prima di qualsiasi nome di variabile evento o segnaposto (ad esempio $event), è un'abbreviazione di #event > 0.

Sintassi della sezione Opzioni

Nella sezione options, puoi specificare le opzioni per la regola. La sintassi per la sezione options è simile a quella della sezione meta. Tuttavia, una chiave deve essere uno dei nomi di opzione predefiniti e il valore non è limitato al tipo di stringa.

Attualmente, l'unica opzione disponibile è allow_zero_values.

• allow_zero_value: se il valore è impostato su true, le corrispondenze generate dalla regola non possono avere valori corrispondenti a quelli della variabile. Se non vengono compilati, vengono assegnati valori zero ai campi evento. Questa opzione è impostata su false per impostazione predefinita.

Nota: per impostazione predefinita, Chronicle non restituisce alcun valore pari a zero come valore della variabile di corrispondenza.

Di seguito è riportata la riga di sezione options valida:

• allow_zero_values = true

Controllo del tipo

Durante la creazione delle regole nell'interfaccia, Chronicle esegue il controllo dei tipi in base alla sintassi YARA-L. Gli errori di controllo del tipo visualizzati consentono di rivedere la regola in modo che funzioni come previsto.

Di seguito sono riportati esempi di predicati non validi:

// $e.target.port is of type integer which cannot be compared to a string.
$e.target.port = "80"

// "LOGIN" is not a valid event_type enum value.
$e.metadata.event_type = "LOGIN"