Utilizzare le tabelle di dati

Le tabelle di dati sono costrutti di dati multicolonna che ti consentono di inserire i dati in Google Security Operations. 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 YARA-L.

Assegnare ambiti alle tabelle di dati utilizzando RBAC per i dati

Per utilizzare le tabelle di dati, devi assegnare gli ambiti alle tabelle di dati utilizzando il controllo dell'accesso basato sui ruoli per i dati (RBAC per i dati). Assegnando ambiti a una tabella di dati, puoi controllare quali utenti e risorse possono accedervi e utilizzarla. Per ulteriori informazioni, consulta Configurare il controllo dell'accesso basato sui ruoli per le tabelle di dati.

Gestire le tabelle di dati utilizzando l'interfaccia web di Google SecOps

Le sezioni seguenti descrivono come gestire le tabelle di dati utilizzando l'interfaccia web, incluso come accedere alle tabelle di dati, aggiungere una nuova tabella di dati e modificarne i contenuti, importare i dati nella tabella, aggiungere righe, separare i dati utilizzando virgole o tabulazioni e come rimuovere una tabella di dati dal tuo account.

Accedere alle tabelle di dati

Per accedere alla pagina Tabelle di dati:

• Nella barra laterale sinistra, seleziona Indagine > Tabelle di dati.

Per trovare una tabella di dati specifica, inserisci il nome nel campo Cerca nella parte superiore della barra laterale.

Aggiungere una nuova tabella di dati

Per aggiungere una nuova tabella di dati a Google SecOps, completa i seguenti passaggi:

1. Fai clic su add Crea in alto a destra della barra laterale.

2. Nella finestra di dialogo Crea nuova tabella di dati, assegna un nome alla nuova tabella e, se vuoi, aggiungi una descrizione.

3. Fai clic su Crea. La nuova tabella di dati viene visualizzata nella finestra principale ed è pronta a ricevere i dati.

Importare i dati nella tabella dei dati

Per aggiungere dati alla tabella di dati, puoi importarli direttamente in Google SecOps nel seguente modo:

1. Fai clic su Importa dati.

2. Seleziona un file CSV standard (solo i file CSV possono essere importati in Google SecOps).

3. Fai clic su Apri quando è tutto pronto per importare i dati nella tabella dei dati.

Mappare i tipi di dati alle colonne della tabella dei dati

Puoi mappare i campi dati singoli a una colonna di dati e mappare i campi dati ripetuti a una colonna di dati utilizzando l'interfaccia web o l'API, nel seguente modo:

• Sia nell'interfaccia web che nell'API, separa i valori dei campi di dati utilizzando il carattere |. Nell'interfaccia web, se un valore include il carattere |, viene considerato un valore ripetuto per impostazione predefinita.

• Per le richieste API, imposta repeated_values su true.

Per ulteriori informazioni, vedi Campi ripetuti.

Nell'esempio seguente, la colonna Field_value della tabella dei dati contiene valori per più campi:

La tabella precedente è suddivisa in quattro colonne, ognuna delle quali è mappata a un solo tipo di campo prima di poter essere utilizzata per uno qualsiasi dei casi d'uso della tabella dei dati presentati in questo documento.

Designare colonne specifiche come colonne chiave

Se contrassegni una colonna come colonna chiave, i valori in quella colonna vengono identificati in modo univoco, si evita la duplicazione dei dati e si migliora l'individuazione dei dati per le regole e le ricerche.

Designare colonne specifiche per supportare i campi ripetuti

Le colonne destinate ad archiviare campi multivalore o campi ripetuti devono essere designate esplicitamente come ripetute al momento della creazione della tabella di dati.

Mappare i nomi delle colonne ai campi delle entità (facoltativo)

Quando crei una tabella di dati, puoi mappare i nomi delle colonne della tabella di 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:

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 dell'entità definito, ad esempio 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.

Aggiungere una nuova riga a una tabella di dati

Per aggiungere una nuova riga:

1. Nella scheda Dettagli, fai clic con il tasto destro del mouse su una riga esistente e seleziona Aggiungi riga sopra.

2. Inserisci i dati per una nuova riga, dove la prima riga viene trattata come intestazione della tabella:

   1. Separa i campi di dati utilizzando virgole o tabulazioni.
   2. Assicurati di abbinare ogni elemento di dati alla colonna di dati appropriata.
   3. Quando inserisci i dati di una riga nella scheda Dettagli, questi vengono compilati nell'editor della tabella.

Modificare una riga nella tabella dei dati

Per modificare una riga:

1. Fai clic sul campo che vuoi modificare. Il campo diventa modificabile.

2. Dopo aver apportato le modifiche, fai clic su Salva.

Specifica se utilizzare virgole o tabulazioni per separare i dati

Per separare i dati utilizzando virgole o tabulazioni:

