Estensioni del parser

Supportato in:

Questo documento spiega come creare estensioni del parser per estrarre i campi dai dati di log non elaborati e mapparli ai campi UDM (Unified Data Model) di destinazione all'interno della piattaforma Google Security Operations.

Il documento illustra la procedura di creazione dell'estensione del parser:

Creare estensioni del parser

Le estensioni del parser offrono un modo flessibile per estendere le funzionalità dei parser predefiniti (e personalizzati) esistenti. Non sostituiscono i parser predefiniti (e personalizzati), ma consentono una personalizzazione senza problemi della pipeline del parser, attivando una nuova logica di analisi e l'estrazione, la manipolazione e la mappatura dei campi.

Un'estensione del parser non è la stessa cosa di un parser personalizzato. Puoi creare un parser personalizzato per il tipo di log che non ha un parser predefinito o disattivare gli aggiornamenti del parser.

Processo di estrazione e normalizzazione del parser

Google SecOps riceve i dati dei log originali come log non elaborati. Gli analizzatori sintattici predefiniti (e personalizzati) estraggono e normalizzano i campi dei log principali in campi UDM strutturati nei record UDM. Questo rappresenta solo un sottoinsieme dei dati dei log non elaborati originali. Puoi definire estensioni del parser per estrarre i valori dei log non gestiti dai parser predefiniti. Una volta attivate, le estensioni del parser diventano parte del processo di estrazione e normalizzazione dei dati di Google SecOps.

Flusso di lavoro di importazione e normalizzazione

Definire nuove estensioni del parser

I parser predefinite contengono insiemi predefiniti di istruzioni di mappatura che specificano come estrarre, trasformare e normalizzare i valori di sicurezza di base. Puoi creare nuove estensioni del parser definendo istruzioni di mappatura utilizzando l'approccio no-code (Mappa i campi di dati) o l'approccio dello snippet di codice:

  • Approccio no-code

    L'approccio senza codice è ideale per estrazioni semplici dai log non elaborati in formato JSON, XML o CSV nativo. Ti consente di specificare i campi di origine dei log non elaborati e di mappare i campi UDM di destinazione corrispondenti.

    Ad esempio, per estrarre i dati dei log JSON con fino a 10 campi, utilizzando semplici confronti di uguaglianza.

  • Approccio basato su snippet di codice

    L'approccio con snippet di codice consente di definire istruzioni per estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM. Gli snippet di codice utilizzano la stessa sintassi di Logstash del parser predefinito (o personalizzato).

    Questo approccio è applicabile a tutti i formati di log supportati. È ideale per questi scenari:

    • Estrazioni di dati complesse o logica complessa.
    • Dati non strutturati che richiedono analizzatori basati su Grok.
    • Formati non JSON come CSV e XML.

    Gli snippet di codice utilizzano funzioni per estrarre dati specifici dai dati non elaborati dei log. Ad esempio, Grok, JSON, KV e XML.

    Nella maggior parte dei casi, è preferibile utilizzare l'approccio di mappatura dei dati utilizzato nel parser predefinito (o personalizzato).

Unisci i valori appena estratti nei campi UDM

Una volta attivate, le estensioni del parser uniscono i valori appena estratti ai campi UDM designati nel record UDM corrispondente in base a principi di unione predefiniti. Ad esempio:

  • Sovrascrive i valori esistenti: i valori estratti sovrascrivono i valori esistenti nei campi UDM di destinazione.

    L'unica eccezione sono i campi ripetuti, in cui puoi configurare l'estensione del parser per accodare nuovi valori durante la scrittura dei dati in un campo ripetuto nel record UDM.

  • L'estensione del parser ha la precedenza: le istruzioni di mappatura dei dati in un'estensione del parser hanno la precedenza su quelle nel parser predefinito (o personalizzato) per quel tipo di log. In caso di conflitto nelle istruzioni di mappatura, l'estensione del parser sovrascriverà il valore impostato per impostazione predefinita.

    Ad esempio, se l'interprete predefinito mappa un campo del log non elaborato al campo UDM event.metadata.description e l'estensione dell'interprete mappa un altro campo del log non elaborato allo stesso campo UDM, l'estensione dell'interprete sovrascrive il valore impostato dall'interprete predefinito.

Limitazioni

  • Una sola estensione del parser per tipo di log: puoi creare una sola estensione del parser per tipo di log.
  • Un solo approccio alle istruzioni di mappatura dei dati: puoi creare un'estensione del parser utilizzando l'approccio no-code o lo snippet di codice, ma non entrambi.
  • Sample di log per la convalida: sono necessari sample di log degli ultimi 30 giorni per convalidare un'estensione del parser UDM. Per informazioni dettagliate, vedi Assicurati che sia presente un parser attivo per il tipo di log.
  • Errori del parser di base: non sono identificabili o correggibili all'interno delle estensioni del parser.
  • Campi ripetuti negli snippet di codice: presta attenzione quando sostituisci interi oggetti ripetuti negli snippet di codice per evitare perdite di dati indesiderate. Per maggiori dettagli, consulta Ulteriori informazioni sul selettore dei campi ripetuti.
  • Eventi disambiguati: le estensioni dell'analizzatore non possono gestire i log con più eventi unici in un singolo record, ad esempio l'array di Google Drive.
  • XML e senza codice: l'approccio senza codice non è consigliato per XML a causa di potenziali problemi di codifica. Utilizza l'approccio basato sugli snippet di codice per XML.
  • Nessun dato retroattivo: non puoi analizzare i dati dei log non elaborati in modo retroattivo.

