Utilizzo delle estensioni per i parser

Supportato in:

Google SecOps SIEM

Google Security Operations fornisce più metodi per definire in che modo i dati nei log non elaborati originali vengono analizzati e normalizzati in un record Unified Data Model (UDM).

• Parser predefiniti: istruzioni per la mappatura dei dati predefinite gestite da Google Security Operations che mappano i dati di log non elaborati originali ai campi UDM.
• Analizzatori personalizzati: istruzioni di mappatura dei dati personalizzate create e gestite da un cliente per soddisfare le sue specifiche esigenze di analisi dei dati.
• Estensioni parser: istruzioni aggiuntive sulla mappatura dei dati che estendono un valore predefinito o parser personalizzato per mappare campi aggiuntivi nel log non elaborato originale. Questa operazione non sostituisce completamente un parser predefinito o personalizzato, ma estende le istruzioni di mappatura esistenti in un parser predefinito o personalizzato.

Questo documento descrive come utilizzare le estensioni dei parser.

Prima di iniziare

I seguenti documenti spiegano i concetti dei prerequisiti importanti dell'utilizzo delle estensioni per i parser:

• Panoramica del modello di dati unificato
• Panoramica dell'analisi dei log
• Riferimento per la sintassi dell'analizzatore sintattico

Informazioni sulle estensioni del parser

Un'estensione del parser ti consente di creare istruzioni di mappatura aggiuntive rispetto a quelle definite in un parser predefinito o personalizzato per soddisfare un caso d'uso unico. Questo ha lo scopo di estendere un parser predefinito o personalizzato esistente. Un'estensione del parser non sostituisce un parser predefinito o personalizzato. Non puoi creare un nuovo parser utilizzando un'estensione del parser.

L'estensione parser legge il log non elaborato originale e inserisce i valori estratti in campi specifici del record UDM. Il record UDM contiene dati impostati sia dal parser predefinito che dall'analizzatore sintattico personalizzato e l'estensione parser.

Le istruzioni per la mappatura dei dati in un'estensione parser hanno la precedenza sulle quelli in un parser predefinito o personalizzato. In caso di conflitto in istruzioni di mappatura, l'estensione parser sovrascriverà un valore impostato un parser predefinito o personalizzato. 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 sovrascriverà il valore impostato dall'interprete predefinito. Un'eccezione è rappresentata dai campi ripetuti. Puoi configurare l'estensione del parser per aggiungere valori quando scrivi i dati in un campo ripetuto.

Devi creare un'estensione del parser per ogni tipo di log. Ogni tipo di log è identificato da un'etichetta di importazione univoca. Consulta Parser predefiniti supportati per un elenco dei tipi di log.

Per creare un'estensione parser, Google Security Operations deve essere in grado di: importare e normalizzare i log non elaborati originali utilizzando un metodo analizzatore sintattico. L'estensione parser estrae dati aggiuntivi dal log non elaborato originale, quindi lo unisce al record UDM.

Le estensioni del parser supportano i seguenti tipi di istruzioni di mappatura:

• Tipo di snippet di codice: scrivi codice del parser simile a quello dei parser predefiniti e personalizzati. I log non elaborati originali possono essere in uno dei formati di dati supportati per il tipo di log.
• Tipo di campo dati: specifichi i campi Origine e Destinazione nell'interfaccia dell'applicazione. I log non elaborati originali devono essere formattati in uno dei seguenti modi:
  • JSON nativo, XML nativo o CSV.
  • Intestazione syslog più JSON nativo, XML nativo o CSV. Puoi creare un'istruzione di mappatura del tipo di campo dati per un sottoinsieme di Log Tipi in Analizzatori predefiniti supportati. Cerca quelli con il formato JSON, XML, CSV, SYSLOG + JSON, SYSLOG + XML e SYSLOG + CSV.

Tieni presente quanto segue durante la creazione di un'estensione parser:

• I dati possono essere mappati a qualsiasi campo UDM che supporta i tipi di dati standard e i valori ripetuti.
• Non puoi mappare i dati ai seguenti campi UDM:
  • event.idm.read_only_udm.additional
  • event.idm.graph.entity.additional
