Cerca nelle tabelle di dati
Le tabelle di dati sono costrutti di dati multicolonna che ti consentono di inserire i dati in Google Security Operations. Le tabelle di dati possono fungere da tabelle di ricerca con colonne definite e i dati archiviati in righe. Puoi creare o importare una tabella di dati nel tuo account Google SecOps utilizzando l'interfaccia web di Google SecOps, l'API delle tabelle di dati o una query Panoramica di YARA-L 2.0.
Assegna gli ambiti alle tabelle di dati utilizzando l'RBAC dei dati
Per utilizzare le tabelle di dati, devi assegnare loro degli ambiti utilizzando controllo dell'accesso basato sui ruoli (RBAC) dei dati. Assegnando gli ambiti a una tabella di dati, puoi controllare quali utenti e risorse possono accedervi e utilizzarla. Per saperne di più, consulta Configura il RBAC dei dati per le tabelle di dati.
Gestisci le tabelle di dati utilizzando l'interfaccia web di Google SecOps
Le sezioni seguenti descrivono come gestire le tabelle dati utilizzando l'interfaccia web, tra cui come accedere alle tabelle dati, aggiungerne una nuova, modificarne i contenuti, aggiungere righe e rimuovere una tabella dati dal tuo account.
Accedi alle tue tabelle di dati
Per accedere alla pagina Tabelle di dati, segui questi passaggi:
- Nella barra laterale, seleziona Indagine > Tabelle dati.
Per trovare una tabella dati specifica, inserisci il nome nel campo Cerca nella parte superiore della barra laterale Tabelle dati.
Aggiungi una nuova tabella di dati
Quando aggiungi una nuova tabella dati, puoi inserire manualmente i dati CSV, incollarli o importare un file CSV o TSV nella tabella dati.
Le seguenti configurazioni sono permanenti e non possono essere modificate dopo il salvataggio di una nuova tabella di dati:
- Intestazioni di colonna
- Mappatura dei dati
- Chiavi primarie
- Campi ripetuti
- Mappatura dei nomi delle colonne ai campi delle entità
Per aggiungere una nuova tabella di dati a Google SecOps, segui questi passaggi:
Nella barra laterale, seleziona Indagine > Tabelle dati.
Nella parte superiore della barra laterale Tabelle dati, fai clic su Crea.
Nella finestra di dialogo Crea nuova tabella dati, assegna un nome alla tabella e, facoltativamente, aggiungi una descrizione.
Esegui una delle seguenti operazioni:
- Inserisci manualmente i dati CSV o incollali nell'area Testo (modalità di modifica).
- Per importare i dati da un file CSV o TSV nella tabella dati:
- Fai clic su Importa file.
- Vai al file e fai clic su Apri. Viene visualizzata la finestra di dialogo Importa file.
- Se nel passaggio precedente hai selezionato un file TSV, segui questi passaggi:
- Dall'elenco Tipo di separatore, seleziona Rileva automaticamente o Tabulazione.
- Nell'elenco Avvia importazione dalla riga, specifica la riga del file da cui importare i dati.
- Fai clic su Importa dati.
Seleziona la modalità di modifica Tabella e configura quanto segue in base alle tue esigenze:
Fai clic su Salva. La nuova tabella dati viene visualizzata nella barra laterale Tabelle dati ed è pronta per accettare altri dati.
Mappa i tipi di dati alle colonne della tabella dati
Quando aggiungi una nuova tabella dati, puoi mappare i tipi di dati (stringa, espressione regolare, CIDR o numero) alle colonne della tabella dati.
Puoi mappare singoli campi di dati a una colonna di dati e mappare campi di dati ripetuti a una colonna di dati utilizzando l'interfaccia web o l'API, come segue:
Sia nell'interfaccia web che nell'API, separa i valori dei campi di dati utilizzando una barra verticale (
|). Nell'interfaccia web, se un valore include una barra verticale (|), viene trattato come un valore ripetuto per impostazione predefinita.Per le richieste API, imposta
repeated_valuessutrue.
Per saperne di più, consulta Campi ripetuti.
Nell'esempio seguente, la colonna della tabella dati Field_value contiene valori per più campi:
| Field_value | Field_name |
|---|---|
| altostrat.com | FQDN |
| 192.0.2.135 | IP |
| charlie | userid |
| esempio | nome host |
La tabella precedente è suddivisa in quattro colonne, ognuna delle quali è mappata a un solo tipo di campo prima di poter essere utilizzata per uno dei casi d'uso della tabella di dati presentati in questo documento.
| FQDN | IP | ID utente | Nome host |
|---|---|---|---|
| altostrat.com | 192.0.2.135 | charlie | esempio |
| … | … | … | … |
Designa le colonne chiave
Quando aggiungi una nuova tabella di dati, puoi designare colonne specifiche come colonne chiave.
Contrassegnare una colonna come colonna chiave consente di identificare i valori di quella colonna in modo univoco, evitare la duplicazione dei dati e migliorare il rilevamento dei dati per regole e ricerche.
Designa colonne per supportare i campi ripetuti
Quando aggiungi una nuova tabella di dati, puoi designare colonne specifiche per supportare i campi ripetuti.
Le colonne destinate a memorizzare campi con più valori o campi ripetuti devono essere designate esplicitamente come ripetute al momento della creazione della tabella di dati.
Mappa i nomi delle colonne ai campi delle entità (facoltativo)
Quando aggiungi una nuova tabella dati, puoi mappare i nomi delle colonne della tabella dati ai campi entità.
Nella seguente tabella di dati di esempio, le colonne Userid e Role sono mappate rispettivamente a entity.user.userid e entity.user.attribute.role.name:
| Userid (mappa a entity.user.userid) |
Role (mappa a entity.user.attribute.role.name) |
|
|---|---|---|
| jack | jack123@gmail.com | amministratore |
| tony | tony123@gmail.com | engineer |
Puoi mappare una colonna della tabella di dati a un campo proto dell'entità utilizzando il campo mapped_column_path della risorsa DataTable.
Per le colonne senza un percorso di entità definito, come Email in questa tabella di esempio, devi specificare manualmente un tipo di dati. Come per gli elenchi di riferimento, i tipi di dati supportati per le tabelle di dati sono number, string, regex e cidr.
Puoi includere colonne mappate e non mappate in una tabella di dati specificando una condizione join.
Le colonne non mappate vengono archiviate nel campo additional dell'entità a cui si unisce la tabella. Questi vengono aggiunti come coppie chiave-valore, dove key è il nome della colonna e value è il valore della riga corrispondente.
Aggiungi una nuova riga a una tabella di dati
Per aggiungere una nuova riga:
- Nella scheda Dettagli, seleziona la modalità di modifica Tabella.
- Fai clic con il tasto destro del mouse su una riga esistente e seleziona Aggiungi riga sopra.
- Inserisci i dati per una nuova riga. La prima riga viene trattata come intestazione della tabella. Assicurati di abbinare ogni elemento dati alla colonna e al tipo di dati appropriati.
- Fai clic su Salva.
Modifica una riga in una tabella di dati
Per modificare una riga:
- Fai clic sul campo da modificare. Il campo diventa modificabile.
- Apporta le modifiche.
- Fai clic su Salva.
Cerca nelle righe della tabella di dati
Puoi cercare informazioni specifiche all'interno di una tabella di dati utilizzando l'interfaccia web. Nella scheda Dettagli, inserisci una stringa di ricerca nel campo di ricerca e fai clic su Cerca. Vengono visualizzate le righe contenenti la stringa di ricerca.
Gestisci il TTL delle righe della tabella
Per gestire il valore della durata (TTL) per le righe della tabella, segui questi passaggi:
Fai clic su Mostra TTL per riga. Viene visualizzata una colonna TTL che indica se ogni riga è scaduta. Se non è scaduto, mostra il tempo rimanente prima della scadenza.
Fai clic sul tempo di Scadenza predefinita delle righe per visualizzare la finestra di dialogo Aggiorna la scadenza predefinita delle righe e regola il TTL delle righe della tabella.
Inserisci un nuovo valore TTL in Ore o Giorni. Il valore minimo è 1 ora. Il valore massimo è 365 giorni.
Fai clic su Salva.
Comportamento di override del TTL a livello di riga
Le righe ereditano il TTL applicato a livello di tabella. Puoi anche impostare un TTL specifico per singole righe e questo TTL a livello di riga ha la precedenza sul valore predefinito a livello di tabella. Quando aggiungi una nuova riga, il relativo TTL inizia dal momento della creazione.
Elimina una riga della tabella
Per eliminare una riga, fai clic con il tasto destro del mouse sulla riga e seleziona Elimina riga/righe.
Per eliminare più righe, seleziona ogni riga che vuoi rimuovere. Poi fai clic con il tasto destro del mouse su una riga selezionata e scegli Elimina righe.
Rimuovi una tabella di dati
Per rimuovere una tabella dati:
Seleziona una tabella di dati dall'elenco Tabelle di dati nella barra laterale.
Fai clic su Elimina.
Gestisci le tabelle di dati utilizzando l'API Chronicle
Puoi anche utilizzare le risorse REST disponibili nell'API Chronicle per gestire le tabelle di dati in Google SecOps. L'API può replicare tutte le funzionalità disponibili nell'interfaccia web e include alcune funzionalità aggiuntive che ti consentono di gestire le tabelle di dati con prestazioni migliori e su scala più ampia.
Ecco le risorse REST della tabella di dati:
Esempio: sintassi del filtro
Il seguente esempio di API Chronicle mostra come utilizzare la sintassi filter per cercare google.com nelle righe della tabella di dati:
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://staging-chronicle.sandbox.googleapis.com/v1alpha/projects/{$PROJECT}/locations/${REGION}/instances/${INSTANCE}/dataTables/${DATA_TABLE_NAME}/dataTableRows?filter=google.com"
Utilizza le tabelle di dati in Google SecOps
Dopo aver aggiunto le tabelle di dati alla tua istanza di Google SecOps, puoi utilizzarle per filtrare, migliorare e arricchire i dati utilizzando le query YARA-L. Questo documento include numerosi esempi di sintassi YARA-L, che puoi incorporare in Google SecOps.
Puoi utilizzare le tabelle di dati insieme alle query YARA-L sia nella ricerca che nelle regole.
Le tabelle di dati possono essere utilizzate nei seguenti modi:
Filtra i dati degli eventi o delle entità UDM utilizzando una tabella di dati
Puoi filtrare gli eventi e le entità di telemetria UDM confrontandoli con le voci di una tabella di dati.
Utilizza una tabella dati come elenco di riferimento a più colonne
Puoi utilizzare una tabella di dati come elenco di riferimento a più colonne. Mentre un elenco di riferimento può accedere ai dati in una singola dimensione, le tabelle di dati consentono di accedere ai dati in più dimensioni, consentendo il filtro dei dati.
Unire una tabella dati a un evento o a un'entità
Puoi collegare gli eventi UDM a una tabella di dati utilizzando l'operatore di uguaglianza (
=) per i confronti basati su righe. Questo confronto ti consente di filtrare i dati. Un confronto basato su righe restituiscetruesolo se tutte le condizioni nell'istruzione corrispondono a una singola riga nella tabella dati.
Filtra i dati di entità ed eventi UDM utilizzando una tabella di dati
Puoi filtrare gli eventi e le entità UDM confrontandoli con le voci di una tabella di dati. Unisci la tabella di dati a un evento o un'entità UDM utilizzando confronti basati su righe o basati su colonne.
Confronti basati su righe e colonne nelle tabelle di dati
| Tipo di confronto | Logica chiave | Operatori comuni | Esempio di sintassi | Quando utilizzarlo |
|---|---|---|---|---|
| Basato su righe | Tutte le condizioni devono corrispondere all'interno della STESSA riga | =, !=, >, >=, <, <= |
$e.field = %table.col_a |
Quando la relazione tra più valori di colonna nella stessa riga è importante. |
| Basato su colonne | Il valore deve esistere IN QUALSIASI PUNTO della colonna | IN, IN regex, IN cidr |
$e.field IN %table.col_b |
Quando controlli la presenza di un valore all'interno di un insieme di valori in una singola colonna. |
Collega gli eventi UDM alle tabelle di dati utilizzando i metodi di confronto Basato su righe o Basato su colonne:
Confronto basato su righe per collegare gli eventi UDM alle tabelle di dati
Per collegare gli eventi UDM alle tabelle di dati utilizzando il confronto basato su righe, utilizza gli operatori di uguaglianza (
=,!=,>,>=,<,<=).Ad esempio:
$<udm_variable>.<field_path> = %<data_table_name>.<column_name>- Se utilizzi più istruzioni di confronto, tutti i campi o le condizioni devono corrispondere nella stessa riga della tabella di dati.
Per utilizzare gli operatori (come
not,!=,>,>=,<,<=) nella query, devi includere almeno una condizionejointra i campi UDM e le righe della tabella di dati.Google SecOps tratta qualsiasi regola con una tabella di dati
joincome una regola multievento, che richiede una sezionematchnella definizione della regola.
Per filtrare i dati confrontando i valori degli eventi UDM con le righe della tabella dei dati, considera la seguente sintassi di join:
Sintassi di join corretta:
Regole di rilevamento (anti-join sinistro): per escludere gli eventi quando una combinazione specifica di più campi corrisponde alla stessa riga in una tabella di dati (anti-join), associa i campi degli eventi alle colonne della tabella di dati utilizzando l'uguaglianza (
=) nella sezioneeventse specifica$e and #<data_table_name> = 0nella sezionecondition. In alternativa, includi#<data_table_name> >= 0nella sezioneconditionin modo che il compilatore esegua un join esterno sinistro (ad esempio,$e and #<data_table_name> >= 0 and $match_count = 0quando conteggia le righe corrispondenti inoutcomeutilizzando$match_count = count(%<data_table_name>.<column_name>)). Se una riga della tabella dati corrisponde a tutte le colonne associate, il conteggio delle righe è maggiore di zero e la regola esclude l'evento. Per saperne di più, consulta Esempi di anti-join sinistro (esclusione) nelle regole.Ricerca e dashboard:
- Con una sezione
match(ricerca aggregata e dashboard): ripetileft joinsu ogni colonna unita nella sezioneevents(ad esempio,left join $e.field1 = %<data_table_name>.col1eleft join $e.field2 = %<data_table_name>.col2) e aggiungi#<data_table_name> = 0nella sezionecondition(o conteggia una colonna corrispondente inoutcomee valuta$match_count = 0incondition). - Senza una sezione
match(dashboard e ricerca multifase non aggregata): inserisci le istruzionileft joinripetute in unstagedenominato che restituisce una colonna della tabella di dati inoutcome(ad esempio,$matched_col = %<data_table_name>.<column_name>), filtra per$<stage_name>.matched_col = ""nella sezioneeventsprincipale (le stringhe di output della fase senza corrispondenza vengono impostate per impostazione predefinita su stringhe vuote anziché su null) e proietta i campi della fase necessari nella sezioneoutcomeprincipale.
- Con una sezione
Sintassi di join errata:
Non racchiudere
NOTtra più condizioni di uguaglianza basate su righe (ad esempio,NOT ($e.field1 = %table.col1 AND $e.field2 = %table.col2)). La corrispondenza viene valutata riga per riga rispetto alla tabella di dati. Se una riga non soddisfa la condizione combinata interna,NOTrestituiscetrue, includendo potenzialmente l'evento anziché escluderlo.Non utilizzare operatori di disuguaglianza indipendenti su più colonne (ad esempio
$e.field1 != %table.col1 AND $e.field2 != %table.col2) senza una condizione di join positiva (=), che causa un errore di compilazione. Anche se associati a un join positivo su un'altra colonna, gli operatori di disuguaglianza valutano le colonne sulla stessa riga unita e trovano una corrispondenza ogni volta che una riga unita è diversa, anziché verificare che nessuna riga corrisponda alla tupla.Non confondere i confronti basati su righe con i controlli di appartenenza basati su colonne (
not $e.field1 in %table.col1 and not $e.field2 in %table.col2). I controlliinbasati su colonne valutano ogni colonna in modo indipendente nell'intera tabella di dati, escludendo un evento sefield1viene visualizzato in una riga efield2in un'altra, anche se i due valori non vengono mai visualizzati insieme nella stessa riga.
Per utilizzare una colonna della tabella di dati di tipo
CIDRoregexper il confronto basato su righe, utilizza la seguente sintassi:net.ip_in_range_cidr($e.principal.ip, %<data_table_name>.<column_name>) re.regex($e.principal.hostname, %<data_table_name>.<column_name>)
Confronto basato su colonne per collegare gli eventi UDM alle tabelle di dati
Per collegare gli eventi UDM alle tabelle di dati utilizzando il confronto basato su colonne, utilizza la parola chiave
in.Ad esempio:
$<udm_variable>.<field_path> in %<data_table_name>.<column_name>Per filtrare gli eventi in cui il valore del campo esiste nella colonna specificata (ad esempio, una lista bloccata o una lista consentita), utilizza questa sintassi:
NOT (... IN %table.column)Ad esempio:
not ($evt_username in %my_data_table.username)Per utilizzare una colonna della tabella di dati di tipo
CIDRoregexper il confronto basato su colonne, utilizza la seguente sintassi:$e.principal.ip in cidr %cidr_data_table.column_name $e.principal.hostname in regex %regex_data_table.column_nameQuando confronti le colonne nelle tabelle di dati che sono tipi di dati CIDR o espressioni regolari, le parole chiave
cidreregexsono facoltative.Puoi anche utilizzare l'operatore
notcon le tabelle di dati.La seguente query di esempio filtra le voci in cui gli indirizzi IP (
$e.principal.ip) non corrispondono a nessuno degli intervalli CIDR elencati nella colonnabenign_ipincidr_data_table:not $e.principal.ip in %data_table.benign_ip
Utilizza una tabella dati come elenco di riferimento a più colonne
Puoi utilizzare una tabella dati come elenco di riferimento a più colonne. Sebbene un elenco di riferimento possa accedere ai dati in una singola dimensione (una colonna), le tabelle di dati supportano più colonne, consentendoti di filtrare e accedere ai dati in più dimensioni.
Puoi collegare gli eventi UDM a una tabella di dati utilizzando la parola chiave in per il confronto basato su colonne, in modo da abbinare i valori di un campo UDM specifico ai valori di una singola colonna della tabella di dati.
Nell'esempio seguente, la tabella di dati badApps contiene due colonne:
hostname e ip. La query corrisponde a entrambi i valori (valore basato sul campo UDM e valore basato sulla tabella di dati, entrambi di tipo di dati stringa) in modo indipendente.
Esempio di regola:
rule udm_in_data_table { meta: description = "Use data table as multicolumn reference list" events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.asset.asset_id = $assetid // Event hostname matches at least one value in table column hostname. $e.target.hostname in %badApps.hostname // Event IP matches at least one value in table column ip. $e.target.ip in %badApps.ip match: $assetid over 1h condition: $e }Esempio di ricerca:
events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.asset.asset_id = $assetid // Event hostname matches at least one value in table column hostname. $e.target.hostname in %badApps.hostname // Event IP matches at least one value in table column ip. $e.target.ip in %badApps.ip
Join basati su righe tra una tabella di dati e un evento o un'entità UDM
Puoi collegare gli eventi UDM a una tabella di dati utilizzando gli operatori di uguaglianza e confronto (=, !=, >, >=,
<, <=) per eseguire confronti basati sulle righe. Questo approccio ti consente di filtrare i dati confrontando i valori degli eventi UDM con le righe della tabella di dati. Se utilizzi più istruzioni di confronto, tutti i campi o le condizioni devono corrispondere nella stessa riga della tabella dati.
Devi includere almeno una condizione join tra i campi UDM e le righe della tabella dei dati per utilizzare gli operatori (ad esempio not, !=, >, >=, <, <=) nella query.
Google SecOps tratta qualsiasi regola con una tabella di dati join come una regola multievento, che richiede una sezione match corrispondente nella definizione della regola.
Quando si verifica un join, le righe della tabella dei dati collegati sono visibili nella Ricerca. Per saperne di più, consulta Visualizza le righe della tabella di dati nella Ricerca.
I segnaposto sono supportati per le tabelle di dati nella sezione
eventdi una query, ma devono essere collegati a un evento UDM o a un'entità UDM.L'esempio seguente utilizza una colonna della tabella di dati di tipo
string.Questo esempio di query YARA-L verifica se un evento di accesso utente corrisponde a una riga in
example_table.- Una condizione è che
user IDesista inexample_table. - Entrambe le condizioni devono corrispondere alla stessa riga in
example_tableaffinché la regola venga attivata.
- Una condizione è che
Esempio di regola:
// Check if user exists in a data table and is active in all user login events. rule udm_join_data_table { meta: description = "Join data table with UDM event" events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" $e.principal.user.userid = $userid // Event must match at least 1 row in the data table // where the uid in the data table row is the userid on the event // and the active date in the same data table row is before the event timestamp. %example_table.uid = $userid $e.principal.hostname = %example_table.hostname match: $userid over 1h condition: $e }Esempio di ricerca:
events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" $e.principal.user.userid = $userid // Event must match at least 1 row in the data table // where the uid in the data table row is the userid on the event // and the active date in the same data table row is before the event timestamp %example_table.uid = $userid $e.principal.hostname = %example_table.hostname
L'esempio seguente illustra l'interazione tra una tabella di dati e i dati sugli eventi UDM.
In base alla logica della query YARA-L precedente, un utente con
user ID 32452viene visualizzato nel rilevamento comehostnamedell'utente dal sistema e corrisponde ahostnamenella tabella dei dati.Tabella di dati uid title hostname 32452 HR host1 64452 Finanza host2 46364 IT host3 Tabella degli eventi UDM principal metadata security_result principal 32452 USER_LOGIN CONSENTI host1 64589 USER_LOGIN CONSENTI host9 87352 USER_LOGIN CONSENTI host4
Escludi gli eventi utilizzando un anti-join basato su righe con più colonne
Per escludere gli eventi solo quando una combinazione specifica di campi corrisponde alla stessa riga in una tabella dati di esclusione (un anti-join sinistro), associa ogni campo evento alla colonna della tabella dati corrispondente nella sezione events e specifica #<data_table_name> = 0 nella sezione condition.
La seguente regola di rilevamento di esempio esclude gli eventi quando sia il nome della regola sia il nome host principale corrispondono alla stessa riga in exclusion_table:
rule multi_column_row_exclusion {
meta:
author = "Google SecOps"
description = "Excludes events matching a specific rule and hostname combination in the same row of an exclusion data table."
events:
$e.metadata.event_type = "USER_LOGIN"
$e.security_result.rule_name = $rule_name
$e.principal.hostname = $hostname
// Both fields must match the SAME row in the exclusion data table
$rule_name = %exclusion_table.rule_name
$hostname = %exclusion_table.hostname
match:
$rule_name, $hostname over 5m
condition:
// Triggers only when the event exists and no matching combination row exists in the data table
$e and #exclusion_table = 0
}
Per altri esempi di outer join e anti-join, consulta Correlare i dati utilizzando gli outer join.
Scrivi i risultati delle query YARA-L nelle tabelle di dati
Puoi scrivere i risultati delle query YARA-L in una tabella di dati. Utilizzando questa funzionalità, puoi creare tabelle di dati dai tuoi dati di Google SecOps e utilizzarle per filtrare e migliorare altri dati.
Puoi utilizzare la sintassi di scrittura delle query YARA-L per:
Definisci la sintassi YARA-L per scrivere i risultati delle query nelle tabelle di dati.
Utilizza le tabelle di dati per la threat intelligence, la risposta agli incidenti e altri casi d'uso della sicurezza.
I dati devono essere conformi alla sintassi e alle convenzioni di YARA-L.
Scrivi rilevamenti e avvisi nelle tabelle di dati utilizzando YARA-L
Puoi utilizzare una query YARA-L per inviare rilevamenti e avvisi alle tabelle di dati.
Utilizzando la funzione write_row, puoi sovrascrivere una riga della tabella dei dati con la chiave corrispondente nella tabella dei dati utilizzando i risultati di una regola. Se la chiave non viene trovata nella tabella, aggiungi una nuova riga.
Specifica la funzione write_row nella sezione di esportazione di una query YARA-L. La scrittura dei dati nella tabella dati deve essere l'azione finale della query. In questo modo, le variabili dei risultati vengono scritte nella tabella dei dati.
Esempio
export: %<data_table_name>.write_row( data_table_column_x_name: <value>, data_table_column_y_name: <value>, ..., ..., data_table_column_z_name: <value> ) // depending on the key column(s), the rows will be updated for existing keys and appended for new keysEsempio: esporta i risultati di ricerca in una tabella di dati
events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" outcome: $user = $e.principal.user.userid $ip = $e.target.ip[0] // Assuming target.ip is an array $timestamp = $e.metadata.event_timestamp.seconds export: // Write to the data table named 'successful_logins' %successful_logins.write_row( user: $user, // Maps $user variable to 'user' column ip: $ip, // Maps $ip variable to 'ip' column first_seen: $timestamp // Maps $timestamp variable to 'first_seen' column )
Modifica una tabella di dati utilizzando YARA-L
Di seguito viene mostrato come modificare una tabella di dati utilizzando YARA-L:
TableName: ip_user_domain_table (le colonne chiave per la chiave primaria vengono definite al momento della creazione)
| Indirizzo IP | employee_id* | dominio |
|---|---|---|
| 192.0.2.10 | Dana | altostrat.com |
| 192.0.2.20 | Quinn | altostrat.com |
| 192.0.2.30 | Lee | cymbalgroup.com |
* indica la chiave primaria.
La seguente query acquisisce combinazioni univoche di principal.ip, principal.user.employee_id e target.domain. Filtra i risultati in base alla prevalenza di target.domain:
Esempio
events: $e.principal.ip = $principal_ip $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 // To run this query as a rule, add Condition Section here // condition:$e
Risultati delle query:
| ip | empid | dominio |
|---|---|---|
| 192.0.2.10 | Dana | altostrat.com |
| 192.0.2.30 | Lee | examplepetstore.com |
| 192.0.2.20 | Quinn | altostrat.com |
Esempio: utilizza write_row per scrivere l'output della query in una tabella di dati
Esempio di regola:
rule udm_write_data_table { meta: description = "Writeto data table" events: $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 outcome: $hostname = $target_domain $principal_emp_id = $principal_user_employee_id condition: $e export: %ips_with_hostnames.write_row( employeeid:$principal_emp_id, hostname:$hostname ) }Esempio di ricerca:
events: $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 outcome: $hostname = $target_domain $principal_emp_id = $principal_user_employee_id export: %ips_with_hostnames.write_row( employeeid:$principal_emp_id, hostname:$hostname )
Esempio: informazioni su write_row
Nell'esempio seguente, user e ip vengono utilizzati come chiavi primarie. Ogni rilevamento che persiste nella tabella dei rilevamenti genera una valutazione della chiamata di funzione nella sezione di esportazione della query.
Esempio di regola:
rule udm_write_data_table { meta: description = "Write data table" events: $e.metadata.event_type = "USER_LOGIN" all $e.security_result.action != "BLOCK" all $e.security_result.action != "UNKNOWN_ACTION" $user = $e.principal.user.userid $ip = $e.target.ip $ts = $e.metadata.event_timestamp.seconds match: $user, $ip over 1h outcome: $first_seen = min($ts) condition: $e export: %successful_logins.write_row(user:$user, ip:$ip) }Esempio di ricerca:
events: $e.metadata.event_type = "USER_LOGIN" all $e.security_result.action != "BLOCK" all $e.security_result.action != "UNKNOWN_ACTION" $ts = $e.metadata.event_timestamp.seconds outcome: $user = $e.principal.user.userid $ip = $e.target.ip[0] export: %successful_logins.write_row(user:$user, ip:$ip)Ecco i dati sugli eventi:
metadata: { event_type: USER_LOGIN event_timestamp: { seconds: 1283299200 } } principal: { user: { userid: "charlie" } } target: { ip: ["192.0.2.135", "192.0.2.136"] } security_result: { action: ALLOW }I seguenti rilevamenti vengono restituiti quando questa query viene eseguita come regola:
ID rilevamento Match $user Match $ip 0 charlie 192.0.2.135 1 charlie 192.0.2.136 La tabella dati contiene quanto segue:
user ip charlie 192.0.2.135 charlie 192.0.2.136 La seguente query di ricerca illustra il supporto offerto nella Ricerca per la scrittura di valori scalari nelle tabelle di dati.
events: $e.metadata.event_type = "NETWORK_CONNECTION" export: %summary_table.write_row(col_name: $e.metadata.product_name, Vendor_name: $e.metadata.vendor_name)
Arricchisci il grafico delle entità con una tabella dati
Puoi utilizzare le tabelle di dati per aggiungere, rimuovere o sostituire le entità presentate in un grafico delle entità dalle regole. Utilizza le funzioni nella sezione della regola setup per indicare in che modo la tabella dati deve essere unita, aggiunta o utilizzata per rimuovere entità dagli eventi entità a cui viene fatto riferimento nella sezione events.
Puoi utilizzare il seguente modello di regola per modificare un grafo di entità:
Template di regola
rule entity_graph_template { meta: ... setup: // import the data table into entity graph <enrichment_keyword> <join_condition> events: ... match: ... condition: ... }
Puoi utilizzare le seguenti funzioni YARA-L 2.0 per migliorare il grafico delle entità con una tabella di dati:
graph_override: sovrascrivi le righe nel grafico delle entità che corrispondono alla condizione di unione con i dati della tabella dei dati.Ad esempio:
[graph_override](?tab=t.0#heading=h.v0fps7eke1if)graph_append: aggiungi le righe della tabella di dati alle righe del grafico delle entità. L'operazionegraph_appendrichiede un array che includa una variabile della tabella dati e una variabile dell'evento entità anziché una condizione di join.Nell'esempio seguente,
$g1è la variabile del grafico delle entità eexample_tableè la tabella di dati:graph_append [$g1, %example_table]Per la funzione
append, le tabelle di dati devono includere le seguenti colonne per convalidare l'entità:start_time(mappata ametadata.interval.start_time.seconds)end_time(mappata ametadata.interval.end_time.seconds)
Le colonne della tabella di dati non possono essere mappate ai campi dei metadati utilizzando l'interfaccia web. Per i casi d'uso di
append, le tabelle di dati devono essere create utilizzando l'API Chronicle (https://docs.cloud.google.com/chronicle/docs/reference/rest/v1alpha/projects.locations.instances.dataTables/create)graph_exclude: rimuovi le righe nel grafo delle entità che corrispondono alla condizionejoin.Ad esempio:
[graph_exclude](?tab=t.0#heading=h.o0qbb5paki6g)
La condizione di join deve essere un'espressione di uguaglianza tra la colonna della tabella dati e il campo del grafo delle entità. Per le funzioni graph_override e graph_exclude, la sintassi per accedere a una tabella dati è la seguente:
<data_table_name>.<column_name>
Qualsiasi filtro specificato per <entity_variable> nella sezione degli eventi viene applicato dopo il suo miglioramento con la tabella di dati.
Dopo che l'entità nel grafico delle entità è stata arricchita con l'entità nella tabella dei dati, la variabile dell'entità nel grafico delle entità deve essere unita all'entità UDM.
Esegui l'override del grafico delle entità con i dati della tabella dati
Con la funzione graph_override, i campi presenti sia nel grafico delle entità sia nella tabella di dati vengono sostituiti con i campi della tabella di dati. I campi presenti nel grafico delle entità e non nella tabella di dati rimangono invariati. I campi non presenti nel grafico delle entità, ma presenti nella tabella dei dati, sono inclusi.
Solo le colonne della tabella di dati mappate sostituiscono le colonne del grafico delle entità. Le colonne non mappate vengono aggiunte al campo additional del grafico delle entità a cui è unita la tabella dati.
Esempio: corrispondenza su un singolo join
Nell'esempio seguente, le righe nel grafico delle entità che corrispondono alla condizione di join tra la colonna della tabella di dati e il campo del grafico delle entità ($g1.graph.entity.ip = %example_table.my_ip) vengono sostituite dalla tabella di dati.
Esempio
rule rule_override { meta: description = "Override entity context with data table before joining with UDM event" setup: //Rows in the entity graph that match the join condition are overridden by the data table graph_override ($g1.graph.entity.ip = %example_table.my_ip) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Filter will be applied after graph is overridden by data table $g1.graph.entity.hostname = "ftp01" // Accessing unmapped columns $g1.graph.additional.fields["Owner"] = "alice" // Joining the UDM event with the enriched entity graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Per utilizzare una colonna non mappata (ad esempio "Proprietario") della tabella di dati, l'istruzione equivalente per $g1.graph.entity.owner = "alice" is $g1.graph.additional.fields["Owner"] = "alice" è:
Questo perché tutte le colonne non mappate della tabella di dati vengono inserite nel campo additional del grafico delle entità ($g1).
Le tabelle seguenti illustrano un'operazione di override in cui le righe nel grafico delle entità vengono arricchite quando il campo IP nella tabella dei dati corrisponde al campo IP nel grafico delle entità.
| Grafico delle entità esistente | ||
|---|---|---|
| Nome host | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tabella di dati | |||
|---|---|---|---|
| Nome host | IP | MAC | Proprietario |
| ftp01 | 10.1.1.4 | …:bb | alice |
| h1 | 10.1.1.6 | …:cc | bob |
| h2 | 10.1.1.7 | …:dd | chris |
| h3 | 10.1.1.4 | …:ee | doug |
| Grafico delle entità arricchito | |||
|---|---|---|---|
| Nome host | IP | MAC | Proprietario |
| ftp01 | 10.1.1.4 | …:bb | alice |
| www01 | 10.1.1.5 | …:02 | |
| h3 | 10.1.1.4 | …:ee | doug |
Esempio: corrispondenza su più join
Nell'esempio seguente, le righe nel grafico delle entità che corrispondono alle più condizioni di join ($g1.graph.entity.ip = %example_table.my_ip e $g1.graph.entity.hostname = %example_table.my_hostname) vengono sostituite dalla tabella di dati.
Esempio
rule rule_override { meta: description = "Override Entity context with Data Table before joining with UDM event" setup: // example with more than one condition graph_override ($g1.graph.entity.ip = %example_table.my_ip and $g1.graph.entity.hostname = %example_table.my_hostname) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Filter will be applied after graph is overridden by data table $g1.graph.entity.hostname = "ftp01" // joining the UDM event with the enriched entity graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Le tabelle seguenti illustrano un'operazione di override in cui le righe del grafico delle entità vengono arricchite quando sia il campo IP sia il campo del nome host nella tabella dei dati corrispondono al campo IP e al campo del nome host nel grafico delle entità.
| Grafico delle entità esistente | ||
|---|---|---|
| Nome host | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tabella di dati | |||
|---|---|---|---|
| Nome host | IP | MAC | Proprietario |
| ftp01 | 10.1.1.4 | …:bb | alice |
| h1 | 10.1.1.5 | …:cc | bob |
| h2 | 10.1.1.6 | …:dd | chris |
| h3 | 10.1.1.4 | …:ee | doug |
| Grafico delle entità arricchito | |||
|---|---|---|---|
| Nome host | IP | MAC | Proprietario |
| ftp01 | 10.1.1.4 | …:bb | alice |
| www01 | 10.1.1.5 | …:02 | |
Aggiungi i dati della tabella dati al grafo delle entità
Con la funzione graph_append, non è richiesta alcuna condizione di join.
Nell'esempio seguente, tutte le righe della tabella di dati vengono aggiunte alle righe del grafo delle entità.
Esempio
rule rule_append { meta: description = "Data table append entity" setup: graph_append [$g1, %example_table] events: // filter UDM events $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Join the filtered UDM events with the enriched graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
La seguente tabella di esempio illustra un'operazione di aggiunta in cui le righe della tabella di dati vengono aggiunte alle righe nel grafico delle entità:
| Grafico delle entità esistente | ||
|---|---|---|
| Nome host | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tabella di dati | ||
|---|---|---|
| IP | MAC | Proprietario |
| 10.1.1.4 | …:01 | alice |
| 10.1.1.6 | …:cc | bob |
| 10.1.1.7 | …:dd | chris |
| 10.1.1.4 | …:ee | doug |
| Grafico delle entità arricchito | |||
|---|---|---|---|
| Nome host | IP | MAC | Proprietario |
| ftp01 | 10.1.1.4 | …:01 | |
| www01 | 10.1.1.5 | …:02 | |
| 10.1.1.4 | …:bb | alice | |
| 10.1.1.6 | …:cc | bob | |
| 10.1.1.7 | …:dd | chris | |
| 10.1.1.4 | …:ee | doug | |
Utilizza graph_exclude per rimuovere righe dal grafo delle entità
Con la funzione graph_exclude, le righe nel grafo delle entità che corrispondono alla condizione di join vengono rimosse dal grafo delle entità.
Nell'esempio seguente, vengono rimosse tutte le righe nel grafico delle entità che corrispondono alla condizione di join specificata (tra la colonna della tabella di dati e il campo del grafico delle entità). Nessuna riga della tabella di dati viene aggiunta al grafico delle entità.
Esempio
rule rule_exclude { meta: setup: graph_exclude ($g1.graph.entity.ip = %example_table.ip) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Le seguenti tabelle illustrano un'operazione di esclusione in cui vengono rimosse le righe del grafico delle entità che corrispondono al campo IP della tabella di dati:
| Grafico delle entità esistente | ||
|---|---|---|
| Nome host | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tabella di dati | ||
|---|---|---|
| IP | MAC | Proprietario |
| 10.1.1.4 | …:bb | alice |
| 10.1.1.6 | …:cc | bob |
| 10.1.1.7 | …:dd | chris |
| Grafico delle entità arricchito | ||
|---|---|---|
| Nome host | IP | MAC |
| www01 | 10.1.1.5 | …:02 |
Limiti di frequenza delle richieste API
Le seguenti quote di query al minuto (QPM) vengono applicate per progetto e utente quando vengono chiamati gli endpoint API REST Google SecOps Data Table e Data Table Row:
| Risorsa | Operazione API | Limitazione di frequenza (STANDARD) |
|---|---|---|
| DataTables | CreateDataTable (data_table/create_requests) |
60 QPM |
| DataTables | GetDataTable (data_table/get_requests) |
120 QPM |
| DataTables | ListDataTables (data_table/list_requests) |
120 QPM |
| DataTables | UpdateDataTable (data_table/update_requests) |
60 QPM |
| DataTables | DeleteDataTable (data_table/delete_requests) |
60 QPM |
| DataTableRows | CreateDataTableRow (data_table_row/create_requests) |
60 QPM |
| DataTableRows | GetDataTableRow (data_table_row/get_requests) |
120 QPM |
| DataTableRows | ListDataTableRows (data_table_row/list_requests) |
120 QPM |
| DataTableRows | UpdateDataTableRow (data_table_row/update_requests) |
60 QPM |
| DataTableRows | DeleteDataTableRow (data_table_row/delete_requests) |
60 QPM |
| DataTableRows | BulkCreateDataTableRows (sincrono/asincrono) |
30 QPM |
| DataTableRows | BulkReplaceDataTableRows (sincrono/asincrono) |
30 QPM |
| DataTableRows | BulkUpdateDataTableRows (sincrono/asincrono) |
10 QPM |
| DataTableRows | BulkDeleteDataTableRows (sincrono/asincrono) |
30 QPM |
| DataTableRows | BulkGetDataTableRows (data_table_row/bulk_get_requests) |
120 QPM |
Limitazioni
Numero massimo di tabelle di dati per un account Google SecOps: 1000.
Le tabelle di dati supportano solo i dati CSV. Le tabelle di dati supportano i valori delimitati da tabulazioni solo quando aggiungi una nuova tabella di dati e importi un file con valori delimitati da tabulazioni (TSV).
I campi della tabella dati non supportano i caratteri virgola (
,).I limiti sul numero di istruzioni
inquando si fa riferimento a un elenco di riferimento in una query si applicano anche alle istruzioniinin una tabella di dati.Numero massimo di istruzioni
inin una query per le colonne tipizzate con tipo di datiStringeNumber: 10.Numero massimo di istruzioni
incon operatori di espressioni regolari: 5.Numero massimo di istruzioni
incon operatori CIDR: 5.Numero massimo di istruzioni
= (JOIN): 10.Numero massimo di colonne per tabella di dati: 1000.
Numero massimo di righe per tabella di dati: 10 milioni.
Limite massimo di visualizzazione nella pagina web per le righe della tabella di dati nella visualizzazione dell'editor di testo e tabella: 10.000 righe.
Volume massimo di dati in una tabella di dati: 10 GB.
I segnaposto non sono consentiti nella sezione di configurazione.
Le colonne non mappate di una tabella dati con tipo di dati impostato su
stringpossono essere unite solo ai campi stringa dell'evento UDM o dell'entità UDM.Utilizza solo colonne non mappate in una tabella di dati con un tipo di dati impostato su
cidroregexper CIDR o espressione regolare.Ricerche nelle tabelle di dati: i caratteri jolly delle espressioni regolari non sono supportati e i termini di ricerca sono limitati a 100 caratteri.
Limitazioni per i join delle tabelle di dati nelle regole
Le seguenti limitazioni si applicano ai join delle tabelle dati nelle regole.
Il recupero di tutti i campioni di eventi per i rilevamenti non è supportato quando si utilizzano i join delle tabelle di dati con gli eventi.
A differenza delle entità e di UDM, le tabelle di dati non supportano i segnaposto. Ciò comporta le seguenti limitazioni:
Non puoi applicare un insieme di filtri a una tabella di dati e unirla a un'entità UDM.
Non puoi applicare un insieme diverso di filtri alla stessa tabella di dati durante l'unione con un altro segnaposto UDM.
Ad esempio, una tabella di dati denominata
dtcon tre colonne:my_hostname,orgemy_emaile con la seguente regola:events: $e1.principal.hostname = %dt.my_hostname %dt.org ="hr" $e2.principal.email = %dt.my_email %dt.org !="hr"
Tutti i filtri di una tabella di dati vengono applicati per primi, quindi le righe filtrate della tabella di dati vengono unite a UDM. In questo caso, i filtri contraddittori (%dt.org ="hr" and %dt.org !="hr") nella tabella dt generano una tabella dati vuota, che viene poi unita sia a e1 che a e2.
Limitazioni relative all'utilizzo di tabelle dati con regole
Le seguenti limitazioni si applicano alle tabelle dati quando vengono utilizzate con le regole.
Limitazioni per la frequenza di esecuzione
La frequenza di esecuzione in tempo reale non è supportata per le regole con tabelle di dati.
Limitazioni per l'output nelle tabelle dati
I modificatori
anyeallnon sono supportati per le colonne dei campi ripetuti nelle tabelle di dati.L'indicizzazione degli array non è supportata per le colonne dei campi ripetuti nelle tabelle di dati.
Puoi esportare solo le variabili dei risultati in una tabella di dati. Non puoi esportare direttamente i percorsi degli eventi o le colonne delle tabelle di dati.
Gli elenchi di colonne devono includere le colonne della chiave primaria per le tabelle di dati.
Puoi avere un massimo di 20 risultati.
Se una tabella di dati non esiste, ne viene creata una nuova con il tipo di dati
stringpredefinito per tutte le colonne, seguendo l'ordine specificato.Un massimo di cinque regole può scrivere contemporaneamente in una tabella di dati.
Non vi è alcuna garanzia che una regola producer possa aggiungere righe a una tabella di dati prima dell'avvio di una regola consumer per quella tabella di dati.
Una singola regola ha un limite al numero di righe dei risultati. Ai risultati,ai dati persistenti e alle tabelle di dati si applica un limite massimo di 10.000 righe.
Quando aggiorni una riga, i nuovi valori di tutte le colonne non chiave sostituiscono quelli precedenti. Eventuali aggiornamenti, inclusa l'aggiunta di una nuova riga, diventano disponibili per le query dopo circa cinque minuti.
Limitazioni per l'arricchimento delle entità dalle tabelle dati
Puoi applicare una sola operazione di arricchimento (
override,appendoexclude) a una singola variabile del grafico delle entità.Ogni operazione di arricchimento può utilizzare una sola tabella dati.
Puoi definire un massimo di due operazioni di arricchimento di qualsiasi tipo nella sezione
setupdi una regola YARA-L.
Nell'esempio seguente, un'operazione override viene applicata alla variabile del grafo di entità $g1 e un'operazione append viene applicata alla variabile del grafo di entità $g2.
none setup: graph_override($g1.graph.entity.user.userid = %table1.myids) graph_append [$g2, %table1]
Nell'esempio precedente, la stessa tabella di dati (table1) viene utilizzata per migliorare diversi grafici di entità. Puoi anche utilizzare tabelle di dati diverse per migliorare i diversi grafici delle entità, come segue:
none setup: graph_override($g1.graph.entity.user.userid = %table1.myids) graph_append [$g2, %table2]
Limitazioni relative all'utilizzo delle tabelle di dati con la Ricerca
Le seguenti limitazioni si applicano alle tabelle di dati quando vengono utilizzate con la Ricerca:
Una singola esecuzione di query può generare un massimo di 1 milione di righe in una tabella di dati o 1 GB, a seconda del limite raggiunto per primo.
L'output della ricerca in una tabella di dati salta le righe degli eventi se superano i 5 MB.
L'arricchimento delle entità non è supportato con la Ricerca.
Le tabelle di dati non sono supportate per gli utenti con chiavi di crittografia gestite dal cliente (CMEK).
Le scritture sono limitate a 6 al minuto per cliente.
La tabella dei dati e i join della tabella dei dati sono supportati solo con gli eventi UDM e non con le entità.
Supportato:
%datatable1.column1 = %datatable2.column1Non supportato:
graph.entity.hostname = %sample.testNon puoi includere una variabile
matchnella sezioneexportdi una query di statistiche.Ad esempio, non è supportato quanto segue:
match: principal.hostname export: %sample.write_row( row: principal.hostname )
Limitazioni durante la ridenominazione o l'eliminazione di tabelle di dati con l'API Chronicle o Terraform
- La ridenominazione non è supportata tramite la piattaforma o l'API.
- Non puoi eliminare una tabella dati (tramite la piattaforma o l'API) se è presente un riferimento a una regola.
- In Terraform, la ridenominazione di una tabella di dati attiva un'operazione di eliminazione e ricreazione. Se la tabella dati è indicata da una regola, questa operazione non andrà a buon fine perché l'API blocca l'eliminazione della vecchia tabella.
- Rischio di perdita di dati in Terraform: anche se una tabella di dati non è richiamata da una regola, la ridenominazione con Terraform comporta la perdita permanente dei dati. Terraform elimina la tabella esistente e la sostituisce con una nuova tabella vuota che non conserva i dati dell'originale.
- Soluzione alternativa consigliata:
- Crea una nuova tabella di dati con il nuovo nome.
- Aggiorna le regole per iniziare a utilizzare la nuova tabella dati.
- Elimina la vecchia tabella di dati.
Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.