Raccogliere i log EDR di Digital Guardian

Supportato in:

Google SecOps SIEM

Nota: questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini di servizio specifici del servizio Google Security Operations. Le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per saperne di più, consulta le linee guida per i servizi di assistenza tecnica di Google SecOps e i Termini di servizio specifici di Google SecOps.

Questo documento spiega come importare i log EDR di Digital Guardian in Google Security Operations utilizzando Google Cloud Storage V2 tramite una funzione Cloud Run.

Digital Guardian (in precedenza Digital Guardian) di Fortra è una piattaforma completa di prevenzione della perdita di dati e rilevamento e risposta degli endpoint che fornisce visibilità su eventi di sistema, utente e dati su endpoint, reti e applicazioni cloud. Il servizio Analytics & Reporting Cloud (ARC) offre funzionalità avanzate di analisi, flusso di lavoro e reporting per una protezione olistica dei dati. La funzione Cloud Run esegue l'autenticazione all'API ARC Export utilizzando OAuth 2.0, recupera i dati di esportazione, conferma il segnalibro per passare al blocco successivo, scrive i risultati come NDJSON in un bucket GCS e Google SecOps li acquisisce tramite un feed GCS V2.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Un progetto Google Cloud con le seguenti API abilitate:
  • Cloud Storage
  • Cloud Run Functions
  • Cloud Scheduler
  • Pub/Sub
  • Cloud Build
• Autorizzazioni per creare e gestire bucket Cloud Storage, funzioni Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
• Accesso privilegiato alla console di gestione Digital Guardian (DGMC)
• Accesso alle impostazioni del tenant di Digital Guardian Analytics & Reporting Cloud (ARC)
• Autorizzazioni di amministratore per configurare i servizi cloud in DGMC
• Un profilo di esportazione creato in DGMC con un GUID valido

Creare un bucket Google Cloud Storage

1. Vai alla console Google Cloud.
2. Seleziona il tuo progetto o creane uno nuovo.
3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
4. Fai clic su Crea bucket.

5. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Assegna un nome al bucket	Inserisci un nome univoco globale (ad esempio digitalguardian-edr-logs).
   Tipo di località	Scegli in base alle tue esigenze (regione singola, doppia regione, più regioni)
   Località	Seleziona la località più vicina alla tua istanza Google SecOps (ad esempio us-central1).
   Classe di archiviazione	Standard (consigliato per i log a cui si accede di frequente)
   Controllo dell'accesso	Uniforme (consigliato)
   Strumenti di protezione	(Facoltativo) Attiva il controllo delle versioni degli oggetti o la policy di conservazione

6. Fai clic su Crea.

   Nota: annota il nome del bucket. Lo utilizzerai per configurare la funzione Cloud Run e il feed Google SecOps.

Raccogliere le credenziali API di Digital Guardian

• Per consentire alla funzione Cloud Run di recuperare i dati di esportazione da Digital Guardian ARC, devi ottenere le credenziali API e configurare un profilo di esportazione.

  Nota :Digital Guardian ARC utilizza il tipo di concessione delle credenziali client OAuth 2.0 con l'ambito client. L'ID accesso API e il secret di accesso API forniscono le autorizzazioni necessarie per accedere ai profili di esportazione.

Ottenere le credenziali API da DGMC

1. Accedi alla console di gestione Digital Guardian (DGMC).
2. Vai a Sistema > Configurazione > Servizi cloud.

3. Nella sezione Accesso API, individua e registra i seguenti valori:

   • ID accesso API: è l'ID client per l'autenticazione OAuth 2.0.
   • API Access Secret: è il client secret per l'autenticazione OAuth 2.0.
   • URL di base di Access Gateway: l'endpoint del gateway API (ad esempio, https://accessgw-usw.msp.digitalguardian.com).
   • URL del server di autorizzazione: l'endpoint del token OAuth 2.0 (ad esempio, https://authsrv.msp.digitalguardian.com/as/token.oauth2).
   Importante:copia e salva immediatamente il segreto di accesso all'API. Potrebbe non essere recuperabile dopo aver abbandonato questa pagina.

Creare e configurare un profilo di esportazione