• Prima di creare un'istruzione di mappatura dei dati, assicurati che il team di Google Security Operations l'istanza ha importato log originali non elaborati negli ultimi 30 giorni per il tipo di log, e che questi log non elaborati contengano il campo che prevedi di definire nei criteri di precondizione. Questi log originali non elaborati vengono utilizzati per convalidare le istruzioni di mappatura dei dati.
• Una volta pubblicata, l'estensione parser inizierà l'analisi dei dati in entrata. Non puoi analizzare i dati non elaborati dei log in modo retroattivo.

Ciclo di vita di un'estensione parser

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

• DRAFT: estensione del parser appena creata che non è ancora stata inviata.
• VALIDATING: Google Security Operations sta convalidando le istruzioni di mappatura rispetto a i log non elaborati esistenti per garantire che i campi vengano analizzati senza errori.
• LIVE: l'estensione del parser ha superato la convalida ed è ora in produzione. È estraendo e trasformando i dati dai log non elaborati in entrata in record UDM.
• FAILED: l'estensione del parser non ha superato la convalida.

Apri la pagina Estensioni parser

Per accedere alla pagina Parser Extensions, esegui i passaggi di una delle sezioni seguenti.

Iniziare dalla barra di navigazione

1. Nella barra di navigazione, seleziona Impostazioni, Impostazioni SIEM e poi Parser.
2. Identifica il tipo di log che vuoi estendere nella tabella Parser.
3. Vai a quella riga, quindi fai clic su Menu.
4. Fai clic su Crea estensione.

Inizia dalla ricerca nei log non elaborati

1. Utilizza Ricerca nei log non elaborati per eseguire una ricerca per record simili a quelli che verranno analizzati.
2. Seleziona un evento dal riquadro Eventi > Spostamenti.
3. Espandi il riquadro Dati sugli eventi.
4. Fai clic sul pulsante Gestisci parser.
5. Nella finestra di dialogo Gestisci analizzatore sintattico, seleziona Crea estensione e poi fai clic su Avanti. La pagina Parser Extensions si apre in modalità di modifica. Puoi iniziare a definire dell'analizzatore sintattico.

Crea una nuova estensione parser

Questa sezione descrive come creare un'estensione del parser dopo aver aperto la pagina Estensioni del parser. I campi disponibili nella pagina Estensioni del parser variano in base alla struttura del log non elaborato.

1. Esamina l'esempio di accesso non elaborato nel riquadro Log non elaborato per verificare che sia rappresentativo dei log elaborati dall'estensione del parser. Utilizza il log non elaborato di esempio come riferimento per creare l'estensione del parser.

   • Se hai aperto la pagina Estensioni dello scanner dalla ricerca dei log non elaborati, il riquadro mostra il log non elaborato originale selezionato nei risultati di ricerca.

   • Se hai aperto la pagina Estensioni del parser nella barra di navigazione, viene visualizzato un log non elaborato di esempio per quel tipo di log.

   Nota: non puoi modificare i dati nel riquadro Log non elaborato. Puoi formattare il log non elaborato utilizzando il menu Visualizza come e la casella di controllo Testo a capo.

2. Scegli il Metodo di estensione. Seleziona una delle seguenti opzioni:

   • Mappa i campi dati: crea una mappatura dei campi dati. Utilizza i campi di applicazione per definire il campo del log non elaborato originale e il campo UDM di destinazione.

   • Scrivi snippet di codice: crea uno snippet di codice per tutti i formati supportati. formati dei log. Lo snippet di codice utilizza la stessa sintassi del parser dei parser predefiniti e personalizzati. Per ulteriori informazioni sulla sintassi del parser, consulta Sintassi del parser.

   Nota: non puoi combinare le istruzioni di mappatura dello snippet di codice con i campi dati. istruzioni sulla mappatura.

Continua con una delle seguenti sottosezioni specifiche per il Metodo di estensione selezionato.

• Creare un'istruzione di mappatura dei campi di dati
• Creare un'istruzione di mappatura per lo snippet di codice

Creare un'istruzione di mappatura dei campi di dati

Crea un'istruzione di mappatura dei campi di dati quando i log non elaborati in entrata sono in formato JSON, XML, CSV, intestazione Syslog più JSON, intestazione Syslog più XML, intestazione Syslog più formato CSV. Definisci il percorso del campo originale e il campo UDM di destinazione nell'istruzione di mappatura dei dati.

