Recopila registros de Digital Guardian EDR

Compatible con:

En este documento, se explica cómo transferir registros de Digital Guardian EDR a Google Security Operations con Google Cloud Storage V2 a través de una función de Cloud Run.

Digital Guardian de Fortra (anteriormente, Digital Guardian) es una plataforma integral de prevención de pérdida de datos y detección y respuesta de extremos que proporciona visibilidad de los eventos del sistema, los usuarios y los datos en los extremos, las redes y las aplicaciones en la nube. El servicio de Analytics & Reporting Cloud (ARC) ofrece capacidades avanzadas de análisis, flujo de trabajo y generación de informes para la protección integral de datos. La función de Cloud Run se autentica en la API de ARC Export con OAuth 2.0, recupera los datos de exportación, confirma el marcador para avanzar al siguiente fragmento, escribe los resultados como NDJSON en un bucket de GCS y Google SecOps los ingiere a través de un feed de GCS V2.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

  • Una instancia de Google SecOps
  • Un proyecto de Google Cloud con las siguientes APIs habilitadas:
    • Cloud Storage
    • Cloud Run Functions
    • Cloud Scheduler
    • Pub/Sub
    • Cloud Build
  • Permisos para crear y administrar buckets de Cloud Storage, funciones de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
  • Acceso con privilegios a la consola de administración de Digital Guardian (DGMC)
  • Acceso a la configuración del arrendatario de Digital Guardian Analytics & Reporting Cloud (ARC)
  • Permisos de administrador para configurar los servicios de Cloud en DGMC
  • Un perfil de exportación creado en DGMC con un GUID válido

Crear un bucket de Google Cloud Storage

  1. Ve a la consola de Google Cloud.
  2. Selecciona tu proyecto o crea uno nuevo.
  3. En el menú de navegación, ve a Cloud Storage > Buckets.
  4. Haz clic en Crear bucket.

  5. Proporciona los siguientes detalles de configuración:

    Configuración Valor
    Asigna un nombre a tu bucket Ingresa un nombre global único (por ejemplo, digitalguardian-edr-logs).
    Tipo de ubicación Elige según tus necesidades (región, birregional, multirregional)
    Ubicación Selecciona la ubicación más cercana a tu instancia de Google SecOps (por ejemplo, us-central1).
    Clase de almacenamiento Estándar (recomendado para los registros a los que se accede con frecuencia)
    Control de acceso Uniforme (recomendado)
    Herramientas de protección Opcional: Habilita el control de versiones de objetos o la política de retención

  6. Haz clic en Crear.

Recopila credenciales de la API de Digital Guardian

  • Para permitir que la función de Cloud Run recupere datos de exportación del ARC de Digital Guardian, debes obtener credenciales de la API y configurar un perfil de exportación.