1. Nella console di gestione Digital Guardian (DGMC), vai a Amministrazione > Report > Esporta profili.
2. Fai clic su Crea profilo di esportazione o seleziona un profilo di esportazione esistente.
3. Configura il profilo di esportazione con le seguenti impostazioni:
   • Nome profilo: inserisci un nome descrittivo (ad esempio, Google SecOps SIEM Integration).
   • Origine dati: seleziona Eventi o Avvisi a seconda dei dati che vuoi esportare.
   • Formato di esportazione: seleziona Tabella JSON appiattita (opzione consigliata per le integrazioni SIEM).
   • Campi: seleziona i campi da includere nell'esportazione.
   • Filtri: configura i filtri per limitare i dati esportati (facoltativo).
4. Fai clic su Salva per creare il profilo di esportazione.

5. Dopo averlo salvato, individua il profilo di esportazione nell'elenco e copia il GUID dall'URL del profilo di esportazione o dalla pagina dei dettagli.

   Importante :copia solo la parte GUID dell'identificatore del profilo di esportazione. Il GUID è un identificatore univoco nel formato xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

Riepilogo delle credenziali del record

Salva le seguenti informazioni per configurare le variabili di ambiente della funzione Cloud Run:

• ID client (ID accesso API): da DGMC Cloud Services
• Client secret (API Access Secret): da DGMC Cloud Services
• URL del server di autorizzazione: ad esempio, https://authsrv.msp.digitalguardian.com/as/token.oauth2
• URL di base di Access Gateway: ad esempio, https://accessgw-usw.msp.digitalguardian.com
• Export Profile GUID: dal profilo di esportazione creato in DGMC

Testare l'accesso API

1. Verifica che le credenziali siano valide eseguendo questi comandi:

   # Step 1: Obtain OAuth 2.0 access token
   curl -s -X POST \
     -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=client" \
     "https://authsrv.msp.digitalguardian.com/as/token.oauth2"
   

   # Step 2: Test export endpoint with the access token
   curl -s -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     "https://accessgw-usw.msp.digitalguardian.com/rest/1.0/export/YOUR_EXPORT_PROFILE_GUID"
   

2. Una risposta positiva restituisce un documento JSON contenente i dati di esportazione. Se ricevi un errore di autenticazione, verifica l'ID accesso API e il segreto in DGMC Cloud Services.

   Nota: sostituisci YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_ACCESS_TOKEN e YOUR_EXPORT_PROFILE_GUID con i tuoi valori effettivi. Utilizza l'URL del server di autorizzazione e l'URL di base del gateway di accesso dalla configurazione di DGMC.

Crea un account di servizio per la funzione Cloud Run

1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
2. Fai clic su Crea account di servizio.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome service account: inserisci digitalguardian-ingestion (o un nome descrittivo).
   • Descrizione service account: inserisci Service account for Digital Guardian EDR Cloud Run function to write logs to GCS.
4. Fai clic su Crea e continua.
5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
   • Amministratore oggetti Storage (per leggere/scrivere oggetti nel bucket Cloud Storage)
   • Cloud Run Invoker (per consentire a Cloud Scheduler di richiamare la funzione)
6. Fai clic su Continua.

7. Fai clic su Fine.

   Nota: registra l'email del account di servizio (ad esempio digitalguardian-ingestion@PROJECT_ID.iam.gserviceaccount.com). La utilizzerai quando crei il job Cloud Scheduler.

Crea un argomento Pub/Sub

Cloud Scheduler attiva la funzione Cloud Run tramite un argomento Pub/Sub.

1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
2. Fai clic su Crea argomento.
3. Nel campo ID argomento, inserisci digitalguardian-edr-trigger.
4. Lascia le impostazioni predefinite.

5. Fai clic su Crea.

   Nota: registra il nome completo dell'argomento (ad esempio, projects/PROJECT_ID/topics/digitalguardian-edr-trigger).

Crea la funzione Cloud Run

Crea una funzione Cloud Run che esegue l'autenticazione in Digital Guardian ARC utilizzando le credenziali client OAuth 2.0, recupera i dati di esportazione, conferma il segnalibro per passare al blocco successivo e scrive i risultati come NDJSON in GCS.

Prepara i file di origine della funzione

Crea i due file seguenti per il deployment della funzione Cloud Run.

• requirements.txt

  functions-framework==3.*
  google-cloud-storage==2.*
  urllib3==2.*
  

