Recopila registros de análisis forense de TAP de Proofpoint

Compatible con:

Google SecOps SIEM

En este documento, se explica cómo transferir registros de Proofpoint TAP Forensics a Google Security Operations con Google Cloud Storage V2.

Proofpoint Targeted Attack Protection (TAP) es una plataforma avanzada de seguridad de correo electrónico que detecta, analiza y bloquea las amenazas que se envían por correo electrónico, incluidos los archivos adjuntos y las URLs maliciosas. La API de TAP Forensics proporciona evidencia forense detallada sobre las amenazas y campañas individuales que se observan en tu entorno, incluidos los resultados del análisis de la zona de pruebas, los indicadores de comportamiento, la actividad de red, los cambios en el sistema de archivos y los datos de ejecución de procesos. Estos indicadores forenses se pueden usar para confirmar la vulneración de un host, enriquecer las fuentes de inteligencia de seguridad o coordinar actualizaciones de los extremos de seguridad.

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 crear servicios de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
• Una suscripción a TAP de Proofpoint con acceso al panel de Threat Insight
• Credenciales del servicio de la API de TAP (principal de servicio y secreto) con permisos para acceder a la API de SIEM y a la API de Forensics

Genera credenciales de servicio de la API de TAP de Proofpoint

1. Accede al panel de Threat Insight de TAP de Proofpoint.
2. Ve a Configuración > Aplicaciones conectadas > Credenciales de servicio.
3. Haz clic en Crear credencial nueva.

4. En el cuadro de diálogo Credencial de servicio generada, copia y almacena de forma segura lo siguiente:

   • Service Principal: Es el identificador de la principal que se usa para la autenticación de la API.
   • Secreto: Es la clave secreta que se usa para la autenticación de la API.
   Nota: El secreto se muestra solo una vez durante la creación. Si la pierdes, deberás generar una credencial nueva. Se requieren credenciales de servicio para todas las solicitudes a la API de TAP y se usa la autenticación básica de HTTP.

Verifica el acceso a la API

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

  PRINCIPAL="your-service-principal"
  SECRET="your-secret"
  
  # Test SIEM API access (fetch last 5 minutes of events)
  curl -s "https://tap-api-v2.proofpoint.com/v2/siem/all?format=json&sinceSeconds=300" \
    --user "${PRINCIPAL}:${SECRET}"
  
  # Test Forensics API access (requires a valid threatId)
  # curl -s "https://tap-api-v2.proofpoint.com/v2/forensics?threatId=<threatId>" \
  #   --user "${PRINCIPAL}:${SECRET}"
  

Una respuesta correcta de la API de SIEM devuelve un objeto JSON que contiene arrays de messagesBlocked, messagesDelivered, clicksBlocked y clicksPermitted.

• Si recibes un error 401, verifica que el principal de servicio y el secreto sean correctos.
• Si recibes un error 403, confirma que tu cuenta tenga habilitado el acceso a la API de TAP.