Concetti relativi ai parser

I seguenti documenti spiegano concetti importanti relativi ai parser:

Prerequisiti

Prerequisiti per la creazione di estensioni del parser:

  • Deve essere presente un parser predefinito (o personalizzato) attivo per il tipo di log.
  • Google SecOps deve essere in grado di importare e normalizzare i log non elaborati utilizzando un parser predefinito (o personalizzato).
  • Assicurati che l'interprete predefinito (o personalizzato) attivo per il tipo di log di destinazione abbia acquisito i dati dei log non elaborati negli ultimi 30 giorni. Questi dati devono contenere un campione dei campi che intendi estrarre o utilizzare per filtrare i record dei log. Verrà utilizzato per convalidare le nuove istruzioni di mappatura dei dati.

Inizia

Prima di creare un'estensione del parser, segui questi passaggi:

  1. Verifica i prerequisiti:

    Assicurati che sia presente un parser attivo per il tipo di log. Se non è ancora presente un parser, crea un parser personalizzato.

  2. Identifica i campi da estrarre dai log non elaborati:

    Identifica i campi da estrarre dai log non elaborati.

  3. Seleziona i campi UDM appropriati:

    Seleziona i campi UDM corrispondenti appropriati per mappare i campi dei log non elaborati estratti.

  4. Scegli un approccio di definizione dell'estensione del parser:

    Scegli uno dei due approcci di estensione (approcci di mappatura dei dati) per creare l'estensione del parser.

Verifica i prerequisiti

Assicurati che sia presente un parser attivo per il tipo di log che intendi estendere, come descritto nelle sezioni seguenti:

Assicurati che sia presente un parser attivo per il tipo di log

Assicurati che sia attivo un parser predefinito (o personalizzato) per il tipo di log che intendi estendere.

Cerca il tipo di log in questi elenchi:

Assicurati che sia presente un parser personalizzato per il tipo di log

Per assicurarti che esista un parser personalizzato per un tipo di log:

  1. Nella barra di navigazione, seleziona Impostazioni SIEM > Parser.

  2. Cerca nella tabella Parser il tipo di log da estendere.

Assicurati che l'analizzatore sia attivo per il tipo di log

Per verificare se un parser è attivo per un tipo di log, svolgi i seguenti passaggi:

  1. Nella barra di navigazione, seleziona Impostazioni SIEM > Parser.

  2. Cerca nella tabella Parser il tipo di log da estendere.

    Se l'analizzatore per il tipo di log non è attivo, attivalo:

Identifica i campi da estrarre dai log non elaborati

Analizza il log non elaborato da cui vuoi estrarre i dati per identificare i campi non estratto dall'interprete predefinito (o personalizzato). Presta attenzione a come l'interprete predefinito (o personalizzato) estrae i campi dei log non elaborati e li mappa ai campi UDM corrispondenti.

Per identificare i campi specifici da estrarre dai log non elaborati, puoi utilizzare gli strumenti di ricerca per identificare i campi:

Per informazioni dettagliate sulla ricerca nei log non elaborati, vedi:

Seleziona i campi UDM appropriati

Ora che hai identificato i campi target specifici da estrarre, puoi abbinarli ai campi UDM di destinazione corrispondenti. Stabilisci una mappatura chiara tra i campi delle origini dei log non elaborati e i relativi campi UDM di destinazione. Puoi mappare i dati a qualsiasi campo UDM che supporti i tipi di dati o i campi ripetuti standard.

Scegli il campo UDM corretto

Le seguenti risorse possono aiutarti a semplificare la procedura:

Acquisisci familiarità con i concetti principali di UDM

Comprendi la mappatura dei dati utilizzata dal parser esistente

Ti consigliamo di comprendere la mappatura dei dati esistente utilizzata dall'interprete predefinito (o personalizzato) tra i campi di origine dei log non elaborati e i campi UDM di destinazione.

Per visualizzare la mappatura dei dati tra i campi di origine dei log non elaborati e i campi UDM di destinazione utilizzati nell'attuale parser predefinito (o personalizzato):

  1. Nella barra di navigazione, seleziona Impostazioni SIEM > Parser.
  2. Cerca nella tabella Parser il tipo di log da estendere.

  3. Vai a quella riga, quindi fai clic su Menu > Visualizza.

    La scheda Codice del parser mostra la mappatura dei dati tra i campi di origine dei log non elaborati e i campi UDM di destinazione utilizzati nel parser predefinito (o personalizzato) esistente.

Utilizzare lo strumento di ricerca UDM

Utilizza lo strumento di ricerca UDM per identificare i campi UDM corrispondenti ai campi dell'origine log non elaborati.