• main.py

  """Cloud Run function to ingest Digital Guardian EDR logs into GCS."""
  
  import json
  import os
  import time
  import urllib.parse
  from datetime import datetime, timezone
  
  import functions_framework
  import urllib3
  from google.cloud import storage
  
  GCS_BUCKET = os.environ["GCS_BUCKET"]
  GCS_PREFIX = os.environ.get("GCS_PREFIX", "digitalguardian_edr")
  STATE_KEY = os.environ.get("STATE_KEY", "digitalguardian_edr_state.json")
  AUTH_SERVER_URL = os.environ["AUTH_SERVER_URL"]
  ARC_SERVER_URL = os.environ["ARC_SERVER_URL"]
  CLIENT_ID = os.environ["CLIENT_ID"]
  CLIENT_SECRET = os.environ["CLIENT_SECRET"]
  EXPORT_PROFILE_GUID = os.environ["EXPORT_PROFILE_GUID"]
  MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))
  
  http = urllib3.PoolManager()
  gcs = storage.Client()
  
  def _get_access_token() -> str:
      """Obtain an OAuth 2.0 access token using client credentials grant."""
      body = urllib.parse.urlencode({
          "grant_type": "client_credentials",
          "client_id": CLIENT_ID,
          "client_secret": CLIENT_SECRET,
          "scope": "client",
      })
      resp = http.request(
          "POST",
          AUTH_SERVER_URL,
          body=body,
          headers={"Content-Type": "application/x-www-form-urlencoded"},
      )
      if resp.status != 200:
          raise RuntimeError(
              f"OAuth token request failed: {resp.status} — "
              f"{resp.data.decode('utf-8')}"
          )
      token_data = json.loads(resp.data.decode("utf-8"))
      return token_data["access_token"]
  
  def _arc_get(token: str, path: str, retries: int = 5) -> dict:
      """Execute a GET request against the ARC API with retry on 429."""
      url = f"{ARC_SERVER_URL}{path}"
      headers = {
          "Authorization": f"Bearer {token}",
          "Accept": "application/json",
      }
      backoff = 2
      for attempt in range(retries):
          resp = http.request("GET", url, headers=headers)
          if resp.status == 200:
              return json.loads(resp.data.decode("utf-8"))
          if resp.status == 429:
              wait = backoff * (2 ** attempt)
              print(
                  f"Rate limited (429). Retrying in {wait}s "
                  f"(attempt {attempt + 1}/{retries})."
              )
              time.sleep(wait)
              continue
          raise RuntimeError(
              f"ARC API error: {resp.status} — {resp.data.decode('utf-8')}"
          )
      raise RuntimeError(
          "ARC API rate limit exceeded after maximum retries."
      )
  
  def _arc_acknowledge(token: str) -> None:
      """POST to the acknowledge endpoint to advance the export bookmark."""
      url = (
          f"{ARC_SERVER_URL}/rest/1.0/export/"
          f"{EXPORT_PROFILE_GUID}/acknowledge"
      )
      headers = {
          "Authorization": f"Bearer {token}",
          "Accept": "application/json",
      }
      resp = http.request("POST", url, headers=headers)
      if resp.status not in (200, 204):
          raise RuntimeError(
              f"ARC acknowledge failed: {resp.status} — "
              f"{resp.data.decode('utf-8')}"
          )
      print("Export bookmark acknowledged successfully.")
  
  def _load_state() -> dict:
      """Load the last run state from GCS."""
      bucket = gcs.bugcs.bucketUCKET)
      blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
      if blob.exists():
          return json.loads(blob.downlodownload_as_text  return {}
  
  def _save_state(state: dict) -> None:
      """Persist run state to GCS."""
      bucket = gcs.bugcs.bucketUCKET)
      blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
      blob.uploadupload_from_string    json.dumps(state), content_type="application/json"
      )
  
  def _fetch_export(token: str) -> list:
      """Fetch export data from the ARC Export API."""
      path = f"/rest/1.0/export/{EXPORT_PROFILE_GUID}"
      data = _arc_get(token, path)
      records = data if isinstance(data, list) else data.get("data", [])
      return records[:MAX_RECORDS]
  
  def _write_ndjson(records: list, run_ts: str) -> str:
      """Write records as NDJSON to GCS and return the blob path."""
      bucket = gcs.bugcs.bucketUCKET)
      blob_path = (
          f"{GCS_PREFIX}/year={run_ts[:4]}/month={run_ts[5:7]}/"
          f"day={run_ts[8:10]}/{run_ts}_export.ndjson"
      )
      blob = bucket.blob(blob_path)
      ndjson = "\n".join(
          json.dumps(r, separators=(",", ":")) for r in records
      )
      blob.uploadupload_from_stringn, content_type="application/x-ndjson")
      return blob_path
  
  @functions_framework.cloud_event
  def main(cloud_event):
      """Entry point triggered by Pub/Sub via Cloud Scheduler."""
      state = _load_state()
      now = datetime.now(timezone.utc)
  
      print("Authenticating to Digital Guardian ARC.")
      token = _get_access_token()
  
      print(
          f"Fetching export data for profile {EXPORT_PROFILE_GUID}."
      )
      records = _fetch_export(token)
  
      if not records:
          print("No new export data found.")
          return "OK"
  
      run_ts = now.strftime("%Y-%m-%dT%H%M%SZ")
      blob_path = _write_ndjson(records, run_ts)
      print(
          f"Wrote {len(records)} records to "
          f"gs://{GCS_BUCKET}/{blob_path}."
      )
  
      _arc_acknowledge(token)
  
      state["last_run"] = now.isoformat()
      state["records_written"] = len(records)
      _save_state(state)
      print(f"State updated. last_run={now.isoformat()}.")
      return "OK"
  