1. Nel selettore Campi ripetuti, specifica in che modo l'estensione dell'analizzatore salva un valore nei campi che supportano un array di valori.

   • Aggiungi valori: il valore viene aggiunto all'insieme esistente di valori memorizzati nel campo.
   • Sostituisci valori: il valore sostituisce tutti i valori archiviati in precedenza con il nuovo valore.

   Alcuni campi UDM, ad esempio principal.ip. e entity.asset.hostname, archiviare un array di valori. Questi campi ripetuti sono identificati dall'etichetta repeated nel Elenco dei campi del modello dei dati unificato. Per informazioni più dettagliate, consulta Selettore di campi ripetuti.

   Importante: le istruzioni di mappatura dei campi di dati possono includere campi ripetuti solo quando il campo ripetuto si trova al livello più basso della gerarchia. Ad esempio, puoi mappare valori nel campo ripetuto udm.principal.ip perché ip è al valore più basso a livello gerarchico e principal non è un campo ripetuto. Non puoi mappare i valori a udm.intermediary.hostname perché intermediary è un campo ripetuto e non si trova al livello più basso della gerarchia.

2. Se vengono visualizzati i campi Syslog e Target, Google Security Operations ha rilevato che il log non elaborato include un'intestazione Syslog.

   Se Google Security Operations rileva che il log non elaborato di esempio non è nativo JSON, XML nativo o CSV e ha un'intestazione Syslog, visualizza il file Syslog e Target. Utilizza i seguenti campi per definire un pattern Grok ed espressioni regolari che pre-elaborano l'intestazione Syslog ed estraggono la parte strutturata del log. La parte strutturata del log può essere mappata utilizzando i campi di dati.

   • Campo Syslog: specifica il pattern di estrazione, utilizzando Grok ed espressioni regolari, che identifica l'intestazione Syslog e il messaggio di log non elaborato.
   • Campo Target: specifica il nome della variabile nel pattern di estrazione che archivia parte strutturata del log.

   Per informazioni su come definire un pattern di estrazione utilizzando Grok ed espressioni regolari, consulta Definire i campi dell'estrattore Syslog.

   L'immagine seguente fornisce un esempio di come aggiungere un pattern di estrazione e un nome di variabile rispettivamente ai campi Syslog e Target.

   

   Entrambi i campi Syslog e Target sono obbligatori e interagiscono per separando l'intestazione Syslog dalla parte strutturata del log.

3. Dopo aver inserito i valori nei campi Syslog e Destinazione, fai clic sul pulsante Convalida. Il processo di convalida controlla gli errori di sintassi e di analisi, quindi restituisce una delle seguenti opzioni:

   • Operazione riuscita: vengono visualizzati i campi della 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.

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

   L'istruzione di precondizione identifica solo un sottoinsieme di log non elaborati originali che l'estensione dell'analizzatore sintattico viene elaborata abbinando un valore statico a un campo nei dati non elaborati log. Se un log non elaborato in entrata soddisfa i criteri di precondizionamento, ovvero se i valori corrispondono, l'estensione dello scanner 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 precondizione: inserisci il percorso completo del campo se il log il formato dei dati è JSON o XML oppure la posizione della colonna se i dati è CSV.
   • Operatore precondizione: seleziona EQUALS o NOT EQUALS.
   • Valore precondizionante: inserisci il valore che deve corrispondere ai dati nel campo Precondizionante.

5. Definisci l'istruzione di mappatura dei dati:

   • Campo dati non elaborati: inserisci il percorso completo del campo se il formato dei dati dei log è JSON o XML oppure la posizione della colonna se il formato dei dati è CSV.
   • Campo di destinazione: inserisci il nome completo del campo UDM in cui verrà memorizzato il valore, ad esempio udm.metadata.collected_timestamp.seconds.
   Importante: se il log non elaborato originale è in formato JSON, il tipo di dato del valore del log originale deve corrispondere al tipo di dato nel campo UDM di destinazione. Ad esempio, se il log originale registra i pacchetti inviati come stringa ("packets_sent":"16") e cerchi di mappare questo elemento all'UDM network.sent_bytes che ha un tipo di dati uint64, l'istruzione non riuscirà. Questo requisito non si applica ai log in formato CSV e XML.

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

7. Google Security Operations convalida l'istruzione di mappatura.

   • Se il processo di convalida ha esito positivo, lo stato cambia in Attivo e la mappatura inizia a elaborare i dati di log in entrata.
   • Se il processo di convalida non va a buon fine, lo stato diventa Non riuscita e viene visualizzato un errore. visualizzato nel campo Log non elaborato.
   Nota: durante la convalida di un'estensione parser, non puoi modificare i dati l'istruzione di mappatura.

   Di seguito è riportato 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"}
   