Obtén credenciales de API del DGMC

  1. Accede a la Consola de administración de Digital Guardian (DGMC).
  2. Ve a System > Configuration > Cloud Services.

  3. En la sección API Access, ubica y registra los siguientes valores:

    • ID de acceso a la API: Es tu ID de cliente para la autenticación de OAuth 2.0.
    • Secreto de acceso a la API: Es el secreto del cliente para la autenticación de OAuth 2.0.
    • URL base de Access Gateway: Es el extremo de la puerta de enlace de API (por ejemplo, https://accessgw-usw.msp.digitalguardian.com).
    • URL del servidor de autorización: Es el extremo del token de OAuth 2.0 (por ejemplo, https://authsrv.msp.digitalguardian.com/as/token.oauth2).

Crea y configura un perfil de exportación

  1. En la Consola de administración de Digital Guardian (DGMC), ve a Admin > Reports > Export Profiles.
  2. Haz clic en Crear perfil de exportación o selecciona un perfil de exportación existente.
  3. Configura el perfil de exportación con los siguientes parámetros:
    • Nombre del perfil: Ingresa un nombre descriptivo (por ejemplo, Google SecOps SIEM Integration).
    • Fuente de datos: Selecciona Eventos o Alertas según los datos que quieras exportar.
    • Formato de exportación: Selecciona Tabla JSON aplanada (recomendado para integraciones de SIEM).
    • Campos: Selecciona los campos que deseas incluir en la exportación.
    • Filtros: Configura los filtros para limitar los datos exportados (opcional).
  4. Haz clic en Guardar para crear el perfil de exportación.

  5. Después de guardar el perfil de exportación, búscalo en la lista y copia el GUID de la URL o la página de detalles del perfil de exportación.

Resumen de credenciales de registro

Guarda la siguiente información para configurar las variables de entorno de la función de Cloud Run:

  • ID de cliente (ID de acceso a la API): De los servicios de DGMC Cloud
  • Client Secret (secreto de acceso a la API): De DGMC Cloud Services
  • URL del servidor de autorización: Por ejemplo, https://authsrv.msp.digitalguardian.com/as/token.oauth2
  • URL base de Access Gateway: Por ejemplo, https://accessgw-usw.msp.digitalguardian.com
  • Export Profile GUID: Es el GUID del perfil de exportación creado en DGMC.

Prueba el acceso a la API

  1. Ejecuta los siguientes comandos para verificar que tus credenciales sean válidas:

    # 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 respuesta correcta devuelve un documento JSON que contiene datos de exportación. Si recibes un error de autenticación, verifica el ID y el secreto de acceso a la API en los servicios de DGMC Cloud.

Crea una cuenta de servicio para la función de Cloud Run

  1. En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio.
  2. Haz clic en Crear cuenta de servicio.
  3. Proporciona los siguientes detalles de configuración:
    • Nombre de la cuenta de servicio: Ingresa digitalguardian-ingestion (o un nombre descriptivo).
    • Descripción de la cuenta de servicio: Ingresa Service account for Digital Guardian EDR Cloud Run function to write logs to GCS.
  4. Haz clic en Crear y continuar.
  5. En la sección Otorga a esta cuenta de servicio acceso al proyecto, agrega los siguientes roles:
    • Administrador de objetos de Storage (para leer o escribir objetos en el bucket de Cloud Storage)
    • Invocador de Cloud Run (para permitir que Cloud Scheduler invoque la función)
  6. Haz clic en Continuar.

  7. Haz clic en Listo.

Crea un tema de Pub/Sub

Cloud Scheduler activa la función de Cloud Run a través de un tema de Pub/Sub.

  1. En la consola de Google Cloud, ve a Pub/Sub > Temas.
  2. Haz clic en Crear un tema.
  3. En el campo ID del tema, ingresa digitalguardian-edr-trigger.
  4. Deja la configuración predeterminada.

  5. Haz clic en Crear.

Crea la función de Cloud Run

Crea una función de Cloud Run que se autentique en Digital Guardian ARC con credenciales de cliente de OAuth 2.0, recupere datos de exportación, confirme el marcador para avanzar al siguiente fragmento y escriba los resultados como NDJSON en GCS.

Prepara los archivos fuente de la función

Crea los siguientes dos archivos para la implementación de la función de 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"

Implementa la Cloud Run function

  1. Guarda ambos archivos (main.py y requirements.txt) en un directorio local (por ejemplo, digitalguardian-function/).
  2. Abre Cloud Shell o una terminal con la CLI de gcloud instalada.

  3. Ejecuta el siguiente comando para implementar la función:

    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. Reemplaza los siguientes valores de marcador de posición:

    • PROJECT_ID es el ID del proyecto de Google Cloud.
    • digitalguardian-edr-logs: Es el nombre de tu bucket de GCS.
    • YOUR_CLIENT_ID: Es el ID de acceso a la API de Digital Guardian.
    • YOUR_CLIENT_SECRET: Es tu secreto de acceso a la API de Digital Guardian.
    • YOUR_EXPORT_PROFILE_GUID: Es el GUID de tu perfil de exportación de DGMC.

  5. Verifica la implementación comprobando el estado de la función:

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

Referencia de variables de entorno

Variable Obligatorio Predeterminado Descripción
GCS_BUCKET Sí Nombre del bucket de GCS para almacenar el resultado en formato NDJSON
GCS_PREFIX No digitalguardian_edr Prefijo del objeto (ruta de acceso a la carpeta) dentro del bucket
STATE_KEY No digitalguardian_edr_state.json Nombre del blob para el archivo de estado dentro del prefijo
AUTH_SERVER_URL Sí URL del servidor de autorización de OAuth 2.0
ARC_SERVER_URL Sí URL base de la puerta de enlace de acceso de ARC
CLIENT_ID Sí ID de acceso a la API del DGMC
CLIENT_SECRET Sí Secreto de acceso a la API de DGMC
EXPORT_PROFILE_GUID Sí Exporta el GUID del perfil desde DGMC
MAX_RECORDS No 10000 Cantidad máxima de registros que se pueden escribir por ejecución

Crea un trabajo de Cloud Scheduler

Cloud Scheduler activa la función de Cloud Run a intervalos regulares a través del tema de Pub/Sub.

  1. En la consola de Google Cloud, ve a Cloud Scheduler.
  2. Haz clic en Crear trabajo.

  3. Proporciona los siguientes detalles de configuración:

    • Nombre: Ingresa digitalguardian-edr-ingestion-schedule.
    • Región: Selecciona la misma región que tu función de Cloud Run (por ejemplo, us-central1).

    • Frecuencia: Ingresa */5 * * * * (cada 5 minutos).

    • Zona horaria: Selecciona la zona horaria que prefieras (por ejemplo, UTC).

  4. Haz clic en Continuar.

  5. En la sección Configura la ejecución, haz lo siguiente:

    • Tipo de destino: Selecciona Pub/Sub.
    • Tema: Selecciona digitalguardian-edr-trigger.
    • Cuerpo del mensaje: Ingresa {"run": true}.

  6. Haz clic en Continuar.

  7. En la sección Configura los parámetros opcionales, haz lo siguiente:

    • Cantidad máx. de reintentos: Ingresa 3.
    • Duración mín. de la retirada: Ingresa 5s.
    • Duración máx. de la retirada: Ingresa 60s.

  8. Haz clic en Crear.

  9. Para ejecutar una prueba inmediata, haz clic en los tres puntos (…) junto al nombre del trabajo y selecciona Forzar ejecución.

Recupera la cuenta de servicio de Google SecOps y configura el feed

Las Operaciones de seguridad de Google usan una cuenta de servicio única para leer datos de tu bucket de GCS. Debes otorgar acceso a tu bucket a esta cuenta de servicio.

Obtén el correo electrónico de la cuenta de servicio

  1. Ve a Configuración de SIEM > Feeds.
  2. Haz clic en Agregar feed nuevo.
  3. Haz clic en Configura un feed único.
  4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Digital Guardian EDR Logs).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona Digital Guardian EDR como el Tipo de registro.

  7. Haz clic en Obtener cuenta de servicio. Se mostrará un correo electrónico único de la cuenta de servicio, por ejemplo:

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

  8. Copia esta dirección de correo electrónico para usarla en el siguiente paso.

  9. Haz clic en Siguiente.

  10. Especifica valores para los siguientes parámetros de entrada:

    • URL del bucket de almacenamiento: Ingresa el URI del bucket de GCS:

      gs://digitalguardian-edr-logs/digitalguardian_edr/
      • Reemplaza digitalguardian-edr-logs por el nombre de tu bucket de GCS.
      • Reemplaza digitalguardian_edr por el valor de GCS_PREFIX que configuraste.

    • Opción de borrado de la fuente: Selecciona la opción de borrado según tu preferencia:

      • Nunca: Nunca borra ningún archivo después de las transferencias (se recomienda para las pruebas).
      • Borrar archivos transferidos: Borra los archivos después de la transferencia exitosa.

      • Borrar los archivos transferidos y los directorios vacíos: Borra los archivos y los directorios vacíos después de la transferencia exitosa.

    • Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días más reciente (el valor predeterminado es 180 días).

    • Espacio de nombres del recurso: Es el espacio de nombres del recurso.

    • Etiquetas de transmisión: Es la etiqueta que se aplicará a los eventos de este feed.

  11. Haz clic en Siguiente.

  12. Revisa la nueva configuración del feed en la pantalla Finalizar y, luego, haz clic en Enviar.

Otorga permisos de IAM a la cuenta de servicio de Google SecOps

La cuenta de servicio de Google SecOps necesita el rol de visualizador de objetos de almacenamiento en tu bucket de Cloud Storage.

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket (por ejemplo, digitalguardian-edr-logs).
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar principales: Pega el correo electrónico de la cuenta de servicio de Google SecOps (por ejemplo, chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
    • Asignar roles: Selecciona Visualizador de objetos de Storage.

  6. Haz clic en Guardar.

Tabla de asignación de UDM

Campo de registro Asignación de UDM Lógica
Aplicación target.application Valor copiado directamente
Aplicación target.process.command_line Se establece en %{Application} si la regla coincide con Printer.
Bytes_Written network.sent_bytes Valor copiado directamente y convertido en uinteger
Categoría, Nombre_de_la_computadora, Detalle metadata.description Se establece en %{Detail} si Category == "Policies" y Computer_Name está vacío; de lo contrario, se establece en %{message} en grok_parse_failure
Command_Line, Command_Line1 principal.process.command_line Valor de Command_Line después de quitar las comillas finales si no está vacío; de lo contrario, se toma de Command_Line1 después de quitar las comillas finales.
Computer_Name, source principal.hostname Valor de computerName si no está vacío; de lo contrario, se establece en %{source}
Destination_Device_Serial_Number, Destination_Device_Serial_Number1 Se extrae con un patrón de Grok para controlar las comillas.
Destination_Directory, Destination_File target.file.full_path Se concatena de Destination_Directory y Destination_File si ambos no están vacíos.
Destination_Drive_Type security_result.detection_fields Se combinó con destination_drive_type_label (clave: Destination_Drive_Type, valor: %{Destination_Drive_Type})
Destination_File target.file.names Se combinó desde Destination_File
Destination_File_Extension target.file.mime_type Valor copiado directamente
Dll_SHA1_Hash target.process.file.sha1 Valor copiado directamente después de convertirlo a minúsculas
Email_Address principal.user.email_addresses Se combinó de Email_Address
Email_Sender, Email_Subject network.email.from Se establece en %{Email_Sender} si no está vacío.
Email_Sender, Email_Subject network.email.subject Se combinó del asunto (%{Email_Subject}) si Email_Sender no está vacío
File_Extension principal.process.file.mime_type Valor copiado directamente
IP_Address, source_ip principal.ip Se fusiona de source_ip si no está vacío; de lo contrario, se fusiona de IP_Address.
Local_Port, source_port principal.port Valor de source_port si no está vacío y se convierte en un número entero; de lo contrario, se toma de Local_Port y se convierte en un número entero
MD5_Checksum target.process.file.md5 Valor copiado directamente después de convertirlo a minúsculas
Network_Direction network.direction Se establece en INBOUND si es verdadero y en OUTBOUND si es falso.
Process_PID principal.process.pid Valor copiado directamente
Process_SHA256_Hash target.process.file.sha256 Valor copiado directamente después de convertirlo a minúsculas
Product_Version metadata.product_version Valor copiado directamente
Protocolo network.ip_protocol Se establece en ICMP si == "1".
Remote_Port target.port Valor copiado directamente y convertido en número entero
Regla security_result.rule_name Valor copiado directamente
Regla metadata.event_type Se establece en PROCESS_UNCATEGORIZED si coincide con Printer.; de lo contrario, se establece en FILE_MOVE si coincide con DLP.*
Gravedad security_result.severity Se establece en LOW si es <=3, en MEDIUM si es <=6, en HIGH si es <=8 y en CRITICAL si es <=10 después de convertirlo en un número entero.
Gravedad security_result.severity_details Valor copiado directamente
Source_Directory, Source_File src.file.full_path Se concatena de Source_Directory y Source_File si ambos no están vacíos
Source_Drive_Type security_result.detection_fields Se combinó con source_drive_type_label (clave: Source_Drive_Type, valor: %{Source_Drive_Type})
Source_File src.file.names Se combinó desde Source_File
Source_File_Extension src.file.mime_type Valor copiado directamente
URL_Path, http_url target.url Valor de http_url si no está vacío; de lo contrario, de URL_Path
User_Name principal.user.userid Valor de userName después de la extracción de Grok
User_Name principal.administrative_domain Valor de domainName después de la extracción de Grok
Was_Removable security_result.detection_fields Se combinó con was_removable_label (clave: Was_Removable, valor: %{Was_Removable})
Was_Source_Removable security_result.detection_fields Se combinó con was_source_removable_label (clave: Was_Source_Removable, valor: %{Was_Source_Removable})
computerName, destination_ip, protocol, source_ip, IP_Address, destination, userName, Process_PID, Category, Computer_Name metadata.event_type Se establece en GENERIC_EVENT de forma inicial; NETWORK_HTTP si protocol == HTTPS y (destination_ip o computerName); NETWORK_CONNECTION si (source_ip o IP_Address) y destination_ip; USER_UNCATEGORIZED si userName no está vacío; SCAN_PROCESS si Process_PID no está vacío
destination_ip target.ip Se combinó desde destination_ip
incidents_url, matched_policies_by_severity security_result Se combinó con _sr (rule_name: %{matched_policies_by_severity}, url_back_to_product: %{incidents_url})
protocolo network.application_protocol Se establece en HTTPS si el protocolo es HTTP o HTTPS.
security_action security_result.action Se combinó desde security_action
metadata.product_name Se debe establecer en "Plataforma de DLP empresarial".
metadata.vendor_name Se establece en "DigitalGuardian".

¿Necesitas más ayuda? Obtén respuestas de miembros de la comunidad y profesionales de Google SecOps.