Recopila registros de BeyondTrust Endpoint Privilege Management (EPM)

Se admite en los siguientes sistemas operativos:

Google SecOps SIEM

En este documento, se explica cómo transferir registros de BeyondTrust Endpoint Privilege Management (EPM) a Google Security Operations con Google Cloud Storage. El analizador se enfoca en transformar los datos de registro JSON sin procesar de BeyondTrust Endpoint en un formato estructurado que cumpla con el UDM de Chronicle. Primero, inicializa los valores predeterminados para varios campos y, luego, analiza la carga útil JSON, y, posteriormente, asigna campos específicos del registro sin procesar a los campos de UDM correspondientes dentro del objeto event.idm.read_only_udm.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

Una instancia de Google SecOps
Un proyecto de GCP con la API de Cloud Storage habilitada
Permisos para crear y administrar buckets de GCS
Permisos para administrar políticas de IAM en buckets de GCS
Permisos para crear servicios de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
Acceso privilegiado al arrendatario o la API de BeyondTrust Endpoint Privilege Management

Crea un bucket de Google Cloud Storage

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

Proporciona los siguientes detalles de configuración:

Configuración	Valor
Asigna un nombre a tu bucket	Ingresa un nombre global único (por ejemplo, `beyondtrust-epm-logs`).
Tipo de ubicación	Elige según tus necesidades (región, birregional, multirregional)
Ubicación	Selecciona la ubicación (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

Haz clic en Crear.

Recopila las credenciales de la API de BeyondTrust EPM

Accede a la consola web de BeyondTrust Privilege Management como administrador.
Ve a Configuración > Configuración > Configuración de la API.
Haz clic en Create an API Account.
Proporciona los siguientes detalles de configuración:
- Nombre: Ingresa Google SecOps Collector.
- Acceso a la API: Habilita Auditoría (lectura) y otros permisos según sea necesario.
Copia y guarda el ID de cliente y el secreto del cliente.
Copia la URL base de la API. Por lo general, es https://<your-tenant>-services.pm.beyondtrustcloud.com (la usarás como BPT_API_URL).

Crea una cuenta de servicio para la Cloud Run Function

La Cloud Run Function necesita una cuenta de servicio con permisos para escribir en el bucket de GCS y ser invocada por Pub/Sub.

Crear cuenta de servicio

En GCP Console, ve a IAM y administración > Cuentas de servicio.
Haz clic en Crear cuenta de servicio.
Proporciona los siguientes detalles de configuración:
- Nombre de la cuenta de servicio: Ingresa beyondtrust-epm-collector-sa.
- Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect BeyondTrust EPM logs.
Haz clic en Crear y continuar.
En la sección Otorga a esta cuenta de servicio acceso al proyecto, agrega los siguientes roles:
1. Haz clic en Selecciona un rol.
2. Busca y selecciona Administrador de objetos de almacenamiento.
3. Haz clic en + Agregar otra función.
4. Busca y selecciona Invocador de Cloud Run.
5. Haz clic en + Agregar otra función.
6. Busca y selecciona Cloud Functions Invoker.
Haz clic en Continuar.
Haz clic en Listo.

Estos roles son necesarios para las siguientes acciones:

Administrador de objetos de almacenamiento: Escribe registros en el bucket de GCS y administra archivos de estado
Invocador de Cloud Run: Permite que Pub/Sub invoque la función
Cloud Functions Invoker: Permite la invocación de funciones

Otorga permisos de IAM en el bucket de GCS

Otorga permisos de escritura a la cuenta de servicio en el bucket de GCS:

Ve a Cloud Storage > Buckets.
Haz clic en el nombre de tu bucket.
Ve a la pestaña Permisos.
Haz clic en Otorgar acceso.
Proporciona los siguientes detalles de configuración:
- Agregar principales: Ingresa el correo electrónico de la cuenta de servicio (por ejemplo, beyondtrust-epm-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Asignar roles: Selecciona Administrador de objetos de Storage.
Haz clic en Guardar.

Crear tema de Pub/Sub

Crea un tema de Pub/Sub en el que Cloud Scheduler publicará y al que se suscribirá la función de Cloud Run.

En GCP Console, ve a Pub/Sub > Temas.
Haz clic en Crear un tema.
Proporciona los siguientes detalles de configuración:
- ID del tema: Ingresa beyondtrust-epm-trigger.
- Deja el resto de la configuración con sus valores predeterminados.
Haz clic en Crear.

Crea una función de Cloud Run para recopilar registros

La función de Cloud Run se activa con mensajes de Pub/Sub de Cloud Scheduler para recuperar registros de la API de BeyondTrust EPM y escribirlos en GCS.

En GCP Console, ve a Cloud Run.
Haz clic en Crear servicio.
Selecciona Función (usa un editor intercalado para crear una función).

En la sección Configurar, proporciona los siguientes detalles de configuración:

Configuración	Valor
Nombre del servicio	`beyondtrust-epm-collector`
Región	Selecciona la región que coincida con tu bucket de GCS (por ejemplo, `us-central1`).
Tiempo de ejecución	Selecciona Python 3.12 o una versión posterior.

En la sección Activador (opcional), haz lo siguiente:
1. Haz clic en + Agregar activador.
2. Selecciona Cloud Pub/Sub.
3. En Selecciona un tema de Cloud Pub/Sub, elige el tema beyondtrust-epm-trigger.
4. Haz clic en Guardar.
En la sección Autenticación, haz lo siguiente:
1. Selecciona Solicitar autenticación.
2. Verifica Identity and Access Management (IAM).
Nota: Pub/Sub controla automáticamente la autenticación cuando invoca la función.
Desplázate hacia abajo y expande Contenedores, redes y seguridad.
Ve a la pestaña Seguridad:
- Cuenta de servicio: Selecciona la cuenta de servicio beyondtrust-epm-collector-sa.

Ve a la pestaña Contenedores:

Haz clic en Variables y secretos.
Haz clic en + Agregar variable para cada variable de entorno:

Nombre de la variable	Valor de ejemplo
`GCS_BUCKET`	`beyondtrust-epm-logs`
`GCS_PREFIX`	`beyondtrust-epm/`
`STATE_KEY`	`beyondtrust-epm/state.json`
`BPT_API_URL`	`https://yourtenant-services.pm.beyondtrustcloud.com`
`CLIENT_ID`	`your-client-id`
`CLIENT_SECRET`	`your-client-secret`
`OAUTH_SCOPE`	`management-api`
`RECORD_SIZE`	`1000`
`MAX_ITERATIONS`	`10`

En la pestaña Variables y Secrets, desplázate hacia abajo hasta Requests:
- Tiempo de espera de la solicitud: Ingresa 600 segundos (10 minutos).
Ve a la pestaña Configuración en Contenedores:
- En la sección Recursos, haz lo siguiente:
  - Memoria: Selecciona 512 MiB o más.
  - CPU: Selecciona 1.
- Haz clic en Listo.
Desplázate hasta Entorno de ejecución:
- Selecciona Predeterminado (recomendado).
En la sección Ajuste de escala de revisión, haz lo siguiente:
- Cantidad mínima de instancias: Ingresa 0.
- Cantidad máxima de instancias: Ingresa 100 (o ajusta según la carga esperada).
Haz clic en Crear.
Espera a que se cree el servicio (de 1 a 2 minutos).
Después de crear el servicio, se abrirá automáticamente el editor de código intercalado.

Agregar el código de función

Ingresa main en Punto de entrada de la función.

En el editor de código intercalado, crea dos archivos:

Primer archivo: main.py:

import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time

# Initialize HTTP client
http = urllib3.PoolManager()

# Initialize Storage client
storage_client = storage.Client()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch logs from BeyondTrust EPM API and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'beyondtrust-epm/')
    state_key = os.environ.get('STATE_KEY', 'beyondtrust-epm/state.json')

    # BeyondTrust EPM API credentials
    api_url = os.environ.get('BPT_API_URL')
    client_id = os.environ.get('CLIENT_ID')
    client_secret = os.environ.get('CLIENT_SECRET')
    oauth_scope = os.environ.get('OAUTH_SCOPE', 'management-api')
    record_size = int(os.environ.get('RECORD_SIZE', '1000'))
    max_iterations = int(os.environ.get('MAX_ITERATIONS', '10'))

    if not all([bucket_name, api_url, client_id, client_secret]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(bucket_name)

        # Load state (last processed timestamp)
        state = load_state(bucket, state_key)
        last_timestamp = state.get('last_timestamp', (datetime.utcnow() - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ"))

        print(f'Processing logs since {last_timestamp}')

        # Get OAuth access token
        token = get_oauth_token(api_url, client_id, client_secret, oauth_scope)

        # Fetch audit events
        events = fetch_audit_events(api_url, token, last_timestamp, record_size, max_iterations)

        if events:
            # Store events in GCS
            current_timestamp = datetime.utcnow()
            filename = f"{prefix}beyondtrust-epm-events-{current_timestamp.strftime('%Y%m%d_%H%M%S')}.json"
            store_events_to_gcs(bucket, filename, events)

            # Update state with latest timestamp
            latest_timestamp = get_latest_event_timestamp(events)
            save_state(bucket, state_key, {'last_timestamp': latest_timestamp, 'updated_at': datetime.utcnow().isoformat() + 'Z'})

            print(f'Successfully processed {len(events)} events and stored to {filename}')
        else:
            print('No new events found')

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

def get_oauth_token(api_url, client_id, client_secret, scope):
    """
    Get OAuth access token using client credentials flow for BeyondTrust EPM.
    Uses the correct endpoint: /oauth/token
    """
    token_url = f"{api_url}/oauth/token"
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    body = f"grant_type=client_credentials&client_id={client_id}&client_secret={client_secret}&scope={scope}"

    response = http.request('POST', token_url, headers=headers, body=body, timeout=urllib3.Timeout(60.0))

    if response.status != 200:
        raise RuntimeError(f"Token request failed: {response.status} {response.data[:256]!r}")

    token_data = json.loads(response.data.decode('utf-8'))
    return token_data['access_token']

def fetch_audit_events(api_url, access_token, last_timestamp, record_size, max_iterations):
    """
    Fetch audit events using the BeyondTrust EPM API endpoint: /management-api/v2/AuditEvents
    with query parameters for filtering and pagination
    """
    headers = {
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'application/json'
    }

    all_events = []
    current_start_date = last_timestamp
    iterations = 0

    # Enforce maximum RecordSize limit of 1000 based on BeyondTrust documentation
    record_size_limited = min(record_size, 1000)

    while iterations < max_iterations:
        iterations += 1

        if len(all_events) >= 10000:
            print(f"Reached maximum events limit (10000)")
            break

        # Use the BeyondTrust EPM API endpoint for audit events
        query_url = f"{api_url}/management-api/v2/AuditEvents"
        params = {
            'StartDate': current_start_date,
            'RecordSize': record_size_limited
        }

        # Construct URL with query parameters
        query_string = '&'.join([f"{k}={v}" for k, v in params.items()])
        full_url = f"{query_url}?{query_string}"

        try:
            response = http.request('GET', full_url, headers=headers, timeout=urllib3.Timeout(300.0))

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', '30'))
                print(f"Rate limited (429). Retrying after {retry_after}s...")
                time.sleep(retry_after)
                continue

            if response.status != 200:
                raise RuntimeError(f"API request failed: {response.status} {response.data[:256]!r}")

            response_data = json.loads(response.data.decode('utf-8'))
            events = response_data.get('events', [])

            if not events:
                break

            print(f"Page {iterations}: Retrieved {len(events)} events")
            all_events.extend(events)

            # If we got fewer events than RecordSize, we've reached the end
            if len(events) < record_size_limited:
                break

            # For pagination, update StartDate to the timestamp of the last event
            last_event = events[-1]
            last_timestamp = extract_event_timestamp(last_event)

            if not last_timestamp:
                print("Warning: Could not find timestamp in last event for pagination")
                break

            # Convert to datetime and add 1 second to avoid retrieving the same event again
            try:
                dt = parse_timestamp(last_timestamp)
                dt = dt + timedelta(seconds=1)
                current_start_date = dt.strftime("%Y-%m-%dT%H:%M:%SZ")
            except Exception as e:
                print(f"Error parsing timestamp {last_timestamp}: {e}")
                break

        except Exception as e:
            print(f"Error fetching page {iterations}: {e}")
            break

    return all_events

def extract_event_timestamp(event):
    """Extract timestamp from event, checking multiple possible fields"""
    # Check common timestamp fields
    timestamp_fields = ['event.dateTime', 'event.timestamp', 'timestamp', 'eventTime', 'dateTime', 'whenOccurred', 'date', 'time', 'event.ingested']

    # Try nested event.dateTime first (common in BeyondTrust)
    if isinstance(event, dict) and isinstance(event.get("event"), dict):
        ts = event["event"].get("dateTime")
        if ts:
            return ts
        ts = event["event"].get("timestamp")
        if ts:
            return ts

    # Fallback to other timestamp fields
    for field in timestamp_fields:
        if field in event and event[field]:
            return event[field]

    return None

def parse_timestamp(timestamp_str):
    """Parse timestamp string to datetime object, handling various formats"""
    if isinstance(timestamp_str, (int, float)):
        # Unix timestamp (in milliseconds or seconds)
        if timestamp_str > 1e12:  # Milliseconds
            return datetime.fromtimestamp(timestamp_str / 1000, tz=timezone.utc)
        else:  # Seconds
            return datetime.fromtimestamp(timestamp_str, tz=timezone.utc)

    if isinstance(timestamp_str, str):
        # Try different string formats
        try:
            # ISO format with Z
            if timestamp_str.endswith('Z'):
                return datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
            # ISO format with timezone
            elif '+' in timestamp_str or timestamp_str.endswith('00:00'):
                return datetime.fromisoformat(timestamp_str)
            # ISO format without timezone (assume UTC)
            else:
                dt = datetime.fromisoformat(timestamp_str)
                if dt.tzinfo is None:
                    dt = dt.replace(tzinfo=timezone.utc)
                return dt
        except ValueError:
            pass

    raise ValueError(f"Could not parse timestamp: {timestamp_str}")

def load_state(bucket, key):
    """Load state from GCS."""
    try:
        blob = bucket.blob(key)
        if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
    except Exception as e:
        print(f'Warning: Could not load state: {str(e)}')
    return {}

def save_state(bucket, key, state):
    """Save state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state),
            content_type='application/json'
        )
    except Exception as e:
        print(f'Warning: Could not save state: {str(e)}')

def store_events_to_gcs(bucket, key, events):
    """Store events as JSONL (one JSON object per line) in GCS"""
    # Convert to JSONL format (one JSON object per line)
    jsonl_content = '\n'.join(json.dumps(event, default=str) for event in events)

    blob = bucket.blob(key)
    blob.upload_from_string(jsonl_content, content_type='application/x-ndjson')

def get_latest_event_timestamp(events):
    """Get the latest timestamp from the events for state tracking"""
    if not events:
        return datetime.utcnow().isoformat() + 'Z'

    latest = None
    for event in events:
        timestamp = extract_event_timestamp(event)
        if timestamp:
            try:
                event_dt = parse_timestamp(timestamp)
                event_iso = event_dt.isoformat() + 'Z'
                if latest is None or event_iso > latest:
                    latest = event_iso
            except Exception as e:
                print(f"Error parsing event timestamp {timestamp}: {e}")
                continue

    return latest or datetime.utcnow().isoformat() + 'Z'

Segundo archivo: requirements.txt:

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

Haz clic en Implementar para guardar y, luego, implementar la función.
Espera a que se complete la implementación (de 2 a 3 minutos).

Nota: La configuración del activador de Pub/Sub crea automáticamente las suscripciones y los permisos necesarios.

Crea un trabajo de Cloud Scheduler

Cloud Scheduler publica mensajes en el tema de Pub/Sub a intervalos regulares, lo que activa la función de Cloud Run.

En GCP Console, ve a Cloud Scheduler.
Haz clic en Crear trabajo.

Proporciona los siguientes detalles de configuración:

Configuración	Valor
Nombre	`beyondtrust-epm-collector-hourly`
Región	Selecciona la misma región que la función de Cloud Run
Frecuencia	`0 * * * *` (cada hora, en punto)
Zona horaria	Selecciona la zona horaria (se recomienda UTC)
Tipo de orientación	Pub/Sub
Tema	Selecciona el tema `beyondtrust-epm-trigger`.
Cuerpo del mensaje	`{}` (objeto JSON vacío)

Haz clic en Crear.

Opciones de frecuencia de programación

Elige la frecuencia según los requisitos de latencia y volumen de registros:

Frecuencia	Expresión cron	Caso de uso
Cada 5 minutos	`/5 * * *`	Alto volumen y baja latencia
Cada 15 minutos	`/15 * * *`	Volumen medio
Cada 1 hora	`0 * * * *`	Estándar (opción recomendada)
Cada 6 horas	`0 /6 * *`	Procesamiento por lotes y volumen bajo
Diario	`0 0 * * *`	Recopilación de datos históricos

Prueba el trabajo de Scheduler

En la consola de Cloud Scheduler, busca tu trabajo.
Haz clic en Forzar ejecución para activarlo de forma manual.
Espera unos segundos y ve a Cloud Run > Servicios > beyondtrust-epm-collector > Registros.
Verifica que la función se haya ejecutado correctamente.
Verifica el bucket de GCS para confirmar que se escribieron los registros.

Recupera la cuenta de servicio de Google SecOps

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

Ve a Configuración de SIEM > Feeds.
Haz clic en Agregar feed nuevo.
Haz clic en Configura un feed único.
En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, BeyondTrust EPM logs).
Selecciona Google Cloud Storage V2 como el Tipo de fuente.
Selecciona BeyondTrust Endpoint Privilege Management como el Tipo de registro.
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
```
Copia esta dirección de correo electrónico para usarla en el siguiente paso.

Nota: Cada instancia de Google SecOps tiene una cuenta de servicio única. No uses cuentas de servicio de otros ejemplos o documentación.

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 GCS.

Ve a Cloud Storage > Buckets.
Haz clic en el nombre de tu bucket.
Ve a la pestaña Permisos.
Haz clic en Otorgar acceso.
Proporciona los siguientes detalles de configuración:
- Agregar principales: Pega el correo electrónico de la cuenta de servicio de Google SecOps.
- Asignar roles: Selecciona Visualizador de objetos de Storage.
Haz clic en Guardar.

Nota: Si planeas usar la opción de eliminación "Borrar archivos transferidos" o "Borrar archivos transferidos y directorios vacíos", otorga el rol de Administrador de objetos de Storage en lugar del rol de Visualizador de objetos de Storage.

Configura un feed en Google SecOps para transferir registros de BeyondTrust EPM

Ve a Configuración de SIEM > Feeds.
Haz clic en Agregar feed nuevo.
Haz clic en Configura un feed único.
En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, BeyondTrust EPM logs).
Selecciona Google Cloud Storage V2 como el Tipo de fuente.
Selecciona BeyondTrust Endpoint Privilege Management como el Tipo de registro.
Haz clic en Siguiente.
Especifica valores para los siguientes parámetros de entrada:
- URL del bucket de almacenamiento: Ingresa el URI del bucket de GCS con la ruta de acceso del prefijo:
```
gs://beyondtrust-epm-logs/beyondtrust-epm/
```
  - Reemplaza lo siguiente:
    - beyondtrust-epm-logs: Es el nombre de tu bucket de GCS.
    - beyondtrust-epm/: Es el prefijo o la ruta de carpeta opcionales en los que se almacenan los registros (déjalo vacío para la raíz).
  - Ejemplos:
    - Bucket raíz: gs://beyondtrust-epm-logs/
    - Con prefijo: gs://beyondtrust-epm-logs/beyondtrust-epm/
  Nota: Siempre incluye la barra diagonal final (/) al final del URI.
- 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.
    
    Nota: Si seleccionas una opción de eliminación, la cuenta de servicio debe tener el rol de administrador de objetos de Storage en lugar del rol de visualizador de objetos de Storage. Actualiza los permisos de IAM según corresponda.
- Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días especificada. El valor predeterminado es de 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.
Haz clic en Siguiente.
Revisa la nueva configuración del feed en la pantalla Finalizar y, luego, haz clic en Enviar.

Tabla de asignación de UDM

Campo de registro	Asignación de UDM	Lógica
agent.id	principal.asset.attribute.labels.value	Se asignó a la etiqueta con la clave agent_id
agent.version	principal.asset.attribute.labels.value	Se asignó a la etiqueta con la clave agent_version
ecs.version	principal.asset.attribute.labels.value	Se asignó a la etiqueta con la clave ecs_version
event_data.reason	metadata.description	Descripción del evento del registro sin procesar
event_datas.ActionId	metadata.product_log_id	Identificador de registro específico del producto
file.path	principal.file.full_path	Ruta de acceso completa al archivo del evento
headers.content_length	additional.fields.value.string_value	Se asignó a la etiqueta con el valor clave content_length
headers.content_type	additional.fields.value.string_value	Se asigna a la etiqueta con la clave content_type
headers.http_host	additional.fields.value.string_value	Se asigna a la etiqueta con la clave http_host
headers.http_version	network.application_protocol_version	Versión del protocolo HTTP
headers.request_method	network.http.method	Método de solicitud HTTP
host.hostname	principal.hostname	Nombre de host principal
host.hostname	principal.asset.hostname	Nombre de host del recurso principal
host.ip	principal.asset.ip	Dirección IP del activo principal
host.ip	principal.ip	Dirección IP principal
host.mac	principal.mac	Dirección MAC principal
host.os.platform	principal.platform	Se establece en MAC si es igual a macOS.
host.os.version	principal.platform_version	Versión del sistema operativo
labels.related_item_id	metadata.product_log_id	Identificador del elemento relacionado
process.command_line	principal.process.command_line	Línea de comandos del proceso
process.name	additional.fields.value.string_value	Se asignó a la etiqueta con la clave process_name
process.parent.name	additional.fields.value.string_value	Se asignó a la etiqueta con la clave process_parent_name
process.parent.pid	principal.process.parent_process.pid	PID del proceso principal convertido en cadena
process.pid	principal.process.pid	PID del proceso convertido en cadena
user.id	principal.user.userid	Identificador del usuario
user.name	principal.user.user_display_name	Nombre visible del usuario
N/A	metadata.event_timestamp	La marca de tiempo del evento se establece en la marca de tiempo de la entrada de registro.
N/A	metadata.event_type	GENERIC_EVENT si no hay principal; de lo contrario, STATUS_UPDATE
N/A	network.application_protocol	Se establece en HTTP si el campo http_version contiene HTTP.

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