Esegui il deployment della funzione Cloud Run

1. Salva entrambi i file (main.py e requirements.txt) in una directory locale (ad esempio, digitalguardian-function/).
2. Apri Cloud Shell o un terminale con l'interfaccia a riga di comando gcloud installata.

3. Esegui questo comando per eseguire il deployment della funzione:

   gcloud functions deploy digitalguardian-edr-to-gcs \
     --gen2 \
     --region=us-central1 \
     --runtime=python312 \
     --trigger-topic=digitalguardian-edr-trigger \
     --entry-point=main \
     --memory=512MB \
     --timeout=540s \
     --service-account=digitalguardian-ingestion@PROJECT_ID.iam.gserviceaccount.com \
     --set-env-vars=\
     "GCS_BUCKET=digitalguardian-edr-logs",\
     "GCS_PREFIX=digitalguardian_edr",\
     "STATE_KEY=digitalguardian_edr_state.json",\
     "AUTH_SERVER_URL=https://authsrv.msp.digitalguardian.com/as/token.oauth2",\
     "ARC_SERVER_URL=https://accessgw-usw.msp.digitalguardian.com",\
     "CLIENT_ID=YOUR_CLIENT_ID",\
     "CLIENT_SECRET=YOUR_CLIENT_SECRET",\
     "EXPORT_PROFILE_GUID=YOUR_EXPORT_PROFILE_GUID",\
     "MAX_RECORDS=10000"
   

4. Sostituisci i seguenti valori segnaposto:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • digitalguardian-edr-logs: il nome del bucket GCS.
   • YOUR_CLIENT_ID: il tuo ID accesso API Digital Guardian.
   • YOUR_CLIENT_SECRET: il segreto di accesso all'API Digital Guardian.
   • YOUR_EXPORT_PROFILE_GUID: il GUID del profilo di esportazione di DGMC.
   Nota: per i deployment di produzione, utilizza Google Cloud Secret Manager per archiviare CLIENT_SECRET anziché passarlo come variabile di ambiente in formato non crittografato. Fai riferimento al secret utilizzando --set-secrets="CLIENT_SECRET=dg-client-secret:latest".

5. Verifica il deployment controllando lo stato della funzione:

   gcloud functions describe digitalguardian-edr-to-gcs --region=us-central1 --gen2
   

Riferimento alle variabili di ambiente

Variabile	Obbligatorio	Predefinito	Descrizione
GCS_BUCKET	Sì		Nome del bucket GCS per l'archiviazione dell'output NDJSON
GCS_PREFIX	No	digitalguardian_edr	Prefisso oggetto (percorso della cartella) all'interno del bucket
STATE_KEY	No	digitalguardian_edr_state.json	Nome del blob per il file di stato all'interno del prefisso
AUTH_SERVER_URL	Sì		URL del server di autorizzazione OAuth 2.0
ARC_SERVER_URL	Sì		URL di base di ARC Access Gateway
CLIENT_ID	Sì		ID accesso API di DGMC
CLIENT_SECRET	Sì		API Access Secret da DGMC
EXPORT_PROFILE_GUID	Sì		Esportare il GUID del profilo da DGMC
MAX_RECORDS	No	10000	Numero massimo di record da scrivere per esecuzione

Crea un job Cloud Scheduler

Cloud Scheduler attiva la funzione Cloud Run a intervalli regolari tramite l'argomento Pub/Sub.

1. Nella console Google Cloud, vai a Cloud Scheduler.
2. Fai clic su Crea job.

