Recopila registros de Symantec Web Security Service (WSS)

Se admite en los siguientes sistemas operativos:

En este documento, se explica cómo transferir registros de Symantec Web Security Service (WSS) a Google Security Operations con Google Cloud Storage. Primero, el analizador intenta analizar el mensaje de registro como JSON. Si eso falla, usa una serie de patrones de grok cada vez más específicos para extraer campos del texto sin procesar y, finalmente, asigna los datos extraídos al Modelo de datos unificado (UDM). Symantec Web Security Service (WSS) es una solución de seguridad web basada en la nube que brinda protección en tiempo real contra amenazas basadas en la Web, como software malicioso, phishing y pérdida de datos.

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 con privilegios al portal de Symantec Web Security Service

Recopila credenciales de la API de Symantec WSS

Obtén la URL del sitio de Symantec WSS

  1. Accede al portal de Symantec Web Security Service.
  2. Toma nota de la URL del portal en la barra de direcciones del navegador.
    • Formato: https://portal.threatpulse.com o la URL específica de tu organización
    • Ejemplo: Si accedes a WSS en https://portal.threatpulse.com/reportpod, la URL de tu sitio es https://portal.threatpulse.com.

Crea credenciales de API

  1. Accede al portal de Symantec Web Security Service como administrador.
  2. Ve a Cuenta > Credenciales de API.
  3. Haz clic en Agregar credenciales de API.
  4. En el portal, se muestra el diálogo Add API Credential con el Username y la Password generados automáticamente.

  5. Copia y guarda de forma segura el nombre de usuario y la contraseña.

  6. Selecciona la opción API Expiry:

    • Basado en el tiempo: Define la fecha y la hora en que vence este token.
    • Nunca vence: El token sigue siendo válido de forma indefinida (se recomienda para la producción).

  7. En la opción Acceso, selecciona Registros de acceso a informes.

  8. Haz clic en Guardar.

Verifica los permisos

Para verificar que la cuenta tenga los permisos necesarios, sigue estos pasos:

  1. Accede al portal de Symantec Web Security Service.
  2. Ve a Cuenta > Credenciales de API.
  3. Si puedes ver las credenciales de la API que creaste con Access configurado como Reporting Access Logs, tienes los permisos necesarios.
  4. Si no ves esta opción, comunícate con tu administrador para que te otorgue permiso para acceder a los registros de acceso a los informes.

Prueba el acceso a la API

  • Prueba tus credenciales antes de continuar con la integración:

    # Replace with your actual credentials
WSS_USERNAME="your-api-username"
WSS_PASSWORD="your-api-password"
WSS_SYNC_URL="https://portal.threatpulse.com/reportpod/logs/sync"

# Test API access (note: sync endpoint requires time parameters)
curl -v -H "X-APIUsername: ${WSS_USERNAME}" \
  -H "X-APIPassword: ${WSS_PASSWORD}" \
  "${WSS_SYNC_URL}?startDate=0&endDate=1000&token=none"

Respuesta esperada: HTTP 200 con datos de registro o respuesta vacía si no hay registros en el período.