Consulta Campi in un'istruzione di mappatura dei dati per un elenco di tutti i possibili campi in un'estensione del parser.

Campi in un'istruzione di mappatura dei dati

Questa sezione descrive tutti i campi che possono essere impostati in un'estensione del parser.

Nome campo	Descrizione
Syslog	Un pattern definito dall'utente che esegue la preelaborazione e separa un'intestazione Syslog dalla parte strutturata di un log non elaborato.
Destinazione	Nome della variabile nel campo Syslog in cui è archiviato il valore parte strutturata del log.
Campo Precondizionale	Identificatore di campo nel log non elaborato contenente il valore da confrontare. Utilizzato in un'istruzione di precondizione.
Operatore di precondizione	Seleziona EQUALS o NOT EQUALS. Utilizzato in un'istruzione di precondizione.
Valore precondizione	Il valore statico che verrà confrontato con il campo Precondizionale nel log non elaborato. Utilizzato in un'istruzione di precondizione.
Campo dati non elaborati	Utilizzato in un'istruzione di mappatura. Se il formato dei dati è JSON, definisci il percorso del campo, ad esempio: jsonPayload.connection.dest_ip. Se il formato dei dati è XML, definisci il percorso completo del campo, ad esempio: /Event/Reason-Code. Se il formato dei dati è CSV, definisci la posizione dell'indice della colonna. Le posizioni dell'indice iniziano da 1.
Campo Destinazione	Utilizzato in un'istruzione di mappatura. Definisci il percorso completo del campo UDM in cui verranno archiviati i dati. Ad esempio: udm.network.dhcp.opcode o graph.entity.asset.hostname

Crea un'istruzione di mappatura dello snippet di codice

Uno snippet di codice utilizza una sintassi simile a Logstash per definire le modalità di estrazione e trasformazione dei valori nel log non elaborato originale e assegnarle al record UDM. Uno snippet di codice utilizza la stessa sintassi e le stesse sezioni dell'istruzione di un parser predefinito o personalizzato. Le sezioni di uno snippet di codice sono le seguenti:

• Sezione 1. Estrai i dati dal log originale.
• 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.

L'esempio seguente illustra uno snippet di codice.

Ecco 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"
}

Di seguito è riportato uno snippet di codice di esempio che mappa il valore in jsonPayload.packets_sent al campo UDM network.sent_bytes.

mutate {
 replace => {
    "jsonPayload.packets_sent" => ""
 }
}

filter {
    # Section 1. extract the data from the original 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"
                    }
                }
            }
        }
    }
}

Nota: se definisci due eventi separati nello snippet di codice e crea due istruzioni di output, l'estensione parser salva i campi di entrambi gli eventi un singolo record UDM.

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

2. Google Security Operations convalida l'istruzione di mappatura.

   • Se il processo di convalida ha esito positivo, lo stato cambia in Attivo e la mappatura inizia a elaborare i dati di log in entrata.
   • Se il processo di convalida non va a buon fine, lo stato diventa Non riuscita e viene visualizzato un errore. visualizzato nel campo Log non elaborato.
   Nota: durante la convalida di un'estensione del parser, non puoi modificare l'istruzione di mappatura dei dati.

Visualizzare un'estensione del parser esistente

1. Nella barra di navigazione, seleziona Impostazioni, Impostazioni SIEM e poi Parser.
2. Nell'elenco Parser, identifica il tipo di log con un'estensione del parser. È identificato dal testo EXTENSION accanto al nome.
3. Vai a quella riga, quindi fai clic su Menu.
4. Fai clic su Visualizza estensione.
5. Visualizza parser personalizzato/predefinito > Viene visualizzata la scheda Estensione con i dettagli sull'estensione parser. Per impostazione predefinita, il riquadro di riepilogo mostra l'estensione parser LIVE. se c'è

Modifica un'estensione parser

1. Apri Visualizza parser personalizzato/predefinito > Scheda Estensione. Per istruzioni su come aprire la pagina, consulta Visualizzare un'estensione di parser esistente.
2. Fai clic sul pulsante Modifica estensione. Viene visualizzata la pagina Parser Extensions.
3. Modifica l'estensione Paser.
   • Per annullare le modifiche e ignorarle, fai clic su Ignora bozza.