1. Fai clic su grid_view Modifica tipo di separatore accanto a Importa dati.

2. Nella finestra di dialogo Modifica tipo di separatore, seleziona Virgola o Tabulazione dal menu Separatore.

Cerca nelle righe della tabella 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 della riga della tabella

Per gestire il valore di durata (TTL) per le righe della tabella:

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 sull'ora di Scadenza predefinita delle righe per visualizzare la finestra di dialogo Aggiorna la scadenza predefinita delle righe e regolare il TTL delle righe della tabella.

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

4. Fai clic su Salva.

Eliminare una riga della tabella

Per eliminare una riga, fai clic con il tasto destro del mouse sulla riga e seleziona Elimina riga/e.

Per eliminare più righe, seleziona ogni riga da rimuovere. Poi fai clic con il tasto destro del mouse su una riga selezionata e scegli Elimina riga/e.

Rimuovere una tabella di dati

Per rimuovere una tabella di dati:

1. Seleziona una tabella di dati dall'elenco Tabelle di dati a sinistra.

2. Fai clic su Elimina.

Gestire 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 consentono di gestire le tabelle di dati con prestazioni migliori e su una scala più ampia.

Ecco le risorse REST della tabella di dati:

• dataTables

• dataTableRows

• dataTableOperationErrors

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

Utilizzare le tabelle di dati in Google SecOps

Una volta importate le tabelle di dati nell'istanza di Google SecOps, puoi utilizzarle per filtrare, migliorare e arricchire i dati utilizzando le query YARA-L. Questo documento include numerosi esempi nella 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:

• Filtrare i dati di eventi o 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.

• Utilizzare una tabella di 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 sola dimensione, le tabelle di dati ti consentono di accedere ai dati in più dimensioni, consentendo il filtraggio dei dati.

• Unire una tabella di dati a un evento o un'entità. Puoi collegare gli eventi UDM a una tabella di dati utilizzando l'operatore di uguaglianza (=) per i confronti basati sulle righe. Questo confronto ti consente di filtrare i dati. Un confronto basato sulle righe viene valutato come true solo se tutte le condizioni nell'istruzione corrispondono a una singola riga nella tabella dei dati.

Filtrare i dati di eventi ed entità UDM utilizzando una tabella di dati

Puoi filtrare gli eventi e le entità UDM confrontandoli con le voci di una tabella di dati.

Collega gli eventi UDM alle tabelle di dati in uno dei seguenti modi:

• Utilizzo di un operatore di uguaglianza (=, !=, >, >=, <, <=) per il confronto basato sulle righe. Ad esempio, $<udm_variable>.<field_path> = %<data_table_name>.<column_name>.