Crea 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:

   Parámetro de configuración	Valor
   Asigna un nombre a tu bucket	Ingresa un nombre único a nivel global (por ejemplo, proofpoint-tap-forensics-logs).
   Tipo de ubicación	Elige una en función de tus necesidades (región, birregional o 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 función de Cloud Run

La función de Cloud Run necesita una cuenta de servicio con permisos para escribir en el bucket de GCS y que Pub/Sub la invoque.

Crea la cuenta de servicio

1. En Google Cloud 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 tap-forensics-collector-sa
   • Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect Proofpoint TAP Forensics logs
4. Haz clic en Crear y continuar.
5. En la sección Otorga acceso al proyecto a esta cuenta de servicio, agrega los siguientes roles:
   1. Haz clic en Selecciona un rol.
   2. Busca y selecciona Administrador de objetos de Storage.
   3. Haz clic en + Agregar otro rol.
   4. Busca y selecciona Invocador de Cloud Run.
   5. Haz clic en + Agregar otro rol.
   6. Busca y selecciona Invocador de Cloud Functions.
6. Haz clic en Continuar.
7. Haz clic en Listo.

Estos roles son necesarios para lo siguiente:

• Administrador de objetos de Storage: Escribe datos de evidencia forense en el bucket de GCS y administra archivos de estado
• Invocador de Cloud Run: Permite que Pub/Sub invoque la función
• Invocador de Cloud Functions: 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 del 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, tap-forensics-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Asignar roles: Selecciona Administrador de objetos de Storage
6. Haz clic en Guardar.

Crea un 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 Google Cloud Console, ve a Pub/Sub > Temas.
2. Haz clic en Crear tema.
3. Proporciona los siguientes detalles de configuración:
   • ID del tema: Ingresa tap-forensics-collector-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 evidencia forense

La función de Cloud Run se activará con mensajes de Pub/Sub de Cloud Scheduler para recuperar eventos de amenazas de la API de SIEM de TAP de Proofpoint, recuperar evidencia forense para cada amenaza única con la API de Forensics y escribir los resultados en GCS.

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

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

   Parámetro de configuración	Valor
   Nombre del servicio	tap-forensics-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 tap-forensics-collector-trigger.
   4. Haz clic en Guardar.

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

   1. Selecciona Necesita autenticación.
   2. Verifica la Administración de identidades y accesos (IAM).
   Nota: Pub/Sub controlará automáticamente la autenticación cuando se invoque la función.

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 tap-forensics-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	proofpoint-tap-forensics-logs	Nombre del bucket de GCS
   GCS_PREFIX	tap-forensics	Prefijo para los archivos de registro
   STATE_KEY	tap-forensics/state.json	Ruta de acceso al archivo de estado
   TAP_PRINCIPAL	your-service-principal	Principal de servicio de la API de TAP
   TAP_SECRET	your-secret	Secreto de la API de TAP
   LOOKBACK_HOURS	1	Período de visualización inicial en horas (máx. 7 días)
   MAX_THREATS	500	Cantidad máxima de amenazas únicas para las que se recuperarán datos forenses por ejecución

10. En la sección Variables y secretos, desplázate hacia abajo hasta Solicitudes:

    • Tiempo de espera de la solicitud: Ingresa 540 segundos (9 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 Escalamiento 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 el campo Punto de entrada.

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, timedelta
     import time
     import base64
     
     # Initialize HTTP client with timeouts
     http = urllib3.PoolManager(
       timeout=urllib3.Timeout(connect=10.0, read=60.0),
       retries=False,
     )
     
     # Initialize Storage client
     storage_client = storage.Client()
     
     # Environment variables
     GCS_BUCKET = os.environ.get('GCS_BUCKET')
     GCS_PREFIX = os.environ.get('GCS_PREFIX', 'tap-forensics').strip('/')
     STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
     TAP_PRINCIPAL = os.environ.get('TAP_PRINCIPAL')
     TAP_SECRET = os.environ.get('TAP_SECRET')
     LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))
     MAX_THREATS = int(os.environ.get('MAX_THREATS', '500'))
     
     API_BASE = 'https://tap-api-v2.proofpoint.com'
     
     def get_auth_header():
       """Build HTTP Basic Authentication header."""
       auth_string = f"{TAP_PRINCIPAL}:{TAP_SECRET}"
       auth_bytes = auth_string.encode('utf-8')
       auth_b64 = base64.b64encode(auth_bytes).decode('utf-8')
       return f"Basic {auth_b64}"
     
     @functions_framework.cloud_event
     def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch Proofpoint TAP
       forensic evidence and write to GCS.
     
       The function first queries the SIEM API to discover threat IDs,
       then calls the Forensics API for each unique threat to retrieve
       detailed forensic evidence (sandbox results, behavioral
       indicators, network activity, file changes, and process data).
     
       Args:
         cloud_event: CloudEvent object containing Pub/Sub message
       """
     
       if not all([GCS_BUCKET, TAP_PRINCIPAL, TAP_SECRET]):
         print('Error: Missing required environment variables')
         return
     
       try:
         bucket = storage_client.bucket(GCS_BUCKET)
     
         # Load state
         state = load_state(bucket, STATE_KEY)
     
         # Determine time window
         now = datetime.now(timezone.utc)
         last_time = None
     
         if isinstance(state, dict) and state.get('last_event_time'):
           try:
             last_time = parse_datetime(state['last_event_time'])
             # Overlap by 2 minutes to catch delayed events
             last_time = last_time - timedelta(minutes=2)
           except Exception as e:
             print(f"Warning: Could not parse last_event_time: {e}")
     
         if last_time is None:
           last_time = now - timedelta(hours=LOOKBACK_HOURS)
     
         # TAP SIEM API allows max 1 hour per request and max 7 days lookback
         if (now - last_time) > timedelta(days=7):
           last_time = now - timedelta(days=7)
           print("Warning: Lookback capped to 7 days (TAP API limit)")
     
         print(f"Fetching threats from {last_time.isoformat()} to {now.isoformat()}")
     
         # Step 1: Fetch threat IDs from the SIEM API
         threat_ids = fetch_threat_ids(last_time, now)
     
         if not threat_ids:
           print("No threats found in the specified time window.")
           save_state(bucket, STATE_KEY, now.isoformat())
           return
     
         print(f"Found {len(threat_ids)} unique threat IDs")
     
         # Step 2: Fetch forensic evidence for each threat
         forensic_records = fetch_forensics_for_threats(threat_ids)
     
         if not forensic_records:
           print("No forensic evidence retrieved.")
           save_state(bucket, STATE_KEY, now.isoformat())
           return
     
         # Write to GCS as NDJSON
         timestamp = now.strftime('%Y%m%d_%H%M%S')
         object_key = f"{GCS_PREFIX}/tap_forensics_{timestamp}.ndjson"
         blob = bucket.blob(object_key)
     
         ndjson = '\n'.join(
           [json.dumps(record, ensure_ascii=False) for record in forensic_records]
         ) + '\n'
         blob.upload_from_string(ndjson, content_type='application/x-ndjson')
     
         print(f"Wrote {len(forensic_records)} records to gs://{GCS_BUCKET}/{object_key}")
     
         # Update state
         save_state(bucket, STATE_KEY, now.isoformat())
     
         print(f"Successfully processed forensics for {len(threat_ids)} threats")
     
       except Exception as e:
         print(f'Error processing TAP forensics: {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: {e}")
       return {}
     
     def save_state(bucket, key, last_event_time_iso):
       """Save the last event timestamp to GCS state file."""
       try:
         state = {'last_event_time': last_event_time_iso}
         blob = bucket.blob(key)
         blob.upload_from_string(
           json.dumps(state, indent=2),
           content_type='application/json'
         )
         print(f"Saved state: last_event_time={last_event_time_iso}")
       except Exception as e:
         print(f"Warning: Could not save state: {e}")
     
     def parse_datetime(value):
       """Parse ISO datetime string to datetime object."""
       if value.endswith('Z'):
         value = value[:-1] + '+00:00'
       return datetime.fromisoformat(value)
     
     def fetch_threat_ids(start_time, end_time):
       """
       Fetch unique threat IDs from the TAP SIEM API by querying
       in 1-hour intervals within the specified time window.
     
       Args:
         start_time: Start of the time window (datetime)
         end_time: End of the time window (datetime)
     
       Returns:
         Set of unique threat ID strings
       """
       headers = {
         'Authorization': get_auth_header(),
         'Accept': 'application/json',
         'User-Agent': 'GoogleSecOps-TAPForensicsCollector/1.0',
       }
     
       threat_ids = set()
       current_start = start_time
       backoff = 1.0
     
       while current_start < end_time:
         # TAP SIEM API allows max 1 hour per request
         current_end = min(current_start + timedelta(hours=1), end_time)
     
         interval = (
           f"{current_start.strftime('%Y-%m-%dT%H:%M:%SZ')}"
           f"/{current_end.strftime('%Y-%m-%dT%H:%M:%SZ')}"
         )
         url = f"{API_BASE}/v2/siem/all?format=json&interval={interval}"
     
         try:
           response = http.request('GET', url, headers=headers)
     
           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, 60.0)
             continue
     
           backoff = 1.0
     
           if response.status != 200:
             print(f"SIEM API HTTP Error: {response.status}")
             response_text = response.data.decode('utf-8')
             print(f"Response body: {response_text[:500]}")
             current_start = current_end
             continue
     
           data = json.loads(response.data.decode('utf-8'))
     
           # Extract threat IDs from all event types
           for key in ['messagesBlocked', 'messagesDelivered']:
             for msg in data.get(key, []):
               for threat_info in msg.get('threatsInfoMap', []):
                 tid = threat_info.get('threatID')
                 if tid:
                   threat_ids.add(tid)
     
           for key in ['clicksBlocked', 'clicksPermitted']:
             for click in data.get(key, []):
               tid = click.get('threatID')
               if tid:
                 threat_ids.add(tid)
     
           event_count = sum(
             len(data.get(k, []))
             for k in [
               'messagesBlocked',
               'messagesDelivered',
               'clicksBlocked',
               'clicksPermitted',
             ]
           )
           print(
             f"Interval {interval}: {event_count} events, "
             f"{len(threat_ids)} unique threats so far"
           )
     
         except Exception as e:
           print(f"Error fetching SIEM events: {e}")
     
         current_start = current_end
     
         if len(threat_ids) >= MAX_THREATS:
           print(f"Reached max threats limit ({MAX_THREATS})")
           break
     
       return threat_ids
     
     def fetch_forensics_for_threats(threat_ids):
       """
       Fetch forensic evidence for each threat ID from the
       Forensics API.
     
       Args:
         threat_ids: Set of threat ID strings
     
       Returns:
         List of forensic report dictionaries
       """
       headers = {
         'Authorization': get_auth_header(),
         'Accept': 'application/json',
         'User-Agent': 'GoogleSecOps-TAPForensicsCollector/1.0',
       }
     
       records = []
       backoff = 1.0
       processed = 0
       skipped = 0
     
       for threat_id in list(threat_ids)[:MAX_THREATS]:
         url = (
           f"{API_BASE}/v2/forensics"
           f"?threatId={threat_id}"
           f"&includeCampaignForensics=true"
         )
     
         try:
           response = http.request('GET', url, headers=headers)
     
           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, 60.0)
             # Retry the same threat
             continue
     
           backoff = 1.0
     
           if response.status == 204:
             skipped += 1
             processed += 1
             continue
     
           if response.status != 200:
             print(
               f"Forensics API error for {threat_id}: "
               f"HTTP {response.status}"
             )
             skipped += 1
             processed += 1
             continue
     
           data = json.loads(response.data.decode('utf-8'))
           reports = data.get('reports', [])
     
           if reports:
             # Add the threat ID to each report for correlation
             for report in reports:
               report['_threatId'] = threat_id
             records.extend(reports)
     
           processed += 1
     
           if processed % 50 == 0:
             print(
               f"Progress: {processed}/{len(threat_ids)} threats, "
               f"{len(records)} forensic reports collected"
             )
     
         except Exception as e:
           print(f"Error fetching forensics for {threat_id}: {e}")
           skipped += 1
           processed += 1
     
       print(
         f"Forensics collection complete: {processed} threats processed, "
         f"{skipped} skipped, {len(records)} reports collected"
       )
       return records
     

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

   Nota: Primero, la función consulta el endpoint /v2/siem/all de la API de TAP SIEM para descubrir los IDs de amenazas de eventos de seguridad de correo electrónico recientes y, luego, llama a la API de Forensics /v2/forensics para cada amenaza única con el objetivo de recuperar evidencia forense detallada, incluidos los resultados de la zona de pruebas, los indicadores de comportamiento, las consultas de DNS, las conexiones de red, las modificaciones de archivos y la actividad de los procesos. La API de SIEM admite un máximo de 1 hora por solicitud y 7 días de visualización. La función divide automáticamente los períodos más grandes en intervalos de 1 hora.

Crea un trabajo de Cloud Scheduler

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

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

3. Proporciona los siguientes detalles de configuración:

   Parámetro de configuración	Valor
   Nombre	tap-forensics-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 objetivo	Pub/Sub
   Tema	Selecciona el tema tap-forensics-collector-trigger.
   Cuerpo del mensaje	{} (objeto JSON vacío)

4. Haz clic en Crear.

Opciones de frecuencia de programación

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

Frecuencia	Expresión cron	Caso de uso
Cada 15 minutos	*/15 * * * *	Entornos de alto volumen con muchas amenazas
Cada 1 hora	0 * * * *	Estándar (recomendado)
Cada 6 horas	0 */6 * * *	Entornos de bajo volumen

Nota: La API de TAP SIEM tiene un límite de regulación de 1,800 solicitudes por cada 24 horas. Un programa por hora usa 24 solicitudes por día, lo que está dentro del límite. Si usas un programa de 15 minutos, asegúrate de que el total de llamadas a la API diarias se mantenga dentro del umbral de limitación.

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 la función tap-forensics-collector.
6. Haz clic en la pestaña Registros.

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

   Fetching threats from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   Interval .../...: X events, Y unique threats so far
   Found Z unique threat IDs
   Forensics collection complete: Z threats processed, 0 skipped, N reports collected
   Wrote N records to gs://proofpoint-tap-forensics-logs/tap-forensics/tap_forensics_YYYYMMDD_HHMMSS.ndjson
   Successfully processed forensics for Z threats
   

8. Ve a Cloud Storage > Buckets.

9. Haz clic en el nombre del bucket.

10. Navega a la carpeta de prefijo tap-forensics/.

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

Si ves errores en los registros, haz lo siguiente:

• HTTP 401: Verifica TAP_PRINCIPAL y TAP_SECRET en las variables de entorno. Verifica que el principal de servicio y el secreto sean correctos.
• HTTP 403: Confirma que tu cuenta de TAP tenga habilitado el acceso a la API.
• HTTP 429: Límite de frecuencia: la función volverá a intentarlo automáticamente con una retirada. Considera reducir la frecuencia de la programación.
• No se encontraron amenazas: Esto es normal si no se detectaron amenazas en el período. TAP solo informa las amenazas identificadas por URL Defense o Attachment Defense.
• Faltan variables de entorno: Verifica que todas las variables requeridas estén configuradas.

Configura un feed en Google SecOps para transferir registros de Proofpoint TAP Forensics

1. Ve a Configuración > Administración de datos > Feeds. Si estás en una plataforma solo de SIEM, ve a Configuración > 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, Proofpoint TAP Forensics).
5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
6. Selecciona Proofpoint Tap Forensics 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:

   [e-mail]
   

8. 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 otra documentación o ejemplos.

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 con la ruta de acceso del prefijo:

      gs://proofpoint-tap-forensics-logs/tap-forensics/
      

      • Reemplaza:
        • proofpoint-tap-forensics-logs: Es el nombre de tu bucket de GCS.
        • tap-forensics: Es el prefijo o la ruta de acceso de la carpeta opcional en la que se almacenan los registros (deja este campo vacío para la raíz).
    Nota: Incluye siempre la barra diagonal (/) al final del URI.

    • Opción de eliminación del código fuente: Selecciona la opción de eliminación 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 que se transfirieron correctamente.
      • Borrar los archivos transferidos y los directorios vacíos: Borra los archivos y los directorios vacíos después de que se transfirieron correctamente.
      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 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 última cantidad de días (el valor predeterminado es 180 días).

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

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

11. Haz clic en Siguiente.

12. Revisa la configuración de tu feed de noticias nuevo 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 Storage en tu bucket de GCS.

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

6. 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 de Visualizador de objetos de Storage.

Tabla de asignación de UDM

Campo de registro	Asignación de UDM	Lógica
malicious_label	additional.fields	Combinado
threat_type_label	additional.fields	Combinado
generated	metadata.event_timestamp	Analizado como ISO8601
has_principal	metadata.event_type	Asignado: true → STATUS_UPDATE
protocol	network.ip_protocol	Asignada directamente
prin_ip	principal.asset.ip	Combinado
domain	principal.domain.name	Asignada directamente
path	principal.file.full_path	Asignada directamente
file_hash_sha256	principal.file.sha256	Asignada directamente
prin_ip	principal.ip	Combinado
port	principal.port	Asignada directamente
url	principal.url	Asignada directamente
_security_result	security_result	Combinado
N/A	metadata.event_type	Constante: STATUS_UPDATE
N/A	metadata.product_event_type	Constante: Forensic Reports
N/A	metadata.product_name	Constante: TAP Forensics
N/A	metadata.vendor_name	Constante: Proofpoint
N/A	principal.asset.platform_software.platform	Constante: WINDOWS

Registro de cambios

Consulta el registro de cambios de este analizador

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