4. Al termine della modifica dell'estensione del parser, fai clic su Invia.

5. Se invii la modifica, viene eseguito il processo di convalida per convalidare la nuova configurazione.

   Nota: durante la convalida di un'estensione parser, non puoi modificare i dati istruzioni sulla mappatura.

Elimina un'estensione parser

1. Apri Visualizza analizzatore personalizzato/predefinito > Scheda Estensione. Per le istruzioni, consulta Visualizzare un'estensione parser esistente su come aprire la pagina.

2. Fai clic sul pulsante Modifica estensione. Viene visualizzata la pagina Estensioni dell'analizzatore sintattico.

3. Fai clic sul pulsante Elimina estensione.

Mentre modifichi un'estensione dell'analizzatore, puoi eliminarla in qualsiasi momento. Fai clic su una delle seguenti opzioni:

• Ignora bozza
• Eliminare l'estensione non riuscita

Scopri di più sul selettore dei campi ripetuti

Alcuni campi UDM memorizzano un array di valori, ad esempio principal.ip e Entity.asset.hostname. Se crei un'estensione del parser per archiviare i dati in un campo ripetuto, questa opzione ti consente di controllare se il valore viene aggiunto all'array o se sostituisce tutti i valori esistenti impostati dal parser predefinito. I campi ripetuti vengono identificati in base all'etichetta ripetuta nell'elenco dei campi Modello dei dati unificato.

Se è selezionata l'opzione Aggiunge valori, l'estensione del parser aggiunge il valore estratto all'array di valori esistenti nel campo UDM. Se è selezionata l'opzione Sostituisci valori, l'estensione del parser sostituisce l'array di valori esistenti nel campo UDM con il valore estratto. Il selettore Campi ripetuti non influisce sul modo in cui i dati vengono archiviati nei campi che non sono ripetuti.

Un'estensione parser può mappare i dati a un campo ripetuto solo se ripetuto è al livello più basso della gerarchia. Ad esempio, mappatura valori a udm.principal.ip è supportato perché il campo ip ripetuto è su il 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 riportata di seguito fornisce esempi di come la configurazione dei campi ripetuti influisce sul record UDM generato.

Selezione di Campi ripetuti	Log di esempio	Configurazione dell'estensione di analisi	Risultato generato
Aggiunta di valori	{"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":"[e-mail]"},"requestMetadata":{"callerIp":"1.1.1.1, 2.2.2.2"}}}	Campo precondizione: protoPayload.requestMetadata.callerIp Valore di precondizione: " " Operatore di precondizione: NOT_EQUALS Campo di 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"} } }
Aggiunta di valori	{"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":"[e-mail]"},"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 dal parser predefinito prima di applicare l'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":"[e-mail]"},"requestMetadata":{"callerIp":"2.2.2.2"}}}	Campo precondizione: protoPayload.authenticationInfo.principalEmail Valore di precondizione: " " Operatore di precondizione: NOT_EQUALS Campo di dati non elaborati: protoPayload.authenticationInfo.principalEmail Campo di destinazione: event.idm.read_only_udm.principal.ip	Eventi UDM generati dal parser predefinito 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 collaborano per definire il modo in cui un'estensione 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 Target, specifica il nome della variabile.

Il seguente esempio illustra il funzionamento combinato di questi campi.

Di seguito è riportato 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, usa quanto segue 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 tu il nome della variabile. L'estensione del parser estrae il segmento JSON del log non elaborato e lo assegna alla variabile msg.

Importante: il valore message è riservato e non può essere utilizzato come nome di una variabile. Verrà restituito un errore durante la convalida dell'espressione.

Nel campo Target, 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"}

Nell'immagine seguente vengono mostrati i campi Syslog e Target completati:

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

Esempio di log non elaborato	Campo Syslog	Campo di destinazione	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.

Controlla l'accesso alle estensioni dei parser

Sono disponibili nuove autorizzazioni che controllano chi può visualizzare e gestire il parser estensioni. Per impostazione predefinita, le estensioni parser sono accessibili agli utenti che utilizzano Ruolo di amministratore. Per ulteriori informazioni sulla gestione di Utenti e Gruppi o sull'assegnazione dei ruoli, consulta Controllo dell'accesso basato sui ruoli.

I nuovi ruoli in Google Security Operations 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.