Crea un bucket de Google Cloud Storage

  1. Ve a Google Cloud Console.
  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, symantec-wss-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

  6. Haz clic en Crear.

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

  1. En GCP Console, 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 symantec-wss-collector-sa.
    • Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect Symantec WSS logs.
  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:
    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.
  6. Haz clic en Continuar.
  7. 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:

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket.
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar principales: Ingresa el correo electrónico de la cuenta de servicio (por ejemplo, symantec-wss-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Asignar roles: Selecciona Administrador de objetos de Storage.
  6. 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.

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

Crea una función de Cloud Run para recopilar registros

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

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

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

    Configuración Valor
    Nombre del servicio symantec-wss-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.

  5. 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 de Pub/Sub (symantec-wss-trigger).
    4. Haz clic en Guardar.

  6. En la sección Autenticación, haz lo siguiente:

    1. Selecciona Solicitar autenticación.
    2. Verifica Identity and Access Management (IAM).

  7. Desplázate hacia abajo y expande Contenedores, redes y seguridad.

  8. Ve a la pestaña Seguridad:

    • Cuenta de servicio: Selecciona la cuenta de servicio (symantec-wss-collector-sa).

  9. Ve a la pestaña Contenedores:

    1. Haz clic en Variables y secretos.
    2. Haz clic en + Agregar variable para cada variable de entorno:
    Nombre de la variable Valor de ejemplo Descripción
    GCS_BUCKET symantec-wss-logs Nombre del bucket de GCS
    GCS_PREFIX symantec/wss/ Prefijo para los archivos de registro
    STATE_KEY symantec/wss/state.json Ruta de acceso al archivo de estado
    WINDOW_SECONDS 3600 Período en segundos (1 hora)
    HTTP_TIMEOUT 60 Tiempo de espera de la solicitud HTTP en segundos
    MAX_RETRIES 3 Cantidad máxima de reintentos
    USER_AGENT symantec-wss-to-gcs/1.0 Cadena de usuario-agente
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync Extremo de la API de sincronización de WSS
    WSS_API_USERNAME your-api-username (de las credenciales de API) Nombre de usuario de la API de WSS
    WSS_API_PASSWORD your-api-password (de las credenciales de API) Contraseña de la API de WSS
    WSS_TOKEN_PARAM none Parámetro de token para la API de sincronización

  10. En la sección Variables y Secrets, desplázate hasta Requests:

    • Tiempo de espera de la solicitud: Ingresa 600 segundos (10 minutos).

  11. Ve a la pestaña Configuración:

    • En la sección Recursos, haz lo siguiente:
      • Memoria: Selecciona 512 MiB o más.
      • CPU: Selecciona 1.

  12. 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).

  13. Haz clic en Crear.

  14. Espera a que se cree el servicio (de 1 a 2 minutos).

  15. Después de crear el servicio, se abrirá automáticamente el editor de código intercalado.

Agregar el código de función

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

  2. 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
import uuid
import time

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=60.0),
    retries=False,
)

# 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 Symantec WSS Sync 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', 'symantec/wss/')
    state_key = os.environ.get('STATE_KEY', 'symantec/wss/state.json')
    window_sec = int(os.environ.get('WINDOW_SECONDS', '3600'))
    http_timeout = int(os.environ.get('HTTP_TIMEOUT', '60'))
    max_retries = int(os.environ.get('MAX_RETRIES', '3'))
    user_agent = os.environ.get('USER_AGENT', 'symantec-wss-to-gcs/1.0')
    wss_sync_url = os.environ.get('WSS_SYNC_URL', 'https://portal.threatpulse.com/reportpod/logs/sync')
    api_username = os.environ.get('WSS_API_USERNAME')
    api_password = os.environ.get('WSS_API_PASSWORD')
    token_param = os.environ.get('WSS_TOKEN_PARAM', 'none')

    if not all([bucket_name, api_username, api_password]):
        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)
        now = datetime.now(timezone.utc).timestamp()
        from_ts = float(state.get('last_to_ts', now - window_sec))
        to_ts = now

        # Convert to milliseconds for WSS API
        start_ms = int(from_ts * 1000)
        end_ms = int(to_ts * 1000)

        print(f'Fetching Symantec WSS logs from {start_ms} to {end_ms}')

        # Fetch logs from WSS Sync API
        blob_data, content_type, content_encoding = fetch_wss_logs(
            wss_sync_url, api_username, api_password, token_param,
            start_ms, end_ms, user_agent, http_timeout, max_retries
        )

        print(f'Retrieved {len(blob_data)} bytes with content-type: {content_type}')
        if content_encoding:
            print(f'Content encoding: {content_encoding}')

        # Write to GCS
        if blob_data:
            blob_name = write_wss_data(
                bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts
            )
            print(f'Wrote logs to {blob_name}')

        # Update state
        save_state(bucket, state_key, {
            'last_to_ts': to_ts,
            'last_successful_run': now
        })

        print(f'Successfully processed logs up to {to_ts}')

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

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, separators=(',', ':')),
            content_type='application/json'
        )
    except Exception as e:
        print(f'Warning: Could not save state: {str(e)}')