Google SecOps fornisce lo strumento di ricerca UDM per aiutarti a trovare rapidamente i campi UDM di destinazione. Per accedere allo strumento di ricerca UDM, vai a Indagine > Ricerca SIEM.

Per informazioni dettagliate su come utilizzare lo strumento di ricerca UDM, consulta questi argomenti:

Esempio di strumento di ricerca UDM

Ad esempio, se nel log non elaborato è presente un campo di origine denominato "packets", utilizza lo strumento di ricerca UDM per trovare potenziali campi UDM di destinazione con "packets" nel nome:

  1. Vai a Indagine > Ricerca SIEM.

  2. Nella pagina Ricerca SIEM, inserisci "packets" nel campo Cerca campi UDM per valore e poi fai clic su Ricerca UDM.

    Viene visualizzata la finestra di dialogo Ricerca UDM. Lo strumento di ricerca trova corrispondenze tra i campi UDM in base al nome del campo o al valore del campo:

    • Ricerca per nome del campo: abbina la stringa di testo inserita ai nomi dei campi contenenti quel testo.
    • Ricerca per valore del campo: abbina il valore inserito ai campi che contengono quel valore nei dati dei log archiviati.

  3. Nella finestra di dialogo Ricerca UDM, seleziona Campi UDM.

    La funzione di ricerca mostrerà un elenco di potenziali campi UDM contenenti il testo "packets" nei nomi dei campi UDM.

  4. Fai clic su ogni riga una alla volta per visualizzare la descrizione di ciascun campo UDM.

Considerazioni importanti sull'UDM per evitare errori

  • Campi simili: la struttura gerarchica dell'UDM può generare campi con nomi simili. Per indicazioni, consulta gli analizzatori sintattici predefiniti. Per maggiori dettagli, consulta Informazioni sulla mappatura dei dati utilizzata dal parser esistente.
  • Mappatura dei campi arbitraria: utilizza l'oggetto additional per i dati che non vengono mappati direttamente a un campo UDM. Per maggiori dettagli, vedi Mappatura di campi arbitrari in UDM.
  • Campi ripetuti: fai attenzione quando utilizzi i campi ripetuti negli snippet di codice. La sostituzione di un intero oggetto potrebbe sovrascrivere i dati originali. L'approccio senza codice offre un maggiore controllo sui campi ripetuti. Per maggiori dettagli, consulta Ulteriori informazioni sul selettore dei campi ripetuti.
  • Campi UDM obbligatori per i tipi di eventi UDM: quando assegni un campo UDMmetadata.event_type a un record UDM, ogni event_type richiede un insieme diverso di campi correlati nel record UDM. Per maggiori dettagli, consulta Ulteriori informazioni sull'assegnazione dei campi metadata.event_type UDM.
  • Problemi del parser di base: le estensioni del parser non possono correggere gli errori del parser di base. Il parser di base è il parser predefinito (o personalizzato) che ha creato il record UDM. Valuta opzioni come il miglioramento dell'estensione del parser, la modifica del parser di base o il prefiltro dei log.
Mappatura dei campi arbitraria nell'UDM

Quando non riesci a trovare un campo UDM standard adatto per archiviare i dati, utilizza l'oggetto additional per archiviarli come coppia chiave-valore personalizzata. In questo modo, puoi memorizzare informazioni preziose nel record UDM, anche se non ha un campo UDM corrispondente.

Scegli un approccio di definizione dell'estensione del parser

Prima di scegliere un approccio di definizione dell'estensione del parser, devi aver esaminato queste sezioni:

I passaggi successivi sono aprire la pagina Estensioni del parser e selezionare l'approccio di estensione da utilizzare per definire l'estensione del parser:

Aprire la pagina Estensioni del parser

La pagina Estensioni del parser ti consente di definire la nuova estensione del parser.

Puoi aprire la pagina Estensioni del parser nei seguenti modi: dal menu Impostazioni, da una ricerca dei log non elaborati o da una ricerca dei log non elaborati precedente:

Aprire dal menu Impostazioni

Per aprire la pagina Estensioni dello scanner dal menu Impostazioni:

  1. Nella barra di navigazione, seleziona Impostazioni SIEM > Parser.

    La tabella Parser mostra un elenco di parser predefiniti per tipo di log.

  2. Individua il tipo di log che vuoi estendere, fai clic su Menu > Crea estensione.

    Viene visualizzata la pagina Estensioni dell'analizzatore sintattico.

Per aprire la pagina Estensioni dell'analizzatore sintattico da una ricerca nei log non elaborati:

  1. Vai a Indagine > Ricerca SIEM.
  2. Nel campo di ricerca, aggiungi il prefisso raw = all'argomento di ricerca e racchiudi il termine di ricerca tra virgolette. Ad esempio, raw = "example.com".
  3. Fai clic su Esegui ricerca. I risultati vengono visualizzati nel riquadro Log non elaborati.
  4. Fai clic su un log (riga) nel riquadro Log non elaborati. Viene visualizzato il riquadro Visualizzazione eventi.
  5. Fai clic sulla scheda Log non elaborato nel riquadro Visualizzazione eventi. Viene visualizzato il log non elaborato.

  6. Fai clic su Gestisci parser > Crea estensione > Avanti.

    Viene visualizzata la pagina Estensioni dell'analizzatore sintattico.

