Collecter les journaux Digital Guardian EDR

Compatible avec :

Ce document explique comment ingérer des journaux Digital Guardian EDR dans Google Security Operations à l'aide de Google Cloud Storage V2 via une fonction Cloud Run.

Digital Guardian de Fortra (anciennement Digital Guardian) est une plate-forme complète de prévention contre la perte de données, de détection et de réponse au niveau des points de terminaison. Elle offre une visibilité sur les événements système, utilisateur et de données sur les points de terminaison, les réseaux et les applications cloud. Le service Analytics & Reporting Cloud (ARC) offre des fonctionnalités avancées d'analyse, de workflow et de reporting pour une protection holistique des données. La fonction Cloud Run s'authentifie auprès de l'API ARC Export à l'aide d'OAuth 2.0, récupère les données d'exportation, confirme le signet pour passer au bloc suivant, écrit les résultats au format NDJSON dans un bucket GCS, et Google SecOps les ingère via un flux GCS V2.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet Google Cloud avec les API suivantes activées :
    • Cloud Storage
    • Cloud Run Functions
    • Cloud Scheduler
    • Pub/Sub
    • Cloud Build
  • Autorisations pour créer et gérer des buckets Cloud Storage, des fonctions Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Accès privilégié à la console de gestion Digital Guardian (DGMC)
  • Accès aux paramètres du locataire Digital Guardian Analytics & Reporting Cloud (ARC)
  • Autorisations d'administrateur pour configurer les services cloud dans DGMC
  • Profil d'exportation créé dans DGMC avec un GUID valide

créer un bucket Google Cloud Storage ;

  1. Accédez à Google Cloud Console.
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage> Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nommer votre bucket Saisissez un nom unique (par exemple, digitalguardian-edr-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou multirégion).
    Emplacement Sélectionnez l'emplacement le plus proche de votre instance Google SecOps (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions des objets ou la règle de conservation

  6. Cliquez sur Créer.

Collecter les identifiants de l'API Digital Guardian

  • Pour permettre à la fonction Cloud Run de récupérer les données d'exportation à partir de Digital Guardian ARC, vous devez obtenir des identifiants API et configurer un profil d'exportation.

Obtenir des identifiants d'API auprès de DGMC

  1. Connectez-vous à la console de gestion Digital Guardian (DGMC).
  2. Accédez à Système > Configuration > Services cloud.

  3. Dans la section Accès à l'API, recherchez et enregistrez les valeurs suivantes :

    • ID d'accès à l'API : il s'agit de votre ID client pour l'authentification OAuth 2.0.
    • Code secret d'accès à l'API : il s'agit de votre code secret du client pour l'authentification OAuth 2.0.
    • URL de base d'Access Gateway : point de terminaison de la passerelle API (par exemple, https://accessgw-usw.msp.digitalguardian.com).
    • URL du serveur d'autorisation : point de terminaison du jeton OAuth 2.0 (par exemple, https://authsrv.msp.digitalguardian.com/as/token.oauth2).

Créer et configurer un profil d'exportation

  1. Dans la console de gestion Digital Guardian (DGMC), accédez à Admin > Reports > Export Profiles.
  2. Cliquez sur Créer un profil d'exportation ou sélectionnez un profil d'exportation existant.
  3. Configurez le profil d'exportation avec les paramètres suivants :
    • Nom du profil : saisissez un nom descriptif (par exemple, Google SecOps SIEM Integration).
    • Source de données : sélectionnez Événements ou Alertes selon les données que vous souhaitez exporter.
    • Format d'exportation : sélectionnez Tableau JSON aplati (recommandé pour les intégrations SIEM).
    • Champs : sélectionnez les champs que vous souhaitez inclure dans l'exportation.
    • Filtres : configurez les filtres pour limiter les données exportées (facultatif).
  4. Cliquez sur Enregistrer pour créer le profil d'exportation.

  5. Une fois l'exportation enregistrée, recherchez le profil d'exportation dans la liste et copiez le GUID à partir de l'URL ou de la page d'informations du profil d'exportation.