def fetch_wss_logs(sync_url, username, password, token, start_ms, end_ms, user_agent, timeout, max_retries):
    """Fetch logs from WSS Sync API with retry logic using custom HTTP headers."""
    params = f"startDate={start_ms}&endDate={end_ms}&token={token}"
    url = f"{sync_url}?{params}"

    attempt = 0
    backoff = 1.0

    while True:
        try:
            headers = {
                'User-Agent': user_agent,
                'X-APIUsername': username,
                'X-APIPassword': password
            }

            response = http.request('GET', url, headers=headers, timeout=timeout)

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

            backoff = 1.0

            if response.status == 200:
                content_type = response.headers.get('Content-Type', 'application/octet-stream')
                content_encoding = response.headers.get('Content-Encoding', '')
                return response.data, content_type, content_encoding
            else:
                raise Exception(f'HTTP {response.status}: {response.data.decode("utf-8", errors="ignore")}')

        except Exception as e:
            attempt += 1
            print(f'HTTP error on attempt {attempt}: {e}')
            if attempt > max_retries:
                raise
            # Exponential backoff with jitter
            time.sleep(min(60, 2 ** attempt) + (time.time() % 1))

def determine_extension(content_type, content_encoding):
    """Determine file extension based on content type and encoding."""
    if 'zip' in content_type.lower():
        return '.zip'
    if 'gzip' in content_type.lower() or content_encoding.lower() == 'gzip':
        return '.gz'
    if 'json' in content_type.lower():
        return '.json'
    if 'csv' in content_type.lower():
        return '.csv'
    return '.bin'

def write_wss_data(bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts):
    """Write WSS data to GCS with unique key."""
    ts_path = datetime.fromtimestamp(to_ts, tz=timezone.utc).strftime('%Y/%m/%d')
    uniq = f"{int(time.time() * 1e6)}_{uuid.uuid4().hex[:8]}"
    ext = determine_extension(content_type, content_encoding)
    blob_name = f"{prefix}{ts_path}/symantec_wss_{int(from_ts)}_{int(to_ts)}_{uniq}{ext}"

    blob = bucket.blob(blob_name)
    blob.upload_from_string(
        blob_data,
        content_type=content_type
    )

    # Set metadata
    blob.metadata = {
        'source': 'symantec-wss',
        'from_timestamp': str(int(from_ts)),
        'to_timestamp': str(int(to_ts)),
        'content_encoding': content_encoding
    }
    blob.patch()

    return blob_name
    • Segundo archivo: requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Haz clic en Implementar para guardar y, luego, implementar la función.

  4. Espera a que se complete la implementación (de 2 a 3 minutos).

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.

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

  3. Proporciona los siguientes detalles de configuración:

    Configuración Valor
    Nombre symantec-wss-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 de Pub/Sub (symantec-wss-trigger).
    Cuerpo del mensaje {} (objeto JSON vacío)

  4. 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 la integración

  1. En la consola de Cloud Scheduler, busca tu trabajo.
  2. Haz clic en Forzar ejecución para activar el trabajo de forma manual.
  3. Espera unos segundos.
  4. Ve a Cloud Run > Servicios.
  5. Haz clic en el nombre de tu función (symantec-wss-collector).
  6. Haz clic en la pestaña Registros.

  7. Verifica que la función se haya ejecutado correctamente. Busca lo siguiente:

    Fetching Symantec WSS logs from [start_ms] to [end_ms]
Retrieved X bytes with content-type: [type]
Wrote logs to symantec/wss/YYYY/MM/DD/symantec_wss_[timestamps].[ext]
Successfully processed logs up to [timestamp]

  8. Ve a Cloud Storage > Buckets.

  9. Haz clic en el nombre de tu bucket.

  10. Navega a la carpeta del prefijo (symantec/wss/).

  11. Verifica que se haya creado un archivo nuevo con la marca de tiempo actual.

Si ves errores en los registros, haz lo siguiente:

  • HTTP 401: Verifica las credenciales de la API en las variables de entorno. Verifica que el nombre de usuario y la contraseña sean correctos.
  • HTTP 403: Verifica que las credenciales de la API tengan habilitado el permiso "Reporting Access Logs" en el portal de WSS.
  • HTTP 429: Se aplica una limitación de frecuencia. La función volverá a intentarlo automáticamente con una espera exponencial.
  • Faltan variables de entorno: Verifica que todas las variables requeridas estén configuradas en la configuración de Cloud Run Function.

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

  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, Symantec WSS logs).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona Symantec WSS como el Tipo de registro.

  7. Haz clic en Obtener cuenta de servicio. Se muestra 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.

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.

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket.
  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.
    • Asignar roles: Selecciona Visualizador de objetos de Storage.

  6. Haz clic en Guardar.