Per aprire la pagina Estensioni dell'analizzatore sintattico da una ricerca di log non elaborati legacy:

  1. Utilizza la ricerca dei log non elaborati precedente per cercare record simili a quelli che verranno analizzati.
  2. Seleziona un evento dal riquadro Eventi > Sequenza temporale.
  3. Espandi il riquadro Dati evento.

  4. Fai clic su Gestisci parser > Crea estensione > Avanti.

    Viene visualizzata la pagina Estensioni dell'analizzatore sintattico.

Pagina Estensioni parser

La pagina mostra i riquadri Log non elaborato e Definizione dell'estensione:

  • Riquadro Log non elaborati:

    Vengono visualizzati dati di log non elaborati di esempio per il tipo di log selezionato. Se hai aperto la pagina dalla Ricerca dei log non elaborati, i dati di esempio sono il risultato della ricerca. Puoi formattare il sample utilizzando il menu Visualizza come (RAW, JSON, CSV, XML e così via) e la casella di controllo A capo automatico.

    1. Verifica che il campione di dati dei log non elaborati visualizzato sia rappresentativo dei log che verranno elaborati dall'estensione dell'analizzatore.

    2. Fai clic su Anteprima output UDM per visualizzare l'output di UDM per i dati dei log non elaborati di esempio.

  • Riquadro Definizione dell'estensione:

    In questo modo puoi definire un'estensione del parser utilizzando uno dei due approcci di istruzione di mappatura: Mappa i campi di dati (senza codice) o Scrivere snippet di codice. Non puoi utilizzare entrambi gli approcci nella stessa estensione del parser.

    A seconda dell'approccio scelto, puoi specificare i campi dei dati dei log di origine da estrarre dai log non elaborati in entrata e mapparli ai campi UDM corrispondenti oppure puoi scrivere uno snippet di codice per eseguire queste attività e altro ancora.

Seleziona l'approccio di estensione

Nella pagina Estensioni del parser, nel riquadro Definizione dell'estensione, nel campo Metodo di estensione, seleziona uno dei seguenti approcci per creare l'estensione del parser:

  • Approccio Mappa i campi di dati (senza codice):

    Questo approccio ti consente di specificare i campi nel log non elaborato e mapparli ai campi UDM di destinazione.

    Questo approccio funziona con i seguenti formati di log non elaborati:

    • JSON nativo, XML nativo o CSV.
    • Intestazione syslog più JSON nativo, XML nativo o CSV. Puoi creare istruzioni di mappatura dei tipi di campi di dati per i log non elaborati nei seguenti formati: JSON, XML, CSV, SYSLOG + JSON, SYSLOG + XML e SYSLOG + CSV.

    Consulta i passaggi successivi, Istruzioni per la creazione di mappe senza codice (campi di dati).

  • Approccio Scrivi snippet di codice:

    Questo approccio ti consente di utilizzare la sintassi simile a Logstash per specificare istruzioni per estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM nel record UDM.

    • Gli snippet di codice utilizzano la stessa sintassi e le stesse sezioni dei parser predefinite (o personalizzate). Per ulteriori informazioni, consulta la Sintassi del parser.

    • Questo approccio funziona con tutti i formati di dati supportati per quel tipo di log.

    Per i passaggi successivi, consulta le istruzioni per creare snippet di codice.

Creare istruzioni senza codice (campi di dati mappa)

L'approccio senza codice (chiamato anche metodo Map data fields (Mappa campi dati)) ti consente di specificare i percorsi dei campi dei log non elaborati e mapparli ai campi UDM di destinazione corrispondenti.

Prima di creare un'estensione del parser utilizzando l'approccio senza codice, devi aver esaminato queste sezioni:

I passaggi successivi per definire l'estensione del parser sono:

  1. Impostare il selettore dei campi ripetuti
  2. Definire un'istruzione di mappatura dei dati per ogni campo
  3. Inviare e attivare l'estensione del parser

Impostare il selettore Campi ripetuti

Nel riquadro Definizione dell'estensione, nel campo Campi ripetuti, imposta la modalità di salvataggio di un valore da parte dell'estensione del parser nei campi ripetuti (campi che supportano un array di valori, ad esempio principal.ip):

  • Aggiunge valori: il valore appena estratto viene aggiunto all'insieme di valori esistente memorizzato nel campo dell'array UDM.
  • Sostituisci valori: il valore appena estratto sostituisce l'insieme di valori esistente nel campo dell'array UDM, precedentemente archiviato dall'interprete predefinito.

Le impostazioni nel selettore Campi ripetuti non influiscono sui campi non ripetuti.

Per maggiori dettagli, vedi Scopri di più sul selettore dei campi ripetuti.

Definisci un'istruzione di mappatura dei dati per ogni campo