Récapitulatif des identifiants d'enregistrement

Enregistrez les informations suivantes pour configurer les variables d'environnement de la fonction Cloud Run :

  • ID client (ID d'accès à l'API) : depuis les services cloud DGMC
  • Code secret du client (code secret d'accès à l'API) : depuis les services cloud DGMC
  • URL du serveur d'autorisation : par exemple, https://authsrv.msp.digitalguardian.com/as/token.oauth2
  • URL de base Access Gateway : par exemple, https://accessgw-usw.msp.digitalguardian.com
  • GUID du profil d'exportation : à partir du profil d'exportation créé dans DGMC

Tester l'accès à l'API

  1. Vérifiez que vos identifiants sont valides en exécutant les commandes suivantes :

    # 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. Une réponse réussie renvoie un document JSON contenant les données d'exportation. Si vous recevez une erreur d'authentification, vérifiez l'ID et le code secret d'accès à l'API dans les services cloud DGMC.

Créer un compte de service pour la fonction Cloud Run

  1. Dans la console Google Cloud, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez digitalguardian-ingestion (ou un nom descriptif).
    • Description du compte de service : saisissez Service account for Digital Guardian EDR Cloud Run function to write logs to GCS.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    • Administrateur des objets Storage (pour lire/écrire des objets dans le bucket Cloud Storage)
    • Demandeur Cloud Run (pour permettre à Cloud Scheduler d'appeler la fonction)
  6. Cliquez sur Continuer.

  7. Cliquez sur OK.

Créer un sujet Pub/Sub

Cloud Scheduler déclenche la fonction Cloud Run via un sujet Pub/Sub.

  1. Dans la console Google Cloud, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Create topic (Créer un sujet).
  3. Dans le champ ID du thème, saisissez digitalguardian-edr-trigger.
  4. Conservez les paramètres par défaut.

  5. Cliquez sur Créer.

Créer la fonction Cloud Run

Créez une fonction Cloud Run qui s'authentifie auprès de Digital Guardian ARC à l'aide d'identifiants client OAuth 2.0, récupère les données d'exportation, confirme le signet pour passer au bloc suivant et écrit les résultats au format NDJSON dans GCS.

Préparer les fichiers sources de la fonction

Créez les deux fichiers suivants pour le déploiement de la fonction 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"

Déployer la fonction Cloud Run

  1. Enregistrez les deux fichiers (main.py et requirements.txt) dans un répertoire local (par exemple, digitalguardian-function/).
  2. Ouvrez Cloud Shell ou un terminal sur lequel la CLI gcloud est installée.

  3. Exécutez la commande suivante pour déployer la fonction :

    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. Remplacez les valeurs d'espace réservé suivantes :

    • PROJECT_ID : ID de votre projet Google Cloud.
    • digitalguardian-edr-logs : nom de votre bucket GCS.
    • YOUR_CLIENT_ID : ID d'accès à l'API Digital Guardian.
    • YOUR_CLIENT_SECRET : code secret d'accès à l'API Digital Guardian.
    • YOUR_EXPORT_PROFILE_GUID : GUID de votre profil d'exportation depuis DGMC.

  5. Vérifiez le déploiement en consultant l'état de la fonction :

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

Documentation de référence sur les variables d'environnement

Variable Obligatoire Par défaut Description
GCS_BUCKET Oui Nom du bucket GCS pour stocker la sortie NDJSON
GCS_PREFIX Non digitalguardian_edr Préfixe d'objet (chemin d'accès au dossier) dans le bucket
STATE_KEY Non digitalguardian_edr_state.json Nom du blob pour le fichier d'état dans le préfixe
AUTH_SERVER_URL Oui URL du serveur d'autorisation OAuth 2.0
ARC_SERVER_URL Oui URL de base d'ARC Access Gateway
CLIENT_ID Oui ID d'accès à l'API depuis DGMC
CLIENT_SECRET Oui Code secret d'accès à l'API depuis DGMC
EXPORT_PROFILE_GUID Oui Exporter le GUID du profil depuis DGMC
MAX_RECORDS Non 10000 Nombre maximal d'enregistrements à écrire par exécution