3. Fornisci i seguenti dettagli di configurazione:

   • Nome: inserisci digitalguardian-edr-ingestion-schedule.
   • Regione: seleziona la stessa regione della tua funzione Cloud Run (ad esempio, us-central1).

   • Frequenza: inserisci */5 * * * * (ogni 5 minuti).

     Nota: l'intervallo di 5 minuti bilancia l'inserimento tempestivo dei log rispetto ai limiti di frequenza API. Modifica la pianificazione in base al volume dei dati di esportazione e ai requisiti di aggiornamento.

   • Fuso orario: seleziona il fuso orario che preferisci (ad esempio, UTC).

4. Fai clic su Continua.

5. Nella sezione Configura l'esecuzione:

   • Tipo di target: seleziona Pub/Sub.
   • Argomento: seleziona digitalguardian-edr-trigger.
   • Corpo del messaggio: inserisci {"run": true}.

6. Fai clic su Continua.

7. Nella sezione Configura le impostazioni facoltative:

   • Numero massimo di nuovi tentativi: inserisci 3.
   • Durata minima di backoff: inserisci 5s.
   • Durata massima backoff: inserisci 60s.

8. Fai clic su Crea.

9. Per eseguire un test immediato, fai clic sui tre puntini (…) accanto al nome del job e seleziona Forza esecuzione.

   Nota: monitora i log di esecuzione della funzione in Cloud Logging filtrando in base al nome della funzione digitalguardian-edr-to-gcs. Verifica che i file NDJSON vengano visualizzati nel bucket GCS con il prefisso configurato.

Recupera l'account di servizio Google SecOps e configura il feed

Google SecOps utilizza un account di servizio univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo account di servizio l'accesso al tuo bucket.

Recupera l'email del account di servizio

1. Vai a Impostazioni SIEM > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Fai clic su Configura un singolo feed.
4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Digital Guardian EDR Logs).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona Digital Guardian EDR come Tipo di log.

7. Fai clic su Ottieni service account. Verrà visualizzata un'email univoca del account di servizio, ad esempio:

   [e-mail]
   

8. Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

   Nota: ogni istanza di Google SecOps ha un account di servizio univoco. Non utilizzare service account di altre documentazioni o esempi.

9. Fai clic su Avanti.

10. Specifica i valori per i seguenti parametri di input:

    • URL bucket di archiviazione: inserisci l'URI del bucket GCS:

      gs://digitalguardian-edr-logs/digitalguardian_edr/
      

      • Sostituisci digitalguardian-edr-logs con il nome del tuo bucket GCS.
      • Sostituisci digitalguardian_edr con il valore GCS_PREFIX configurato.
      Nota: includi sempre la barra finale (/) alla fine dell'URI.

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
      • Elimina file trasferiti: elimina i file dopo il trasferimento riuscito.

      • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

        Nota :se selezioni un'opzione di eliminazione, il account di servizio Google SecOps deve disporre del ruolo Amministratore oggetti Storage anziché di Visualizzatore oggetti Storage. Aggiorna le autorizzazioni IAM di conseguenza.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni (il valore predefinito è 180 giorni).

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

11. Fai clic su Avanti.

12. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps deve disporre del ruolo Visualizzatore oggetti Storage sul bucket Cloud Storage.

1. Vai a Cloud Storage > Bucket.
2. Fai clic sul nome del bucket (ad esempio digitalguardian-edr-logs).
3. Vai alla scheda Autorizzazioni.
4. Fai clic su Concedi l'accesso.
5. Fornisci i seguenti dettagli di configurazione:
   • Aggiungi entità: incolla l'email dell'account di servizio Google SecOps (ad esempio, [e-mail]).
   • Assegna ruoli: seleziona Visualizzatore oggetti Storage.

6. Fai clic su Salva.

   Nota: se prevedi di utilizzare l'opzione di eliminazione "Elimina file trasferiti" o "Elimina file trasferiti e directory vuote", assegna il ruolo Storage Object Admin anziché Storage Object Viewer.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logic