Definisci un'istruzione di mappatura dei dati per ogni campo da estrarre dal log non elaborato. L'istruzione deve specificare il percorso del campo di origine nel log grezzo e mapparlo al campo UDM di destinazione.

  1. Se il Sample di log non elaborato visualizzato nel riquadro Log non elaborato contiene un Syslog, vengono visualizzati i campi Syslog e Destinazione. Alcuni formati di log non contengono un'intestazione Syslog, ad esempio JSON nativo, XML nativo o CSV.

    Google SecOps avrà bisogno dei campi Syslog e Target per pre-elaborare l'intestazione Syslog, in modo da estrarre la parte strutturata del log.

    1. Definisci questi campi:

      • Syslog: si tratta di un pattern definito dall'utente che esegue la preelaborazione e la separazione di un'intestazione Syslog dalla parte strutturata di un log non elaborato.

        Specifica il pattern di estrazione, utilizzando Grok ed espressioni regolari, che identifica l'intestazione Syslog e il messaggio di log grezzo. Per maggiori dettagli, vedi Definire i campi dell'estrattore Syslog.

      • Destinazione: nome della variabile nel campo Syslog che memorizza la parte strutturata del log.

        Specifica il nome della variabile nel pattern di estrazione che memorizza la parte strutturata del log.

      Questo è un esempio di pattern di estrazione e di nome di una variabile per i campi Syslog e Destinazione, rispettivamente.

      Campi dell'estrattore Syslog

    2. Dopo aver inserito i valori nei campi Syslog e Destinazione, fai clic sul pulsante Convalida.

      La procedura di convalida controlla sia gli errori di sintassi sia quelli di analisi, quindi restituisce uno dei seguenti valori:

      • Operazione riuscita: vengono visualizzati i campi di mappatura dei dati. Definisci il resto dell'estensione del parser.
      • Errore: viene visualizzato un messaggio di errore. Correggi la condizione di errore prima di continuare.

  2. (Facoltativo) Definisci un'istruzione di precondizione.

    Un'istruzione di precondizione identifica un sottoinsieme dei log non elaborati elaborati dall'estensione del parser abbinando un valore statico a un campo nel log non elaborato. Se un log non elaborato in entrata soddisfa i criteri di precondizionamento, l'estensione del parser applica l'istruzione di mappatura. Se i valori non corrispondono, l'estensione del parser non applica l'istruzione di mappatura.

    Completa i seguenti campi:

    • Campo precondizionale: identificatore del campo nel log non elaborato contenente il valore da confrontare. Inserisci il percorso completo del campo se il formato dei dati del log è JSON o XML oppure la posizione della colonna se il formato dei dati è CSV.
    • Operatore precondizione: seleziona EQUALS o NOT EQUALS.
    • Valore precondizionamento: il valore statico che verrà confrontato con il campo Precondizionamento nel log non elaborato.

    Per un altro esempio di istruzione di precondizionamento, consulta Senza codice - Estrarre campi con valore di precondizionamento.

  3. Mappa il campo dei dati di log non elaborati al campo UDM di destinazione:

    • Campo dati non elaborati: inserisci il percorso completo del campo se il formato dei dati del log è JSON (ad es. jsonPayload.connection.dest_ip) o XML (ad es. /Event/Reason-Code) oppure la posizione della colonna se il formato dei dati è CSV (nota: le posizioni dell'indice iniziano da 1).

    • Campo di destinazione: inserisci il nome completo del campo UDM in cui verrà memorizzato il valore, ad esempioudm.metadata.collected_timestamp.seconds.

  4. Per continuare ad aggiungere altri campi, fai clic su Aggiungi e inserisci tutti i dettagli delle istruzioni di mappatura per il campo successivo.

Per un altro esempio di mappatura dei campi, consulta Senza codice - Estrarre i campi.

Invia e attiva l'estensione del parser

Dopo aver definito le istruzioni di mappatura dei dati per tutti i campi che intendi estrarre dal log non elaborato, invia e attiva l'estensione dell'analizzatore.

Fai clic su Invia per salvare e convalidare l'istruzione di mappatura.

Google SecOps convalida le istruzioni di mappatura:

  • Se la procedura di convalida va a buon fine, lo stato diventa Pubblicata e le istruzioni di mappatura iniziano a elaborare i dati dei log in entrata.

  • Se la procedura di convalida non va a buon fine, lo stato diventa Non riuscita e viene visualizzato un errore nel campo Log non elaborato.

    Questo è un esempio di errore di convalida:

      ERROR: generic::unknown: pipeline.ParseLogEntry failed: LOG_PARSING_CBN_ERROR:
  "generic::invalid_argument: pipeline failed: filter mutate (7) failed: copy failure:
  copy source field \"jsonPayload.dest_instance.region\" must not be empty
  (try using replace to provide the value before calling copy)

  "LOG: {"insertId":"14suym9fw9f63r","jsonPayload":{"bytes_sent":"492",
  "connection":{"dest_ip":"10.12.12.33","dest_port":32768,"protocol":6,
  "src_ip":"10.142.0.238","src_port":22},"end_time":"2023-02-13T22:38:30.490546349Z",
  "packets_sent":"15","reporter":"SRC","src_instance":{"project_id":"example-labs",
  "region":"us-east1","vm_name":"example-us-east1","zone":"us-east1-b"},
  "src_vpc":{"project_id":"example-labs","subnetwork_name":"default",
  "vpc_name":"default"},"start_time":"2023-02-13T22:38:29.024032655Z"},
  "logName":"projects/example-labs/logs/compute.googleapis.com%2Fvpc_flows",
  "receiveTimestamp":"2023-02-13T22:38:37.443315735Z","resource":{"labels":
  {"location":"us-east1-b","project_id":"example-labs",
    "subnetwork_id":"00000000000000000000","subnetwork_name":"default"},
    "type":"gce_subnetwork"},"timestamp":"2023-02-13T22:38:37.443315735Z"}

    Stati del ciclo di vita di un'estensione del parser

    Le estensioni del parser hanno i seguenti stati del ciclo di vita:

  • DRAFT: estensione del parser appena creata che non è ancora stata inviata.

  • VALIDATING: Google SecOps convalida le istruzioni di mappatura rispetto ai log non elaborati esistenti per assicurarsi che i campi vengano analizzati senza errori.

  • LIVE: l'estensione del parser ha superato la convalida ed è ora in produzione. Estrae e trasforma i dati dai log non elaborati in arrivo in record UDM.

  • FAILED: l'estensione del parser non ha superato la convalida.