Créer une tâche Cloud Scheduler

Cloud Scheduler déclenche la fonction Cloud Run à intervalles réguliers via le sujet Pub/Sub.

  1. Dans la console Google Cloud, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    • Nom : saisissez digitalguardian-edr-ingestion-schedule.
    • Région : sélectionnez la même région que votre fonction Cloud Run (par exemple, us-central1).

    • Fréquence : saisissez */5 * * * * (toutes les cinq minutes).

    • Fuseau horaire : sélectionnez le fuseau horaire de votre choix (par exemple, UTC).

  4. Cliquez sur Continuer.

  5. Dans la section Configurer l'exécution :

    • Type de cible : sélectionnez Pub/Sub.
    • Sujet : sélectionnez digitalguardian-edr-trigger.
    • Corps du message : saisissez {"run": true}.

  6. Cliquez sur Continuer.

  7. Dans la section Configurer les paramètres facultatifs :

    • Nombre maximal de nouvelles tentatives : saisissez 3.
    • Intervalle minimal entre les tentatives : saisissez 5s.
    • Intervalle maximal entre les tentatives : saisissez 60s.

  8. Cliquez sur Créer.

  9. Pour exécuter un test immédiat, cliquez sur les trois points (...) à côté du nom du job, puis sélectionnez Forcer l'exécution.

