Cerca nelle tabelle di dati

Supportata in:

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:

Per aggiungere una nuova tabella di dati a Google SecOps, segui questi passaggi:

  1. Nella barra laterale, seleziona Indagine > Tabelle dati.

  2. Nella parte superiore della barra laterale Tabelle dati, fai clic su Crea.

  3. Nella finestra di dialogo Crea nuova tabella dati, assegna un nome alla tabella e, facoltativamente, aggiungi una descrizione.

  4. 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:
    1. Fai clic su Importa file.
    2. Vai al file e fai clic su Apri. Viene visualizzata la finestra di dialogo Importa file.
    3. Se nel passaggio precedente hai selezionato un file TSV, segui questi passaggi:
      1. Dall'elenco Tipo di separatore, seleziona Rileva automaticamente o Tabulazione.
      2. Nell'elenco Avvia importazione dalla riga, specifica la riga del file da cui importare i dati.
    4. Fai clic su Importa dati.
  5. Seleziona la modalità di modifica Tabella e configura quanto segue in base alle tue esigenze:

  6. 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_values su true.

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)
Email 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:

  1. Nella scheda Dettagli, seleziona la modalità di modifica Tabella.
  2. Fai clic con il tasto destro del mouse su una riga esistente e seleziona Aggiungi riga sopra.
  3. 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.
  4. Fai clic su Salva.

Modifica una riga in una tabella di dati

Per modificare una riga:

  1. Fai clic sul campo da modificare. Il campo diventa modificabile.
  2. Apporta le modifiche.
  3. 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:

  1. 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.

  2. 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.

  3. Inserisci un nuovo valore TTL in Ore o Giorni. Il valore minimo è 1 ora. Il valore massimo è 365 giorni.

  4. 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:

  1. Seleziona una tabella di dati dall'elenco Tabelle di dati nella barra laterale.

  2. 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 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:

  • 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 condizione join tra i campi UDM e le righe della tabella di dati.

    • Google SecOps tratta qualsiasi regola con una tabella di dati join come una regola multievento, che richiede una sezione match nella 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 sezione events e specifica $e and #<data_table_name> = 0 nella sezione condition. In alternativa, includi #<data_table_name> >= 0 nella sezione condition in modo che il compilatore esegua un join esterno sinistro (ad esempio, $e and #<data_table_name> >= 0 and $match_count = 0 quando conteggia le righe corrispondenti in outcome utilizzando $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): ripeti left join su ogni colonna unita nella sezione events (ad esempio, left join $e.field1 = %<data_table_name>.col1 e left join $e.field2 = %<data_table_name>.col2) e aggiungi #<data_table_name> = 0 nella sezione condition (o conteggia una colonna corrispondente in outcome e valuta $match_count = 0 in condition).
      • Senza una sezione match (dashboard e ricerca multifase non aggregata): inserisci le istruzioni left join ripetute in un stage denominato che restituisce una colonna della tabella di dati in outcome (ad esempio, $matched_col = %<data_table_name>.<column_name>), filtra per $<stage_name>.matched_col = "" nella sezione events principale (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 sezione outcome principale.
    • Sintassi di join errata:

    • Non racchiudere NOT tra 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, NOT restituisce true, 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 controlli in basati su colonne valutano ogni colonna in modo indipendente nell'intera tabella di dati, escludendo un evento se field1 viene visualizzato in una riga e field2 in 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 CIDR o regex per 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>)
    
  • 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 CIDR o regex per 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_name
    
  • Quando confronti le colonne nelle tabelle di dati che sono tipi di dati CIDR o espressioni regolari, le parole chiave cidr e regex sono facoltative.

  • Puoi anche utilizzare l'operatore not con 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 colonna benign_ip in cidr_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 event di 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 ID esista in example_table.
      • Entrambe le condizioni devono corrispondere alla stessa riga in example_table affinché la regola venga attivata.
    • 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 32452 viene visualizzato nel rilevamento come hostname dell'utente dal sistema e corrisponde a hostname nella 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 keys
    
  • Esempio: 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'operazione graph_append richiede 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à e example_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 a metadata.interval.start_time.seconds)

    • end_time (mappata a metadata.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 condizione join.

    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 in quando si fa riferimento a un elenco di riferimento in una query si applicano anche alle istruzioni in in una tabella di dati.

  • Numero massimo di istruzioni in in una query per le colonne tipizzate con tipo di dati String e Number: 10.

  • Numero massimo di istruzioni in con operatori di espressioni regolari: 5.

  • Numero massimo di istruzioni in con 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 string possono 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 cidr o regex per 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 dt con tre colonne: my_hostname, org e my_email e 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 any e all non 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 string predefinito 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, append o exclude) 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 setup di 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.column1

    Non supportato: graph.entity.hostname = %sample.test

  • Non puoi includere una variabile match nella sezione export di 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.