Scopri di più sul selettore dei campi ripetuti

Alcuni campi UDM memorizzano un array di valori, ad esempio il campo principal.ip. Il selettore Campi ripetuti ti consente di controllare in che modo l'estensione dell'analizzatore memorizza i dati appena estratti in un campo ripetuto:

  • Aggiungere valori:

    L'estensione dello scanner aggiungerà il nuovo valore estratto all'array di valori esistenti nel campo UDM.

  • Sostituisci valori:

    L'estensione dell'analizzatore sostituirà l'array di valori esistenti nel campo UDM con il valore appena estratto.

Un'estensione dell'analizzatore può mappare i dati a un campo ripetuto solo quando il campo ripetuto si trova al livello più basso della gerarchia. Ad esempio:

  • La mappatura dei valori a udm.principal.ip è supportata perché il campo ripetuto ip si trova al livello più basso della gerarchia e principal non è un campo ripetuto.
  • La mappatura dei valori a udm.intermediary.hostname non è supportata perchéintermediary è un campo ripetuto e non si trova al livello più basso della gerarchia.

La tabella seguente fornisce esempi di come la configurazione del selettore Campi ripetuti influisce sul record UDM generato.

Selezione Campi ripetuti Log di esempio Configurazione dell'estensione del parser Risultato generato
Aggiungi valori {"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":"admin@cmmar.co"},"requestMetadata":{"callerIp":"1.1.1.1, 2.2.2.2"}}} Campo precondizionamento: protoPayload.requestMetadata.callerIp
Valore precondizionamento: " "
Operatore precondizionamento: NOT_EQUALS
Campo dati non elaborati: protoPayload.requestMetadata.callerIp
Campo di destinazione: event.idm.read_only_udm.principal.ip 		metadata:{event_timestamp:{}.....}principal:{Ip:"1.1.1.1, 2.2.2.2"} } }
Aggiungi valori {"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":"admin@cmmar.co"},"requestMetadata":{"callerIp":"2.2.2.2, 3.3.3.3", "name":"Akamai Ltd"}}} Precondizione 1:
Campo precondizione:protoPayload.requestMetadata.callerIp
Valore precondizione: " "
Operatore precondizione: NOT_EQUALS
Campo dati non elaborati: protoPayload.requestMetadata.callerIp
Campo di destinazione: event.idm.read_only_udm.principal.ip

Precondizione 2:
Campo dati non elaborati: protoPayload.requestMetadata.name
Campo di destinazione: event.idm.read_only_udm.metadata.product_name

 Eventi generati dall'analizzatore precompilato prima dell'applicazione dell'estensione.
metadata:{event_timestamp:{} ... principal:{ip:"1.1.1.1"}}}

Output dopo l'applicazione dell'estensione.
timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} .... product_name: "Akamai Ltd"}principal:{ip:"1.1.1.1, 2.2.2.2, 3.3.3.3"}}}

Sostituisci valori {"protoPayload":{"@type":"type..AuditLog","authenticationInfo":{"principalEmail":"admin@cmmar.co"},"requestMetadata":{"callerIp":"2.2.2.2"}}} Campo precondizionamento: protoPayload.authenticationInfo.principalEmail
Valore precondizionamento: " "
Operatore precondizionamento: NOT_EQUALS
Campo dati non elaborati: protoPayload.authenticationInfo.principalEmail
Campo di destinazione: event.idm.read_only_udm.principal.ip 		Eventi UDM generati dall'analizzatore precompilato prima dell'applicazione dell'estensione.
timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} ... principal:{ip:"1.1.1.1"}}}

Output UDM dopo l'applicazione dell'estensione timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} ....} principal:{ip:"2.2.2.2"}}}

Scopri di più sui campi dell'estrattore Syslog

I campi dell'estrattore Syslog ti consentono di separare l'intestazione Syslog da un log strutturato definendo l'espressione regolare Grok, oltre a un token denominato nel pattern dell'espressione regolare per memorizzare l'output.

Definisci i campi dell'estrattore Syslog