Récupérer le compte de service Google SecOps et configurer le flux

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Digital Guardian EDR Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Digital Guardian EDR comme Type de journal.

  7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique pour le compte de service s'affiche, par exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

  9. Cliquez sur Suivant.

  10. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket de stockage : saisissez l'URI du bucket GCS :

      gs://digitalguardian-edr-logs/digitalguardian_edr/
      • Remplacez digitalguardian-edr-logs par le nom de votre bucket GCS.
      • Remplacez digitalguardian_edr par la valeur GCS_PREFIX que vous avez configurée.

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.

      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux.

  11. Cliquez sur Suivant.

  12. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps doit disposer du rôle Lecteur des objets Storage sur votre bucket Cloud Storage.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (par exemple, digitalguardian-edr-logs).
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps (par exemple, chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
Application target.application Valeur copiée directement
Application target.process.command_line Définissez %{Application} si la règle correspond. Imprimante
Bytes_Written network.sent_bytes Valeur copiée directement et convertie en uinteger
Catégorie, Computer_Name, Détail metadata.description Défini sur %{Detail} si la catégorie est "Policies" et que Computer_Name est vide ; sinon, défini sur %{message} en cas d'échec de grok_parse
Command_Line, Command_Line1 principal.process.command_line Valeur de Command_Line après suppression des guillemets de fin si elle n'est pas vide, sinon valeur de Command_Line1 après suppression des guillemets de fin
Computer_Name, source principal.hostname Valeur de computerName si elle n'est pas vide, sinon définie sur %{source}
Destination_Device_Serial_Number, Destination_Device_Serial_Number1 Extrait à l'aide du modèle grok pour gérer les guillemets
Destination_Directory, Destination_File target.file.full_path Concaténation de Destination_Directory et Destination_File si les deux ne sont pas vides
Destination_Drive_Type security_result.detection_fields Fusionné avec destination_drive_type_label (clé : Destination_Drive_Type, valeur : %{Destination_Drive_Type})
Destination_File target.file.names Fusionné à partir de Destination_File
Destination_File_Extension target.file.mime_type Valeur copiée directement
Dll_SHA1_Hash target.process.file.sha1 Valeur copiée directement après avoir été convertie en minuscules
Email_Address principal.user.email_addresses Fusionné à partir de Adresse_e-mail
Email_Sender, Email_Subject network.email.from Définissez sur %{Email_Sender} si ce champ n'est pas vide.
Email_Sender, Email_Subject network.email.subject Objet fusionné (%{Email_Subject}) si Email_Sender n'est pas vide
File_Extension principal.process.file.mime_type Valeur copiée directement
IP_Address, source_ip principal.ip Fusionné à partir de source_ip s'il n'est pas vide, sinon à partir de IP_Address
Local_Port, source_port principal.port Valeur de source_port si elle n'est pas vide et convertie en entier, sinon valeur de Local_Port convertie en entier
MD5_Checksum target.process.file.md5 Valeur copiée directement après avoir été convertie en minuscules
Network_Direction network.direction Défini sur INBOUND si la valeur est "True", ou sur OUTBOUND si la valeur est "False".
Process_PID principal.process.pid Valeur copiée directement
Process_SHA256_Hash target.process.file.sha256 Valeur copiée directement après avoir été convertie en minuscules
Product_Version metadata.product_version Valeur copiée directement
Protocole network.ip_protocol Définissez sur ICMP si == "1"
Remote_Port target.port Valeur copiée directement et convertie en entier
Règle security_result.rule_name Valeur copiée directement
Règle metadata.event_type Définissez sur PROCESS_UNCATEGORIZED si la valeur correspond à .Printer., sinon sur FILE_MOVE si elle correspond à DLP.*
Gravité security_result.severity Définissez sur "LOW" (FAIBLE) si la valeur est inférieure ou égale à 3, sur "MEDIUM" (MOYENNE) si elle est inférieure ou égale à 6, sur "HIGH" (ÉLEVÉE) si elle est inférieure ou égale à 8, et sur "CRITICAL" (CRITIQUE) si elle est inférieure ou égale à 10 après conversion en entier.
Gravité security_result.severity_details Valeur copiée directement
Source_Directory, Source_File src.file.full_path Concaténation de Source_Directory et Source_File si les deux ne sont pas vides
Source_Drive_Type security_result.detection_fields Fusionné avec source_drive_type_label (clé : Source_Drive_Type, valeur : %{Source_Drive_Type})
Source_File src.file.names Fusionné à partir de Source_File
Source_File_Extension src.file.mime_type Valeur copiée directement
URL_Path, http_url target.url Valeur de http_url si elle n'est pas vide, sinon valeur de URL_Path
Nom_Utilisateur principal.user.userid Valeur extraite de userName après l'extraction Grok
Nom_Utilisateur principal.administrative_domain Valeur extraite de domainName après l'analyse Grok
Was_Removable security_result.detection_fields Fusionné avec was_removable_label (clé : Was_Removable, valeur : %{Was_Removable})
Was_Source_Removable security_result.detection_fields Fusionné avec was_source_removable_label (clé : Was_Source_Removable, valeur : %{Was_Source_Removable})
computerName, destination_ip, protocol, source_ip, IP_Address, destination, userName, Process_PID, Category, Computer_Name metadata.event_type Définissez la valeur sur GENERIC_EVENT au départ, puis sur NETWORK_HTTP si protocol == HTTPS et (destination_ip ou computerName), sur NETWORK_CONNECTION si (source_ip ou IP_Address) et destination_ip, sur USER_UNCATEGORIZED si userName n'est pas vide, et sur SCAN_PROCESS si Process_PID n'est pas vide.
destination_ip target.ip Fusionné à partir de destination_ip
incidents_url, matched_policies_by_severity security_result Fusionné avec _sr (rule_name: %{matched_policies_by_severity}, url_back_to_product: %{incidents_url})
protocol network.application_protocol Définissez sur HTTPS si le protocole est HTTP ou HTTPS.
security_action security_result.action Fusionné depuis security_action
metadata.product_name Définissez le paramètre sur "Enterprise DLP Platform" (Plate-forme DLP Enterprise).
metadata.vendor_name Défini sur "DigitalGuardian"

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.