Applicazione	target.application	Valore copiato direttamente
Applicazione	target.process.command_line	Imposta su %{Application} se la regola corrisponde a Printer.
Bytes_Written	network.sent_bytes	Valore copiato direttamente e convertito in uinteger
Categoria, Computer_Name, Dettaglio	metadata.description	Imposta %{Detail} se Category == "Policies" e Computer_Name è vuoto; altrimenti imposta %{message} su grok_parse_failure
Command_Line, Command_Line1	principal.process.command_line	Valore di Command_Line dopo la rimozione delle virgolette finali se non è vuoto, altrimenti di Command_Line1 dopo la rimozione delle virgolette finali
Computer_Name, source	principal.hostname	Valore di computerName se non è vuoto, altrimenti impostato su %{source}
Destination_Device_Serial_Number, Destination_Device_Serial_Number1		Estratto utilizzando il pattern Grok per la gestione delle virgolette
Destination_Directory, Destination_File	target.file.full_path	Concatenato da Destination_Directory e Destination_File se entrambi non sono vuoti
Destination_Drive_Type	security_result.detection_fields	Unito a destination_drive_type_label (chiave: Destination_Drive_Type, valore: %{Destination_Drive_Type})
Destination_File	target.file.names	Unito da Destination_File
Destination_File_Extension	target.file.mime_type	Valore copiato direttamente
Dll_SHA1_Hash	target.process.file.sha1	Valore copiato subito dopo la conversione in minuscolo
Email_Address	principal.user.email_addresses	Unito da Email_Address
Email_Sender, Email_Subject	network.email.from	Impostato su %{Email_Sender} se non è vuoto
Email_Sender, Email_Subject	network.email.subject	Unito dall'oggetto (%{Email_Subject}) se Email_Sender non è vuoto
File_Extension	principal.process.file.mime_type	Valore copiato direttamente
IP_Address, source_ip	principal.ip	Unito da source_ip se non è vuoto, altrimenti da IP_Address
Local_Port, source_port	principal.port	Valore di source_port se non è vuoto e convertito in numero intero, altrimenti da Local_Port e convertito in numero intero
MD5_Checksum	target.process.file.md5	Valore copiato subito dopo la conversione in minuscolo
Network_Direction	network.direction	Impostato su INBOUND se True, altrimenti OUTBOUND se False
Process_PID	principal.process.pid	Valore copiato direttamente
Process_SHA256_Hash	target.process.file.sha256	Valore copiato subito dopo la conversione in minuscolo
Product_Version	metadata.product_version	Valore copiato direttamente
Protocollo	network.ip_protocol	Imposta su ICMP se == "1"
Remote_Port	target.port	Valore copiato direttamente e convertito in numero intero
Regola	security_result.rule_name	Valore copiato direttamente
Regola	metadata.event_type	Impostato su PROCESS_UNCATEGORIZED se corrisponde a .Printer., altrimenti FILE_MOVE se corrisponde a DLP.*
Gravità	security_result.severity	Imposta su LOW se <=3, MEDIUM se <=6, HIGH se <=8, CRITICAL se <=10 dopo la conversione in numero intero
Gravità	security_result.severity_details	Valore copiato direttamente
Source_Directory, Source_File	src.file.full_path	Concatenato da Source_Directory e Source_File se entrambi non sono vuoti
Source_Drive_Type	security_result.detection_fields	Unito a source_drive_type_label (chiave: Source_Drive_Type, valore: %{Source_Drive_Type})
Source_File	src.file.names	Unito da Source_File
Source_File_Extension	src.file.mime_type	Valore copiato direttamente
URL_Path, http_url	target.url	Valore di http_url se non è vuoto, altrimenti di URL_Path
User_Name	principal.user.userid	Valore di userName dopo l'estrazione di grok
User_Name	principal.administrative_domain	Valore di domainName dopo l'estrazione grok
Was_Removable	security_result.detection_fields	Unito a was_removable_label (chiave: Was_Removable, valore: %{Was_Removable})
Was_Source_Removable	security_result.detection_fields	Unito a was_source_removable_label (chiave: Was_Source_Removable, valore: %{Was_Source_Removable})
computerName, destination_ip, protocol, source_ip, IP_Address, destination, userName, Process_PID, Category, Computer_Name	metadata.event_type	Impostato inizialmente su GENERIC_EVENT; NETWORK_HTTP se protocollo == HTTPS e (destination_ip o computerName); NETWORK_CONNECTION se (source_ip o IP_Address) e destination_ip; USER_UNCATEGORIZED se userName non è vuoto; SCAN_PROCESS se Process_PID non è vuoto
destination_ip	target.ip	Unito da destination_ip
incidents_url, matched_policies_by_severity	security_result	Unita a _sr (rule_name: %{matched_policies_by_severity}, url_back_to_product: %{incidents_url})
protocollo	network.application_protocol	Imposta su HTTPS se protocollo == HTTP o HTTPS
security_action	security_result.action	Unito da security_action
	metadata.product_name	Imposta su "Enterprise DLP Platform"
	metadata.vendor_name	Impostato su "DigitalGuardian"

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