I valori nei campi Syslog e Target agiscono insieme per definire in che modo l'estensione del parser separa l'intestazione Syslog dalla parte strutturata di un log non elaborato. Nel campo Syslog, definisci un'espressione utilizzando una combinazione di sintassi Grok ed espressioni regolari. L'espressione include un nome di variabile che identifica la parte strutturata del log non elaborato. Nel campo Destinazione, specifica il nome della variabile.

Il seguente esempio illustra il funzionamento combinato di questi campi.

Questo è un esempio di log non elaborato:

<13>1 2022-09-14T15:03:04+00:00 fieldname fieldname - - - {"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Il log non elaborato contiene le seguenti sezioni:

  • Intestazione syslog: <13> 2022-09-14T15:03:04+00:00 fieldname fieldname - - -

  • Evento in formato JSON: {"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Per separare l'intestazione Syslog dalla parte JSON del log non elaborato, utilizza la seguente espressione di esempio nel campo Syslog: %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg}

  • Questa parte dell'espressione identifica l'intestazione Syslog: %{TIMESTAMP\_ISO8601} %{WORD} %{WORD} ([- ]+)?
  • Questa parte dell'espressione acquisisce il segmento JSON del log non elaborato: %{GREEDYDATA:msg}

Questo esempio include il nome della variabile msg. Scegli il nome della variabile. L'estensione del parser estrae il segmento JSON del log non elaborato e lo assegna alla variabile msg.

Nel campo Destinazione, inserisci il nome della variabile msg. Il valore memorizzato nella variabilemsg viene inserito nelle istruzioni di mappatura dei campi di dati che crei nell'estensione del parser.

Utilizzando il log non elaborato di esempio, il seguente segmento viene inserito nell'istruzione di mappatura dei dati:

{"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Di seguito sono riportati i campi Syslog e Destinazione completati:

Campi dell&#39;estrattore Syslog

La tabella seguente fornisce altri esempi con log di esempio, il pattern di estrazione Syslog, il nome della variabile Target e il risultato.

Log non elaborato di esempio Campo Syslog Campo target Risultato
<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg} msg field_mappings { field: "msg" value: "{\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" }
<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\"} - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"} %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg1} ([- ]+)?%{GREEDYDATA:msg2} msg2 field_mappings { field: "msg2" value: "{\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" }
"<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\"} - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:message} ([- ]+)?%{GREEDYDATA:msg2} msg2 Error - message already exists in state and not overwritable.

Scopri di più sull'assegnazione dei campi metadata.event_type UDM

Quando assegni un campo metadata.event_type UDM a un record UDM, viene sottoposto a convalida per garantire che i campi correlati obbligatori siano presenti nel record UDM. Ogni metadata.event_type UDM richiede un insieme diverso di campi correlati. Ad esempio, un evento USER_LOGIN senza un user non è utile.

Se manca un campo correlato obbligatorio, la convalida UDM restituisce un errore:

  "error": {
    "code": 400,
    "message": "Request contains an invalid argument.",
    "status": "INVALID_ARGUMENT"
  }

Un parser Grok restituisce un errore più dettagliato:

  generic::unknown: 
  invalid event 0: LOG_PARSING_GENERATED_INVALID_EVENT: 
  "generic::invalid_argument: udm validation failed: target field is not set"

Per trovare i campi obbligatori per un event_type UDM che vuoi assegnare, utilizza le seguenti risorse:

  • Documentazione di Google SecOps: Guida all'utilizzo di UDM - Campi UDM obbligatori e facoltativi per ogni tipo di evento

  • Risorse non ufficiali di terze parti: UDM Event Validation

    Nei casi in cui la Guida all'utilizzo di UDM non fornisca dettagli, questo documento integra la documentazione ufficiale fornendo i campi UDM obbligatori minimi necessari per compilare un determinato UDM metadata.event_type.

    Ad esempio, apri il documento e cerca il tipo di evento GROUP_CREATION.

    Dovresti vedere i seguenti campi UDM minimi, presentati come oggetto UDM:

    {
    "metadata": {
        "event_timestamp": "2023-07-03T13:01:10.957803Z",
        "event_type": "GROUP_CREATION"
    },
    "principal": {
        "user": {
            "userid": "pinguino"
        }
    },
    "target": {
        "group": {
            "group_display_name": "foobar_users"
        }
    }
}

Creare istruzioni per gli snippet di codice

L'approccio con snippet di codice ti consente di utilizzare una sintassi simile a Logstash per definire come estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM nel record UDM.

Prima di creare un'estensione del parser utilizzando l'approccio dello snippet di codice, devi aver esaminato le seguenti sezioni:

I passaggi successivi per definire l'estensione del parser sono:

  1. Per suggerimenti e best practice, consulta Suggerimenti e best practice per la scrittura di istruzioni per snippet di codice.
  2. Creare un'istruzione di snippet di codice
  3. Inviare un'istruzione per uno snippet di codice

Suggerimenti e best practice per la scrittura di istruzioni per gli snippet di codice

Le istruzioni dello snippet di codice possono non riuscire a causa di problemi come pattern Grok errati, operazioni di rinominazione o sostituzione non riuscite o errori di sintassi. Consulta quanto segue per consigli e best practice:

Creare un'istruzione per lo snippet di codice

Le istruzioni dello snippet di codice utilizzano la stessa sintassi e le stesse sezioni del parser predefinito (o personalizzato):

  • Sezione 1. Estrai i dati dal log non elaborato.
  • Sezione 2. Trasforma i dati estratti.
  • Sezione 3. Assegna uno o più valori a un campo UDM.
  • Sezione 4. Associa i campi evento UDM alla chiave @output.

Per creare un'estensione del parser utilizzando l'approccio dello snippet di codice:

  1. Nella pagina Estensioni parser, nel riquadro Snippet CBN, inserisci uno snippet di codice per creare l'estensione del parser.
  2. Fai clic su Convalida per convalidare le istruzioni di mappatura.

Esempi di istruzioni per gli snippet di codice

L'esempio seguente illustra uno snippet di codice.

Questo è un esempio di log non elaborato:

  {
      "insertId": "00000000",
      "jsonPayload": {
          ...section omitted for brevity...
          "packets_sent": "4",
          ...section omitted for brevity...
      },
      "timestamp": "2022-05-03T01:45:00.150614953Z"
  }

Questo è un esempio di snippet di codice che mappa il valore in jsonPayload.packets_sent al campo UDM network.sent_bytes:

mutate {
 replace => {
    "jsonPayload.packets_sent" => ""
 }
}
filter {
    # Section 1. extract data from the raw JSON log
    json {
        source => "message"
        array_function => "split_columns"
        on_error => "_not_json"
    }
    if [_not_json] {
        drop {
            tag => "TAG_UNSUPPORTED"
        }
    } else {
        # Section 2. transform the extracted data
        if [jsonPayload][packets_sent] not in ["",0] {
            mutate {
                convert => {
                    "jsonPayload.packets_sent" => "uinteger"
                }
            }
            # Section 3. assign the value to a UDM field
            mutate {
                copy => {
                    "udm.network.sent_bytes" => "jsonPayload.packets_sent"
                }
                on_error => "_exception"
            }
            if ![_exception] {
                # Section 4. Bind the UDM fields to the @output key
                mutate {
                    merge => {
                        "@output" => "event"
                    }
                }
            }
        }
    }
}

Inviare un'istruzione per lo snippet di codice

  1. Fai clic su Invia per salvare le istruzioni di mappatura.

  2. Google SecOps convalida le istruzioni di mappatura.

    • Se la procedura di convalida va a buon fine, lo stato diventa Pubblicata e le istruzioni di mappatura iniziano a elaborare i dati dei log in entrata.
    • Se la procedura di convalida non va a buon fine, lo stato diventa Non riuscita e viene visualizzato un errore nel campo Log non elaborato.

Gestire le estensioni del parser esistenti

Puoi visualizzare, modificare, eliminare e controllare l'accesso alle estensioni del parser esistenti.

Visualizzare un'estensione del parser esistente

  1. Nella barra di navigazione, seleziona Impostazioni SIEM > Parser.
  2. Nell'elenco Parser, individua il parser (tipo di log) che vuoi visualizzare. I parser con un'estensione sono indicati dal testo EXTENSION accanto al nome.

  3. Vai a quella riga e fai clic su Menu > Visualizza estensione.

    Viene visualizzata la scheda Visualizza parser personalizzato/predefinito > Estensione, che mostra dettagli sull'estensione del parser. Per impostazione predefinita, il riquadro riepilogativo mostra l'estensione del parser LIVE.

Modificare un'estensione del parser

  1. Apri Visualizza parser personalizzato/predefinito > scheda Estensione, come descritto in Visualizzare un'estensione del parser esistente.

  2. Fai clic sul pulsante Modifica estensione.

    Viene visualizzata la pagina Estensioni dell'analizzatore sintattico.

  3. Modifica l'estensione del parser.

    • Per annullare la modifica e ignorare le modifiche, fai clic su Elimina bozza.

    • Per eliminare l'estensione del parser in qualsiasi momento, fai clic su Elimina estensione non riuscita.

    • Al termine della modifica dell'estensione del parser, fai clic su Invia.

      Viene eseguita la procedura di convalida della nuova configurazione.

Eliminare un'estensione del parser

  1. Apri Visualizza parser personalizzato/predefinito > Scheda Estensione, come descritto in Visualizzare un'estensione del parser esistente.

  2. Fai clic sul pulsante Elimina estensione.

Controllare l'accesso alle estensioni del parser

Per impostazione predefinita, gli utenti con il ruolo Amministratore possono accedere alle estensioni del parser. Puoi controllare chi può visualizzare e gestire le estensioni del parser. Per ulteriori informazioni sulla gestione di utenti e gruppi o sull'assegnazione dei ruoli, consulta Controllo di accesso basato sui ruoli.

I nuovi ruoli in Google SecOps sono riassunti nella tabella seguente.

Funzionalità Azione Descrizione
Parser Elimina Elimina le estensioni del parser.
Parser Modifica Creare e modificare le estensioni del parser.
Parser Visualizza Visualizza le estensioni del parser.

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