Recopila registros de Proofpoint Secure Email Relay

Se admite en los siguientes sistemas operativos:

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

Proofpoint Secure Email Relay (SER) es un servicio de retransmisión administrado para el correo electrónico generado por aplicaciones, como los mensajes transaccionales y de notificación. SER genera informes sobre ese tráfico a través de su API de Reporting, una de las APIs de configuración de SER. La API devuelve cifras de uso agregadas: la posición de la capacidad de procesamiento con licencia, el volumen y los recuentos de mensajes diarios, y los contadores para cada usuario de retransmisión. El analizador asigna esas cifras al modelo de datos unificado (UDM) y las registra como etiquetas junto con la identidad del usuario de retransmisión.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

  • Una instancia de Google SecOps
  • Un Google Cloud proyecto con la API de Cloud Storage habilitada
  • Permisos para crear y administrar buckets de Cloud Storage
  • Permisos para administrar políticas de Identity and Access Management (IAM) en buckets de Cloud Storage
  • Permisos para crear servicios de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
  • Acceso de administrador al portal de Proofpoint Secure Email Relay, incluido el permiso para crear claves de API

Cree un bucket de Cloud Storage

  1. Ve a la consola deGoogle 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 global único (por ejemplo, proofpoint-ser-logs).
    Tipo de ubicación Elige según tus necesidades (regional, 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.

Recopila credenciales de la API de SER de Proofpoint

El acceso a la API de informes se otorga con una clave de API emitida por el servicio de administración de claves de API de Proofpoint. La clave no se crea dentro de la consola de SER, por lo que no aparece en ninguna de las entradas de navegación de SER.

Crea una clave de API

  1. Accede al portal de retransmisión de correo electrónico seguro de Proofpoint con credenciales de administrador.
  2. Abre el Selector de apps en la esquina superior izquierda.
  3. Ve a Servicios > Administración de claves de API.
  4. Haga clic en Crear clave.
  5. Selecciona Secure Email Relay como el producto.

  6. Copia y almacena de forma segura los siguientes valores:

    • Clave: Se usa como client_id.
    • Secret: Se usa como client_secret.

Verifica los permisos

El servicio API Key Management se comparte entre varios productos de Proofpoint, por lo que se accede a él a través del Selector de apps en lugar del menú de navegación de SER. Para obtener acceso a las APIs de configuración de SER, incluida la API de Reporting, debes seleccionar Secure Email Relay como el producto cuando crees tu clave.

Si Administración de claves de API no aparece en el Selector de apps, significa que tu cuenta no tiene permiso de administración de APIs. Comunícate con tu administrador de Proofpoint o con el equipo de cuentas para que te otorguen el permiso.

Prueba el acceso a la API

  • La API de Informes usa el otorgamiento de credenciales de cliente de OAuth 2.0. Intercambia la clave y el secreto por un token de portador y, luego, llama a la API con ese token.

    # Replace with the values you copied
CLIENT_ID="<your-key>"
CLIENT_SECRET="<your-secret>"

# 1. Exchange the key and secret for an access token
ACCESS_TOKEN=$(curl -s -X POST "https://auth.proofpoint.com/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=${CLIENT_ID}" \
  -d "client_secret=${CLIENT_SECRET}" \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['access_token'])")

# 2. Call the Reporting API with the token
curl -v -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  "https://reporting.ser.proofpoint.com/v1/usage/overview"

Una llamada exitosa devuelve un objeto JSON cuyo miembro data contiene throughputLimit, licenseStartDate, licenseEndDate y los promedios de capacidad de procesamiento.

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 un bucket de Cloud Storage y para ser invocada por Pub/Sub.

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 proofpoint-ser-collector-sa.
    • Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect Proofpoint Secure Email Relay 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 registros en un bucket de Cloud Storage 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 Cloud Storage

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

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket (por ejemplo, proofpoint-ser-logs).
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar entidades: Ingresa el correo electrónico de la cuenta de servicio (por ejemplo, proofpoint-ser-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 proofpoint-ser-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 activará con mensajes de Pub/Sub de Cloud Scheduler para recuperar informes de uso de la API de SER Reporting y escribirlos en Cloud Storage.

  1. En Google Cloud 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:

    Parámetro de configuración Valor
    Nombre del servicio proofpoint-ser-collector
    Región Selecciona la región que coincida con tu bucket de Cloud Storage (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 (proofpoint-ser-trigger).
    4. Haz clic en Guardar.

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

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

  7. Ve a Contenedores, redes y seguridad y expándelo.

  8. Ve a la pestaña Seguridad:

    • Cuenta de servicio: Selecciona la cuenta de servicio (proofpoint-ser-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-ser-logs Nombre del bucket de Cloud Storage
    GCS_PREFIX ser-logs Prefijo para los archivos de registro
    STATE_KEY ser-logs-state.json Ruta de acceso al estado, fuera del prefijo del registro
    TOKEN_URL https://auth.proofpoint.com/v1/token Extremo de token de OAuth 2.0
    API_BASE https://reporting.ser.proofpoint.com URL base de la API de SER Reporting
    CLIENT_ID your-key La clave de la administración de claves de API
    CLIENT_SECRET your-secret El secreto de API Key Management
    PAGE_SIZE 50 Usuarios de retransmisión solicitados por página
    MAX_PAGES 200 Límite de páginas para la paginación de usuarios de retransmisión
    REPORT_DAY_OFFSET 1 Informe del día que se indica
    MAX_BACKFILL_DAYS 7 La mayoría de los días, una sola ejecución realizará el reabastecimiento.
    SEEN_RETENTION_DAYS 7 Días que se conservan las claves de anulación de duplicación en el estado

  10. En la sección Variables y Secrets, ve a Solicitudes:

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

Agrega el código de la 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
from google.cloud.exceptions import NotFound
import hashlib
import json
import os
import time
import urllib.parse
import urllib3
from datetime import date, datetime, timezone, timedelta

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=30.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', 'ser-logs')
# STATE_KEY must stay OUTSIDE GCS_PREFIX. The feed ingests every object under
# its bucket URI and, with a deletion option selected, deletes what it
# transferred. A state file inside the prefix would be ingested as log data and
# then deleted, resetting collection and re-ingesting duplicates.
STATE_KEY = os.environ.get('STATE_KEY', 'ser-logs-state.json')
TOKEN_URL = os.environ.get('TOKEN_URL', 'https://auth.proofpoint.com/v1/token')
API_BASE = os.environ.get('API_BASE', 'https://reporting.ser.proofpoint.com')
CLIENT_ID = os.environ.get('CLIENT_ID')
CLIENT_SECRET = os.environ.get('CLIENT_SECRET')
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '50'))
MAX_PAGES = int(os.environ.get('MAX_PAGES', '200'))
# The Reporting API filters on whole calendar days, so the collector reports on
# a day that has already finished rather than on a partial one.
REPORT_DAY_OFFSET = int(os.environ.get('REPORT_DAY_OFFSET', '1'))
MAX_BACKFILL_DAYS = int(os.environ.get('MAX_BACKFILL_DAYS', '7'))
SEEN_RETENTION_DAYS = int(os.environ.get('SEEN_RETENTION_DAYS', '7'))

MAX_RATE_LIMIT_RETRIES = 5

class FetchError(Exception):
    """Raised when a Proofpoint SER API call fails.

    Collection must fail loudly. Returning an empty result on an API error is
    indistinguishable from a day with no traffic, and would let the run record
    a day it never actually read.
    """

def get_access_token():
    """Exchange the API key and secret for an OAuth 2.0 bearer token.

    The SER configuration APIs use the client credentials grant with the
    credentials in the form body. The returned token is sent to each API
    host as an Authorization: Bearer header.
    """
    body = urllib.parse.urlencode({
        'grant_type': 'client_credentials',
        'client_id': CLIENT_ID,
        'client_secret': CLIENT_SECRET,
    })
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Accept': 'application/json',
    }

    try:
        response = http.request('POST', TOKEN_URL, body=body, headers=headers)
    except Exception as e:
        raise FetchError(f'Token request to {TOKEN_URL} failed: {e}') from e

    if response.status != 200:
        raise FetchError(f'HTTP {response.status} from {TOKEN_URL}: {response.data.decode("utf-8")}')

    try:
        token = json.loads(response.data.decode('utf-8')).get('access_token')
    except json.JSONDecodeError as e:
        raise FetchError(f'Malformed token response from {TOKEN_URL}: {e}') from e

    if not token:
        raise FetchError('Token response did not contain an access_token')

    return token

def call_api(token, method, path, body=None):
    """Call one Reporting API endpoint and return the decoded JSON body.

    Every failure raises. A caller that mistook an error for an empty report
    would record the day as collected and never come back to it.
    """
    url = f'{API_BASE}{path}'
    headers = {
        'Authorization': f'Bearer {token}',
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'User-Agent': 'GoogleSecOps-ProofpointSERCollector/1.0',
    }
    payload = json.dumps(body) if body is not None else None
    backoff = 1.0
    retries = 0

    while True:
        try:
            response = http.request(method, url, body=payload, headers=headers)
        except Exception as e:
            raise FetchError(f'Request to {url} failed: {e}') from e

        if response.status == 429:
            retries += 1
            if retries > MAX_RATE_LIMIT_RETRIES:
                raise FetchError(f'Rate limited repeatedly by {url}; giving up without recording the day')
            raw_retry_after = response.headers.get('Retry-After')
            try:
                # Retry-After may also be an HTTP date, which int() cannot parse.
                delay = int(raw_retry_after) if raw_retry_after else int(backoff)
            except (TypeError, ValueError):
                delay = int(backoff)
            print(f'Rate limited (429) on {path}. Retrying after {delay}s...')
            time.sleep(delay)
            backoff = min(backoff * 2, 30.0)
            continue

        if response.status != 200:
            raise FetchError(f'HTTP {response.status} from {url}: {response.data.decode("utf-8")}')

        try:
            return json.loads(response.data.decode('utf-8'))
        except json.JSONDecodeError as e:
            raise FetchError(f'Malformed JSON response from {url}: {e}') from e

def as_list(value):
    """Return a response data member as a list.

    The Reporting API returns data as an object on some endpoints and as an
    array on others, and the published schema declares neither.
    """
    if value is None:
        return []
    if isinstance(value, list):
        return value
    return [value]

def collect_day(token, day, include_overview):
    """Collect one reporting day and return the records to write.

    The nesting of each record is chosen to match what the parser expects.
    Rows carrying acceptedMessages are emitted bare, because the parser nests
    those under data itself. The other two responses are emitted whole, so
    that their data and metadata envelope survives to the parser.
    """
    records = []

    # Licensed throughput position. This endpoint takes no date and reports
    # the tenant's standing right now, so it is collected once per run rather
    # than once per day: a backfill would otherwise write the same snapshot
    # against every day it catches up on.
    if include_overview:
        records.append(call_api(token, 'GET', '/v1/usage/overview'))

    # Volume in bytes for the day. One envelope per row, so that the
    # totalThroughput in metadata stays attached to the row it describes.
    data_trend = call_api(token, 'POST', '/v1/usage/data-trend', {
        'dates': day,
        'interval': 'day',
    })
    for element in as_list(data_trend.get('data')):
        records.append({'data': [element], 'metadata': data_trend.get('metadata', {})})

    # Message counters for the day.
    message_trend = call_api(token, 'POST', '/v1/usage/message-trend', {
        'dates': day,
        'interval': 'day',
    })
    records.extend(as_list(message_trend.get('data')))

    # Per relay user counters, paginated.
    page = 1
    while True:
        if page > MAX_PAGES:
            raise FetchError(f'Relay user pagination for {day} exceeded MAX_PAGES ({MAX_PAGES})')

        payload = call_api(token, 'POST', '/v1/usage/relay-users', {
            'dates': day,
            'pageNum': page,
            'pageSize': PAGE_SIZE,
        })
        elements = as_list(payload.get('data'))
        if not elements:
            break

        records.extend(elements)

        pagination = (payload.get('metadata') or {}).get('pagination') or {}
        total_pages = pagination.get('totalPages')
        if not total_pages or page >= total_pages:
            break
        page += 1

    return records

def record_key(record):
    """Return the deduplication identity of one record.

    Reporting rows are aggregates and carry no identifier of their own, so
    identity is the content hash. Keys are held per reporting day, which makes
    a repeated run of the same day a no-op without ever suppressing a new day
    whose figures happen to be identical.
    """
    return 'sha256:' + hashlib.sha256(
        json.dumps(record, sort_keys=True, ensure_ascii=False).encode('utf-8')
    ).hexdigest()

def pending_days(last_report_date, target):
    """Return the reporting days still to collect, oldest first."""
    if not last_report_date:
        start = target
    else:
        start = date.fromisoformat(last_report_date) + timedelta(days=1)

    if start > target:
        return []

    if (target - start).days >= MAX_BACKFILL_DAYS:
        start = target - timedelta(days=MAX_BACKFILL_DAYS - 1)
        print(f'Backfill capped at {MAX_BACKFILL_DAYS} days. Days before {start.isoformat()} are not collected.')

    return [start + timedelta(days=offset) for offset in range((target - start).days + 1)]

def prune_seen(seen, target):
    """Drop deduplication keys for days outside the retention window."""
    cutoff = target - timedelta(days=SEEN_RETENTION_DAYS)
    return {day: keys for day, keys in seen.items() if date.fromisoformat(day) >= cutoff}

@functions_framework.cloud_event
def main(cloud_event):
    """Fetch Proofpoint SER usage reports and write them to Cloud Storage.

    Args:
        cloud_event: CloudEvent object containing the Pub/Sub message.
    """
    if not all([GCS_BUCKET, CLIENT_ID, CLIENT_SECRET]):
        # Raise rather than return: a bare return acks the Pub/Sub message and
        # reports the run as successful, silently discarding the schedule tick.
        raise RuntimeError('Missing required environment variables')

    bucket = storage_client.bucket(GCS_BUCKET)
    state = load_state(bucket, STATE_KEY)
    seen = state.get('seen') or {}

    now = datetime.now(timezone.utc)
    target = (now - timedelta(days=REPORT_DAY_OFFSET)).date()

    days = pending_days(state.get('last_report_date'), target)
    if not days:
        print(f'Nothing to collect. {target.isoformat()} is already recorded.')
        return

    token = get_access_token()

    for day in days:
        key = day.isoformat()
        print(f'Collecting reporting day {key}')

        # A FetchError here propagates: the run fails, the state is left at the
        # last day that was fully written, and the next run retries this day.
        records = collect_day(token, key, include_overview=(day == days[-1]))

        day_seen = set(seen.get(key, []))
        fresh = []
        for record in records:
            digest = record_key(record)
            if digest in day_seen:
                continue
            day_seen.add(digest)
            fresh.append(record)

        print(f'{key}: fetched {len(records)} records, {len(fresh)} new after deduplication')

        if fresh:
            timestamp = now.strftime('%Y%m%dT%H%M%SZ')
            object_key = f'{GCS_PREFIX}/usage_{key}_{timestamp}.ndjson'
            blob = bucket.blob(object_key)

            ndjson = '\n'.join(json.dumps(record, ensure_ascii=False) for record in fresh) + '\n'
            blob.upload_from_string(ndjson, content_type='application/x-ndjson')

            print(f'Wrote {len(fresh)} records to gs://{GCS_BUCKET}/{object_key}')

        # Record the day only after its data is durably written.
        seen[key] = sorted(day_seen)
        state['last_report_date'] = key
        state['seen'] = prune_seen(seen, target)
        save_state(bucket, STATE_KEY, state)

    print(f'Successfully processed {len(days)} reporting day(s)')

def load_state(bucket, key):
    """Read the collector state from Cloud Storage.

    Only a missing object is treated as a cold start. Any other error is
    raised: swallowing it would silently restart collection and re-ingest the
    whole backfill window.
    """
    blob = bucket.blob(key)
    try:
        return json.loads(blob.download_as_text())
    except NotFound:
        print('No state file found. Starting from the most recent completed day.')
        return {}

def save_state(bucket, key, state):
    """Write the collector state to Cloud Storage.

    Failures are raised, not logged. If the state write fails after the data
    was uploaded, the next run repeats the same day and duplicates it.
    """
    blob = bucket.blob(key)
    blob.upload_from_string(
        json.dumps(state, indent=2),
        content_type='application/json',
    )
    print(f'Saved state: last_report_date={state.get("last_report_date")}')

  • Segundo archivo: requirements.txt:

    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0
  1. Haz clic en Implementar para guardar y, luego, implementar la función.

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

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 proofpoint-ser-collector-daily
    Región Selecciona la misma región que la función de Cloud Run
    Frecuencia 0 2 * * * (diariamente, a las 2:00 a.m.)
    Zona horaria Selecciona la zona horaria (se recomienda UTC)
    Tipo de objetivo Pub/Sub
    Tema Selecciona el tema de Pub/Sub (proofpoint-ser-trigger).
    Cuerpo del mensaje {} (objeto JSON vacío)

  4. Haz clic en Crear.

Opciones de frecuencia de programación

La API de Reporting realiza agregaciones por día calendario, por lo que un día completado se recopila una vez. Ejecuta el trabajo diariamente, después de que finalice el día del informe en la zona horaria de tu arrendatario:

Frecuencia Expresión cron Caso de uso
Todos los días a las 02:00 0 2 * * * Estándar (recomendado)
Todos los días a las 6:00 a.m. 0 6 * * * Usuarios cuyo informe se establece más tarde
Dos veces al día 0 2,14 * * * Se agrega un reintento el mismo día si falló la primera ejecución.

Una ejecución que encuentra que su día ya está registrado sale sin escribir nada, por lo que una ejecución adicional cuesta una llamada a la API y nunca duplica los datos.

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 (proofpoint-ser-collector).
  6. Haz clic en la pestaña Registros.

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

    Collecting reporting day YYYY-MM-DD
YYYY-MM-DD: fetched X records, X new after deduplication
Wrote X records to gs://proofpoint-ser-logs/ser-logs/usage_YYYY-MM-DD_YYYYMMDDTHHMMSSZ.ndjson
Saved state: last_report_date=YYYY-MM-DD
Successfully processed 1 reporting day(s)

  8. Ve a Cloud Storage > Buckets.

  9. Haz clic en el nombre de tu bucket (proofpoint-ser-logs).

  10. Navega a la carpeta del prefijo (ser-logs/).

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

Si ves errores en los registros, haz lo siguiente:

  • HTTP 400 del extremo del token: La clave o el secreto son incorrectos, o la clave venció. invalid_client significa que se rechazó el par, por lo que debes crear una clave de reemplazo.
  • HTTP 401 de la API de Reporting: No se envió el token de portador o ya no es válido.
  • HTTP 429: Se alcanzó el límite de frecuencia. La función reintenta con una retirada y falla la ejecución si el límite persiste, lo que deja el día para la siguiente ejecución.
  • Faltan variables de entorno: Verifica que estén configuradas todas las variables requeridas.

Recupera la cuenta de servicio de Google SecOps

Google SecOps usa una cuenta de servicio única para leer datos de tu bucket de Cloud Storage. 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 Add New Feed.
  3. Haz clic en Configura un feed único.
  4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Proofpoint SER Logs).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona ProofPoint Secure Email Relay como el Tipo de registro.
  7. Haz clic en Obtener cuenta de servicio.

  8. Se mostrará un correo electrónico único de la cuenta de servicio, por ejemplo:

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

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

  10. Haz clic en Siguiente.

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

    • URL del bucket de almacenamiento: Ingresa el URI del bucket de Cloud Storage con la ruta de acceso del prefijo:

      gs://proofpoint-ser-logs/ser-logs/
      • Reemplaza:
        • proofpoint-ser-logs: Es el nombre de tu bucket de Cloud Storage.
        • ser-logs: Es el prefijo o la ruta de acceso a la carpeta opcionales en los que se almacenan los registros (déjalo vacío para la raíz).

    • Opción de eliminación del código fuente: Selecciona la opción de eliminación según tu preferencia:

      • No borrar archivos nunca: Nunca borra archivos de la fuente (se recomienda para las pruebas).
      • Borrar los archivos transferidos y los directorios vacíos: Borra los archivos y los directorios vacíos de la fuente después de que se complete una recuperación exitosa.

    • Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días especificada (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.

  12. Haz clic en Siguiente.

  13. 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 dos roles en tu bucket de Cloud Storage: Visualizador de objetos de Storage para leer los objetos de registro y un rol a nivel del bucket para leer los metadatos del bucket.

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket (por ejemplo, proofpoint-ser-logs).
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar entidades: Pega el correo electrónico de la cuenta de servicio de Google SecOps.
    • Asignar roles: Selecciona los siguientes roles:
      • Visualizador de objetos de Storage: Lee los objetos de registro.
      • Storage Legacy Bucket Reader: Lee los metadatos del bucket. Si seleccionaste la opción de borrado Borrar los archivos transferidos y los directorios vacíos, selecciona Storage Legacy Bucket Writer, que también otorga el permiso de borrado.

  6. Haz clic en Guardar.

Tabla de asignación de UDM

Campo de registro Asignación de UDM Lógica
acceptedMessages_label additional.fields Combinado
acceptedThroughput_label additional.fields Combinado
average30DayThroughput_label additional.fields Combinado
average7DayThroughput_label additional.fields Combinado
averageDailyThroughput_label additional.fields Combinado
avgAcceptedMessageSize_label additional.fields Combinado
blockedMessages_label additional.fields Combinado
data_totalThroughput_label additional.fields Combinado
deliveredMessages_label additional.fields Combinado
licenseEndDate_label additional.fields Combinado
licenseStartDate_label additional.fields Combinado
map_label additional.fields Combinado
metadata_totalThroughput_label additional.fields Combinado
quarantinedMessages_label additional.fields Combinado
rejectedMessages_label additional.fields Combinado
remainingThroughput_label additional.fields Combinado
requestedMessages_label additional.fields Combinado
requestedThroughput_label additional.fields Combinado
sentMessages_label additional.fields Combinado
throughputForecast_label additional.fields Combinado
throughputLimit_label additional.fields Combinado
throughput_label additional.fields Combinado
totalMessages_label additional.fields Combinado
undeliveredMessages_label additional.fields Combinado
data.name metadata.description Asignada directamente
desc metadata.description Asignada directamente
data.date metadata.event_timestamp Se analizó como yyyy-MM-dd
event_type metadata.event_type Asignada directamente
fromEnvelope network.email.bounce_address Asignada directamente
fromHeader network.email.from Asignada directamente
applicationName principal.administrative_domain Asignada directamente
principal_host principal.asset.hostname Asignada directamente
principal_host principal.hostname Asignada directamente
principal_port principal.port Asignada directamente
data.relayUserId principal.user.product_object_id Asignada directamente
userId principal.user.product_object_id Asignada directamente
applicationUserName principal.user.user_display_name Asignada directamente
senderName target.administrative_domain Asignada directamente
senderId target.user.product_object_id Asignada directamente
N/A metadata.product_name Constante: PROOFPOINT SER
N/A metadata.vendor_name Constante: PROOFPOINT

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.