Configura un feed en Google SecOps para transferir registros de Symantec WSS

  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, Symantec WSS logs).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona Symantec WSS como el Tipo de registro.
  7. Haz clic en Siguiente.

  8. 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://symantec-wss-logs/symantec/wss/

      • Reemplaza lo siguiente:

        • symantec-wss-logs: Es el nombre de tu bucket de GCS.
        • symantec/wss/: 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://company-logs/
        • Con prefijo: gs://company-logs/symantec-wss/
        • Con subcarpeta: gs://company-logs/symantec/wss/

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

  9. Haz clic en Siguiente.

  10. 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
category_id read_only_udm.metadata.product_event_type Si category_id es 1, read_only_udm.metadata.product_event_type se establece en Security. Si category_id es 5, entonces read_only_udm.metadata.product_event_type se establece en Policy.
collector_device_ip read_only_udm.principal.ip, read_only_udm.principal.asset.ip Valor del campo collector_device_ip
connection.bytes_download read_only_udm.network.received_bytes Valor del campo connection.bytes_download convertido en número entero
connection.bytes_upload read_only_udm.network.sent_bytes Valor del campo connection.bytes_upload convertido en número entero
connection.dst_ip read_only_udm.target.ip Valor del campo connection.dst_ip
connection.dst_location.country read_only_udm.target.location.country_or_region Valor del campo connection.dst_location.country
connection.dst_name read_only_udm.target.hostname Valor del campo connection.dst_name
connection.dst_port read_only_udm.target.port Valor del campo connection.dst_port convertido en número entero
connection.http_status read_only_udm.network.http.response_code El valor del campo connection.http_status se convirtió en un número entero.
connection.http_user_agent read_only_udm.network.http.user_agent Valor del campo connection.http_user_agent
connection.src_ip read_only_udm.principal.ip, read_only_udm.src.ip Es el valor del campo connection.src_ip. Si src_ip o collector_device_ip no están vacíos, se asignan a read_only_udm.src.ip.
connection.tls.version read_only_udm.network.tls.version_protocol Valor del campo connection.tls.version
connection.url.host read_only_udm.target.hostname Valor del campo connection.url.host
connection.url.method read_only_udm.network.http.method Valor del campo connection.url.method
connection.url.path read_only_udm.target.url Valor del campo connection.url.path
connection.url.text read_only_udm.target.url Valor del campo connection.url.text
cs_connection_negotiated_cipher read_only_udm.network.tls.cipher Valor del campo cs_connection_negotiated_cipher
cs_icap_status read_only_udm.security_result.description Valor del campo cs_icap_status
device_id read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id Valor del campo device_id
device_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valor del campo device_ip
device_time read_only_udm.metadata.collected_timestamp, read_only_udm.metadata.event_timestamp Es el valor del campo device_time convertido en cadena. Si when está vacío, se asigna a read_only_udm.metadata.event_timestamp.
Nombre de host read_only_udm.principal.hostname, read_only_udm.principal.asset.hostname Valor del campo de nombre de host
log_time read_only_udm.metadata.event_timestamp Es el valor del campo log_time convertido en marca de tiempo. Si when y device_time están vacíos, se asigna a read_only_udm.metadata.event_timestamp.
msg_desc read_only_udm.metadata.description Valor del campo msg_desc
os_details read_only_udm.target.asset.platform_software.platform, read_only_udm.target.asset.platform_software.platform_version Es el valor del campo os_details. Si os_details no está vacío, se analiza para extraer os_name y os_ver. Si os_name contiene Windows, read_only_udm.target.asset.platform_software.platform se establece en WINDOWS. os_ver se asigna a read_only_udm.target.asset.platform_software.platform_version.
product_data.cs(Referer) read_only_udm.network.http.referral_url Valor del campo product_data.cs(Referer)
product_data.r-supplier-country read_only_udm.principal.location.country_or_region Valor del campo product_data.r-supplier-country
product_data.s-supplier-ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valor del campo product_data.s-supplier-ip
product_data.x-bluecoat-application-name read_only_udm.target.application Valor del campo product_data.x-bluecoat-application-name
product_data.x-bluecoat-transaction-uuid read_only_udm.metadata.product_log_id Valor del campo product_data.x-bluecoat-transaction-uuid
product_data.x-client-agent-sw read_only_udm.observer.platform_version Valor del campo product_data.x-client-agent-sw
product_data.x-client-agent-type read_only_udm.observer.application Valor del campo product_data.x-client-agent-type
product_data.x-client-device-id read_only_udm.target.resource.type, read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id Si no está vacío, read_only_udm.target.resource.type se establece en DEVICE. El valor del campo product_data.x-client-device-id se asigna a read_only_udm.target.resource.id y read_only_udm.target.resource.product_object_id.
product_data.x-client-device-name read_only_udm.src.hostname, read_only_udm.src.asset.hostname Valor del campo product_data.x-client-device-name
product_data.x-cs-client-ip-country read_only_udm.target.location.country_or_region Valor del campo product_data.x-cs-client-ip-country
product_data.x-cs-connection-negotiated-cipher read_only_udm.network.tls.cipher Valor del campo product_data.x-cs-connection-negotiated-cipher
product_data.x-cs-connection-negotiated-ssl-version read_only_udm.network.tls.version_protocol Valor del campo product_data.x-cs-connection-negotiated-ssl-version
product_data.x-exception-id read_only_udm.security_result.summary Valor del campo product_data.x-exception-id
product_data.x-rs-certificate-hostname read_only_udm.network.tls.client.server_name Valor del campo product_data.x-rs-certificate-hostname
product_data.x-rs-certificate-hostname-categories read_only_udm.security_result.category_details Valor del campo product_data.x-rs-certificate-hostname-categories
product_data.x-rs-certificate-observed-errors read_only_udm.network.tls.server.certificate.issuer Valor del campo product_data.x-rs-certificate-observed-errors
product_data.x-rs-certificate-validate-status read_only_udm.network.tls.server.certificate.subject Valor del campo product_data.x-rs-certificate-validate-status
product_name read_only_udm.metadata.product_name Valor del campo product_name
product_ver read_only_udm.metadata.product_version Valor del campo product_ver
proxy_connection.src_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valor del campo proxy_connection.src_ip
received_bytes read_only_udm.network.received_bytes Valor del campo received_bytes convertido en número entero
ref_uid read_only_udm.metadata.product_log_id Valor del campo ref_uid
s_action read_only_udm.metadata.description Valor del campo s_action
sent_bytes read_only_udm.network.sent_bytes Valor del campo sent_bytes convertido en número entero
severity_id read_only_udm.security_result.severity Si severity_id es 1 o 2, entonces read_only_udm.security_result.severity se establece en LOW. Si severity_id es 3 o 4, read_only_udm.security_result.severity se establece en MEDIUM. Si severity_id es 5 o 6, read_only_udm.security_result.severity se establece en HIGH.
supplier_country read_only_udm.principal.location.country_or_region Valor del campo supplier_country
target_ip read_only_udm.target.ip, read_only_udm.target.asset.ip Valor del campo target_ip
user.full_name read_only_udm.principal.user.user_display_name Valor del campo user.full_name
user.name read_only_udm.principal.user.user_display_name Valor del campo user.name
user_name read_only_udm.principal.user.user_display_name Valor del campo user_name
uuid read_only_udm.metadata.product_log_id Valor del campo uuid
cuándo read_only_udm.metadata.event_timestamp Valor de cuándo se convirtió el campo en una marca de tiempo
read_only_udm.metadata.event_type Se establece en NETWORK_UNCATEGORIZED si el nombre de host está vacío y connection.dst_ip no está vacío. Se establece en SCAN_NETWORK si el nombre de host no está vacío. Se establece en NETWORK_CONNECTION si has_principal y has_target son verdaderos. Se establece en STATUS_UPDATE si has_principal es verdadero y has_target es falso. Se establece en GENERIC_EVENT si has_principal y has_target son falsos.
read_only_udm.metadata.log_type Siempre se establece en SYMANTEC_WSS
read_only_udm.metadata.vendor_name Siempre se debe establecer en SYMANTEC.
read_only_udm.security_result.action Se establece en ALLOW si product_data.sc-filter_result es OBSERVED o PROXIED. Se establece en BLOCK si product_data.sc-filter_result es DENIED
read_only_udm.security_result.action_details Valor del campo product_data.sc-filter_result
read_only_udm.target.resource.type Se establece en DEVICE si product_data.x-client-device-id no está vacío.

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