• Utilizzo della parola chiave in per il confronto basato sulle colonne. Ad esempio, $<udm_variable>.<field_path> in %<data_table_name>.<column_name>.`

Come per gli elenchi di riferimento, i tipi di dati supportati per ogni colonna della tabella di dati possono essere number, string, regex o CIDR.

Per utilizzare una colonna della tabella dei dati di tipo number per confronti e unioni basati sulle colonne, utilizza la seguente sintassi. Questo esempio cerca eventi che includono target.port 8080.

%table.number_field = target.port
%table.number_field = 8080
target.port in %table.number_field

Per utilizzare una colonna della tabella dei dati di tipo CIDR o regex per il confronto basato sulle 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 utilizzare una colonna della tabella dei dati di tipo CIDR o regex per il confronto basato sulle 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 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

Utilizzare una tabella di 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 (una colonna), le tabelle di dati supportano più colonne, consentendoti di filtrare e accedere ai dati in diverse dimensioni.

Puoi collegare gli eventi UDM a una tabella di dati utilizzando la parola chiave in per il confronto basato sulle colonne, in modo da confrontare i valori di un campo UDM specifico con i valori di una singola colonna della tabella di dati.

Nell'esempio seguente, la tabella dei 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 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

Unire una tabella dati a 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 corrispondenti ai valori degli eventi UDM rispetto alle righe della tabella di dati. Se utilizzi più istruzioni di confronto, tutti i campi o le condizioni devono corrispondere alla stessa riga della tabella di dati.

Per utilizzare gli operatori (ad esempio not, !=, >, >=, <, <=) nella query, devi includere almeno una condizione join tra i campi UDM e le righe della tabella di dati. Google SecOps considera qualsiasi regola con una tabella di dati join come una regola multi-evento, che richiede di includere anche una sezione match nella definizione della regola.

Quando si verifica un join, le righe della tabella di dati collegata sono visibili nella Ricerca. Per saperne di più, vedi Visualizzare le righe della tabella di dati nella ricerca.

L'esempio seguente utilizza una colonna della tabella dei dati di tipo string. Questa query YARA-L controlla se un evento di accesso utente corrisponde a una riga in example_table verificando che user ID esista nella tabella. Entrambe le condizioni devono corrispondere alla stessa riga della tabella dei dati affinché la regola venga attivata.

// Check if a user exists in a data table and that the user is active for all user login events.

Esempio di regola:

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 table where the uid in the table
// row is the userid on the event and the active date in the same 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 table where the uid in the table
// row is the userid on the event and the active date in the same table
// row is before the event timestamp
%example_table.uid = $userid
$e.principal.hostname = %example_table.hostname

Il seguente esempio illustra come funzionano insieme una tabella di dati e i dati degli 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.

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

Scrivere 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 di una tabella di dati con la chiave corrispondente nella tabella di 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 dei dati deve essere l'azione finale della query. In questo modo, le variabili di risultato vengono scritte nella tabella dei dati.

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

Modificare 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)

* indica la chiave primaria.

La seguente query acquisisce combinazioni uniche di principal.ip, principal.user.employee_id e target.domain. Filtra i risultati in base alla prevalenza di target.domain:

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 della query:

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: Understanding write_row

Nell'esempio seguente, user e ip vengono utilizzati come chiavi primarie. Ogni rilevamento che persiste nella tabella dei rilevamenti comporta 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 dell'evento:

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
}

Quando questa query viene eseguita come regola, vengono restituiti i seguenti rilevamenti:

La tabella dei dati contiene quanto segue:

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)

Arricchire il grafico delle entità con una tabella dati

Puoi utilizzare le tabelle di dati per aggiungere, rimuovere o sostituire le entità presentate nel grafico delle entità dalle regole. Utilizza le funzioni nella sezione setup della regola per indicare in che modo la tabella dei dati deve essere unita, aggiunta o utilizzata per rimuovere le entità dagli eventi entità a cui viene fatto riferimento nella sezione events.

Puoi utilizzare il seguente modello di regola per modificare un grafico delle entità:

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 di dati e una variabile dell'evento entità anziché una condizione di unione.

  Nell'esempio seguente, $g1 è la variabile del grafico delle entità e example_table è la tabella dei 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 (mappato su metadata.interval.start_time.seconds)

  • end_time (mappato su metadata.interval.end_time.seconds)

  Non è possibile mappare le colonne della tabella di dati 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://cloud.google.com/chronicle/docs/reference/rest/v1alpha/projects.locations.instances.dataTables/create)

• graph_exclude: rimuovi le righe nel grafico 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 grafico delle entità. Per le funzioni graph_override e graph_exclude, la sintassi per accedere a una tabella di dati è la seguente:

<data_table_name>.<column_name>

Qualsiasi filtro specificato per <entity_variable> nella sezione Evento viene applicato dopo il miglioramento con la tabella dei dati.

Dopo che l'entità nel grafico delle entità è stata arricchita con l'entità nella tabella di dati, la variabile dell'entità nel grafico delle entità deve essere unita all'entità UDM.

Eseguire 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 dati vengono sostituiti con i campi della tabella dati. I campi presenti nel grafico delle entità e non nella tabella di dati rimangono invariati. Sono inclusi i campi non presenti nel grafico delle entità, ma presenti nella tabella dei dati.

Solo le colonne della tabella dei dati mappate eseguono l'override delle 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 una singola unione

Nell'esempio seguente, le righe del 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.

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, utilizza un'istruzione equivalente per $g1.graph.entity.owner = "alice" is $g1.graph.additional.fields["Owner"] = "alice". Questo perché tutte le colonne non mappate della tabella dei 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à.

Esempio: corrispondenza su più unioni

Nell'esempio seguente, le righe del 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.

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 nome host nella tabella dei dati corrispondono al campo IP e al campo nome host nel grafico delle entità.

Aggiungere i dati dalla tabella dati al grafico delle entità

Con la funzione graph_append, non è necessaria alcuna condizione di join.

Nell'esempio seguente, tutte le righe della tabella dei dati vengono aggiunte alle righe del grafico delle entità.

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 accodamento in cui le righe della tabella di dati vengono accodate alle righe del grafico delle entità:

Utilizza graph_exclude per rimuovere righe dal grafico delle entità

Con la funzione graph_exclude, le righe del grafico delle entità che corrispondono alla condizione di join vengono rimosse dal grafico 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 dei dati e il campo del grafico delle entità). Nessuna riga della tabella di dati viene aggiunta al grafico delle entità.

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 tabelle seguenti illustrano un'operazione di esclusione in cui vengono rimosse le righe del grafico delle entità che corrispondono al campo IP della tabella dei dati:

Limitazioni

• Numero massimo di tabelle di dati per un account Google SecOps: 1000.

• Per i caricamenti è supportato solo il tipo di file CSV.

• I limiti al 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: 10

• Numero massimo di istruzioni in in una query per colonne di tipo di dati String e Number: 7

• Numero massimo di istruzioni in con operatori di espressioni regolari: 4

• Numero massimo di istruzioni in con operatori CIDR: 2

• Numero massimo di colonne per tabella di dati: 1000.

• Numero massimo di righe per tabella di dati: 10 milioni.

• Limite aggregato massimo del volume di dati nelle tabelle di dati di un account: 1 TB.

• Limite massimo di visualizzazione nella pagina web per le righe della tabella di dati nella visualizzazione dell'editor di testo e tabelle: 10.000 righe

• Limite massimo di righe durante il caricamento di un file in una nuova tabella di dati nella pagina web: 10.000 righe

• Limite massimo per le dimensioni del caricamento dei file per la creazione di tabelle di dati dall'API: 1 GB

• I segnaposto non sono consentiti nella sezione di configurazione.

• Le colonne non mappate di una tabella dati con il 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.

• Ricerca nelle tabelle di dati: i caratteri jolly delle espressioni regolari non sono supportati e i termini di ricerca sono limitati a 100 caratteri.

Unioni

• Il recupero di tutti i campioni di eventi per i rilevamenti non è supportato quando si utilizzano unioni di tabelle di dati con eventi.

• A differenza di entità e UDM, le tabelle di dati non supportano i segnaposto. Ciò significa che non puoi:

  • Applica un insieme di filtri a una tabella di dati e uniscila a un'entità UDM.

  • Applica un insieme diverso di filtri alla stessa tabella di dati mentre la unisci a 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"
  

Vengono applicati prima tutti i filtri di una tabella di dati, poi le righe filtrate della tabella di dati vengono unite a UDM. In questo caso, una tabella dei dati vuota viene unita a e1 e e2 perché i due filtri nella tabella dei dati dt si contraddicono a vicenda (%dt.org ="hr" and %dt.org !="hr").

Utilizzare le tabelle di dati con le regole

Alle tabelle di dati si applicano le seguenti limitazioni quando vengono utilizzate con le regole.

Frequenza di esecuzione

La frequenza di esecuzione in tempo reale non è supportata per le regole con tabelle di dati.

Output nelle tabelle di 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 le variabili di risultato solo in una tabella di dati. Non puoi esportare direttamente le colonne del percorso evento o della tabella dei dati.

• Gli elenchi di colonne devono includere le colonne della chiave primaria per le tabelle di dati.

• Non puoi avere più di 20 risultati.

• Se una tabella di dati non esiste, ne viene creata una nuova con il tipo di dati stringa predefinito per tutte le colonne, seguendo l'ordine specificato.

• Solo una regola può scrivere in una tabella di dati alla volta. Se una regola tenta di scrivere in una tabella di dati in cui un'altra regola sta già scrivendo, la compilazione della regola non riesce.

• Non è garantito che una regola del produttore possa aggiungere righe a una tabella di dati prima dell'inizio di una regola del consumatore per quella tabella di dati.

• Una regola ha un limite al numero di righe di risultati. Un limite di 10.000 righe si applica ai risultati e ai dati persistenti. Lo stesso limite si applica alle tabelle di dati: una singola esecuzione della regola può generare un massimo di 10.000 righe in una tabella di dati.

• Se nella tabella dei dati esiste già una riga con la stessa chiave primaria, le colonne della chiave non primaria verranno sostituite con i nuovi valori.

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ò essere eseguita utilizzando una sola tabella di 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 di override viene applicata alla variabile del grafico delle entità $g1 e un'operazione append viene applicata alla variabile del grafico delle entità $g2.

    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 delle entità. Puoi anche utilizzare tabelle di dati diverse per migliorare i vari grafici delle entità, come segue:

    setup:
    graph_override($g1.graph.entity.user.userid = %table1.myids)
    graph_append [$g2, %table2]

Utilizzare le tabelle di dati con la ricerca

Le seguenti limitazioni si applicano alle tabelle di dati quando vengono utilizzate con la Ricerca.

• Non puoi eseguire query di ricerca sulle tabelle di dati utilizzando l'API Chronicle. Puoi eseguire query di ricerca solo dall'interfaccia web.

• Una singola esecuzione della query può restituire un massimo di 1 milione di righe a una tabella di dati o 1 GB, a seconda di quale dei due limiti viene raggiunto per primo.

• L'output della ricerca in una tabella di dati ignora 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 i clienti che utilizzano chiavi di crittografia gestite dal cliente (CMEK).

• Le scritture sono limitate a 6 al minuto per cliente.

• Il supporto API non è disponibile.

• Le query statistiche non sono supportate con le unioni di tabelle di dati.

• La tabella di dati e l'unione di tabelle di dati sono supportate 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 query delle statistiche nella sezione export.

  Ad esempio, non è supportato quanto segue:

  match:
      principal.hostname
  export:
      %sample.write_row(
      row: principal.hostname
    )

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