Recoger registros de auditoría de Tines

Disponible en:

SecOps de Google SIEM

Nota: Esta función está cubierta por los Términos de las Ofertas Previas a la Disponibilidad General de los Términos Específicos del Servicio de Google Security Operations. Las funciones previas a la disponibilidad general pueden tener una asistencia limitada y los cambios que se produzcan en ellas podrían no ser compatibles con otras versiones previas a la disponibilidad general. Para obtener más información, consulta las directrices del servicio de asistencia técnica de Google SecOps y los Términos Específicos de los Servicios de Google SecOps.

En este documento se explica cómo ingerir registros de auditoría de Tines en Google Security Operations mediante Amazon S3.

Antes de empezar

Asegúrate de que cumples los siguientes requisitos previos:

• Una instancia de Google SecOps.
• Acceso privilegiado a Tines.
• Acceso privilegiado a AWS (S3, Gestión de Identidades y Accesos [IAM], Lambda y EventBridge).

Obtener la URL de Tines

1. En tu navegador, abre la interfaz de usuario de Tines de tu arrendatario.
2. Copia el dominio de la barra de direcciones. Lo usarás como TINES_BASE_URL.
   • Formato: https://<tenant-domain> (por ejemplo, https://<tenant-domain>.tines.com).

Crea una clave de API de servicio de Tines (opción recomendada) o una clave de API personal

Valores que debes guardar para los pasos posteriores:

• TINES_BASE_URL: por ejemplo, https://<domain>.tines.com
• TINES_API_KEY: el token que crees en los pasos siguientes

Opción 1: Clave de API de servicio (recomendada)

1. Ve al menú de navegación > Claves de API.
2. Haz clic en + Nueva clave.
3. Selecciona Clave de API de servicio.
4. Introduzca un nombre descriptivo (por ejemplo, SecOps Audit Logs).
5. Haz clic en Crear.
6. Copia el token generado inmediatamente y guárdalo de forma segura. Lo usarás como TINES_API_KEY.

Opción 2: Clave de API personal (si no hay claves de servicio disponibles)

1. Ve al menú de navegación > Claves de API.
2. Haz clic en + Nueva clave.
3. Selecciona Clave de API personal.
4. Introduzca un nombre descriptivo.
5. Haz clic en Crear.

6. Copia el token generado y guárdalo de forma segura.

   Nota: Es preferible usar claves de API de servicio porque están vinculadas a cuentas de servicio con permisos específicos, en lugar de heredar todos los permisos de una cuenta de usuario.

Conceder el permiso de lectura de registros de auditoría

1. Inicia sesión como propietario del arrendatario (o pídele a uno que lo haga).
2. Ve a Configuración > Administrar > Administración de usuarios. (También puedes hacer clic en el nombre de tu equipo en el menú de la parte superior izquierda y seleccionar Usuarios).
3. Busca el usuario de la cuenta de servicio asociado a tu clave de API de Service (tendrá el mismo nombre que tu clave de API).
   • Si usas una clave de API personal, busca tu propia cuenta de usuario.
4. Haz clic en el usuario para abrir su perfil.
5. En la sección Tenant permissions (Permisos de arrendatario), habilita AUDIT_LOG_READ.
6. Haz clic en Guardar.

(Opcional) Verificar el acceso a la API

1. Prueba el endpoint con curl o cualquier cliente HTTP:

   curl -X GET "https://<tenant-domain>/api/v1/audit_logs?per_page=1" \
       -H "Authorization: Bearer <TINES_API_KEY>" \
       -H "Content-Type: application/json"
   

2. Deberías recibir una respuesta JSON con las entradas del registro de auditoría.

3. También puedes comprobar si existen registros de auditoría en la interfaz de usuario. Para ello, ve a Configuración > Monitorización > Registros de auditoría (se necesita el permiso AUDIT_LOG_READ).

Configurar un segmento de AWS S3

1. Crea un segmento de Amazon S3 siguiendo esta guía de usuario: Crear un segmento.
2. Guarda el nombre y la región del segmento para consultarlos más adelante (por ejemplo, tines-audit-logs).

Configurar la política y el rol de gestión de identidades y accesos para las subidas de Lambda a S3

1. En la consola de AWS, vaya a IAM > Policies > Create policy > JSON tab (IAM > Políticas > Crear política > pestaña JSON).
2. Copia y pega la siguiente política.

3. JSON de la política (sustituye tines-audit-logs si has introducido otro nombre de contenedor):

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::tines-audit-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::tines-audit-logs/tines/audit/state.json"
       }
     ]
   }
   

4. Haz clic en Siguiente > Crear política.

5. Asigna un nombre a la política TinesLambdaS3Policy.

6. Ve a IAM > Roles > Crear rol > Servicio de AWS > Lambda.

7. Adjunta el TinesLambdaS3Policy que acabas de crear.

8. Dale el nombre TinesAuditToS3Role al rol y haz clic en Crear rol.

Crear la función Lambda

1. En la consola de AWS, ve a Lambda > Funciones > Crear función.
2. Haz clic en Crear desde cero.

3. Proporciona los siguientes detalles de configuración:

   Ajuste	Valor
   Nombre	tines_audit_to_s3
   Tiempo de ejecución	Python 3.13
   Arquitectura	x86_64
   Rol de ejecución	TinesAuditToS3Role

4. Una vez creada la función, abra la pestaña Código, elimine el stub y pegue el siguiente código (tines_audit_to_s3.py).

   #!/usr/bin/env python3
   # Lambda: Pull Tines Audit Logs to S3 (no transform)
   
   import os, json, time, urllib.parse
   from urllib.request import Request, urlopen
   from urllib.error import HTTPError, URLError
   import boto3
   
   S3_BUCKET      = os.environ["S3_BUCKET"]
   S3_PREFIX      = os.environ.get("S3_PREFIX", "tines/audit/")
   STATE_KEY      = os.environ.get("STATE_KEY", "tines/audit/state.json")
   LOOKBACK_SEC   = int(os.environ.get("LOOKBACK_SECONDS", "3600"))  # default 1h
   PAGE_SIZE      = int(os.environ.get("PAGE_SIZE", "500"))  # Max is 500 for Tines
   MAX_PAGES      = int(os.environ.get("MAX_PAGES", "20"))
   TIMEOUT        = int(os.environ.get("HTTP_TIMEOUT", "60"))
   HTTP_RETRIES   = int(os.environ.get("HTTP_RETRIES", "3"))
   TINES_BASE_URL = os.environ["TINES_BASE_URL"]
   TINES_API_KEY  = os.environ["TINES_API_KEY"]
   
   s3 = boto3.client("s3")
   
   def _iso(ts: float) -> str:
       return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))
   
   def _load_state() -> dict:
       try:
           obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
           b = obj["Body"].read()
           return json.loads(b) if b else {}
       except Exception:
           return {}
   
   def _save_state(st: dict) -> None:
       s3.put_object(
           Bucket=S3_BUCKET, Key=STATE_KEY,
           Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
   
   def _req(url: str) -> dict:
       attempt = 0
       while True:
           try:
               req = Request(url, method="GET")
               req.add_header("Authorization", f"Bearer {TINES_API_KEY}")
               req.add_header("Accept", "application/json")
               req.add_header("Content-Type", "application/json")
               with urlopen(req, timeout=TIMEOUT) as r:
                   data = r.read()
               return json.loads(data.decode("utf-8"))
           except HTTPError as e:
               if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                   retry_after = 1 + attempt
                   try:
                       retry_after = int(e.headers.get("Retry-After", retry_after))
                   except Exception:
                       pass
                   time.sleep(max(1, retry_after))
                   attempt += 1
                   continue
               raise
           except URLError:
               if attempt < HTTP_RETRIES:
                   time.sleep(1 + attempt)
                   attempt += 1
                   continue
               raise
   
   def _write(payload, page: int) -> str:
       ts = time.gmtime()
       key = f"{S3_PREFIX}{time.strftime('%Y/%m/%d/%H%M%S', ts)}-tines-audit-{page:05d}.json"
       s3.put_object(
           Bucket=S3_BUCKET, Key=key,
           Body=json.dumps(payload, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
       return key
   
   def _extract_items(payload) -> list:
       if isinstance(payload, list):
           return payload
       if isinstance(payload, dict):
           audit_logs = payload.get("audit_logs")
           if isinstance(audit_logs, list):
               return audit_logs
       return []
   
   def _extract_newest_ts(items: list, current: str | None) -> str | None:
       newest = current
       for it in items:
           # Use created_at as the timestamp field
           t = it.get("created_at")
           if isinstance(t, str) and (newest is None or t > newest):
               newest = t
       return newest
   
   def lambda_handler(event=None, context=None):
       st = _load_state()
       since = st.get("since") or _iso(time.time() - LOOKBACK_SEC)
   
       page = 1
       pages = 0
       total = 0
       newest_ts = since
   
       while pages < MAX_PAGES:
           # Build URL with query parameters
           # Note: Tines audit logs API uses 'after' parameter for filtering
           base_url = f"{TINES_BASE_URL.rstrip('/')}/api/v1/audit_logs"
           params = {
               "after": since,  # Filter for logs created after this timestamp
               "page": page,
               "per_page": PAGE_SIZE
           }
           url = f"{base_url}?{urllib.parse.urlencode(params)}"
   
           payload = _req(url)
           _write(payload, page)
           items = _extract_items(payload)
           total += len(items)
           newest_ts = _extract_newest_ts(items, newest_ts)
           pages += 1
   
           # Check if there's a next page using meta.next_page_number
           meta = payload.get("meta") or {}
           next_page = meta.get("next_page_number")
   
           if not next_page:
               break
           page = next_page
   
       if newest_ts and newest_ts != since:
           st["since"] = newest_ts
           _save_state(st)
   
       return {"ok": True, "pages": pages, "items": total, "since": st.get("since")}
   
   if __name__ == "__main__":
       print(lambda_handler())
   

5. Vaya a Configuración > Variables de entorno.

6. Haz clic en Editar > Añadir nueva variable de entorno.

7. Introduce las variables de entorno que se indican en la siguiente tabla y sustituye los valores de ejemplo por los tuyos.

   Variables de entorno

   Clave	Valor de ejemplo
   S3_BUCKET	tines-audit-logs
   S3_PREFIX	tines/audit/
   STATE_KEY	tines/audit/state.json
   TINES_BASE_URL	https://your-tenant.tines.com
   TINES_API_KEY	your-tines-api-key
   LOOKBACK_SECONDS	3600
   PAGE_SIZE	500
   MAX_PAGES	20
   HTTP_TIMEOUT	60
   HTTP_RETRIES	3

8. Una vez creada la función, permanece en su página (o abre Lambda > Funciones > tu-función).

9. Seleccione la pestaña Configuración.

10. En el panel Configuración general, haz clic en Editar.

11. Cambia Tiempo de espera a 5 minutos (300 segundos) y haz clic en Guardar.

    Nota: El tiempo de espera es un límite superior estricto, lo que significa que, si la función sigue ejecutándose cuando el temporizador llegue a los 5 minutos, AWS Lambda la finalizará. Si la ejecución es más corta, se completará con normalidad y solo se te cobrará por el tiempo de ejecución real.

Crear una programación de EventBridge

1. Ve a Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Programador > Crear programación).
2. Proporcione los siguientes detalles de configuración:
   • Programación periódica: Precio (1 hour).
   • Destino: tu función Lambda tines_audit_to_s3.
   • Nombre: tines-audit-1h.
3. Haz clic en Crear programación.

Crear un usuario y claves de IAM de solo lectura para Google SecOps

1. En la consola de AWS, ve a IAM > Usuarios.
2. Haz clic en Add users (Añadir usuarios).
3. Proporcione los siguientes detalles de configuración:
   • Usuario: introduce secops-reader.
   • Tipo de acceso: selecciona Clave de acceso > Acceso programático.
4. Haz clic en Crear usuario.
5. Asigna una política de lectura mínima (personalizada): Usuarios > secops-reader > Permisos > Añadir permisos > Asignar políticas directamente > Crear política.

6. JSON:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["s3:GetObject"],
         "Resource": "arn:aws:s3:::tines-audit-logs/*"
       },
       {
         "Effect": "Allow",
         "Action": ["s3:ListBucket"],
         "Resource": "arn:aws:s3:::tines-audit-logs"
       }
     ]
   }
   

7. Nombre = secops-reader-policy.

8. Haz clic en Crear política > busca o selecciona > Siguiente > Añadir permisos.

9. Crea una clave de acceso para secops-reader: Credenciales de seguridad > Claves de acceso.

10. Haz clic en Crear clave de acceso.

11. Descarga la .CSV. (Estos valores se pegarán en el feed).

Configurar un feed en Google SecOps para ingerir registros de auditoría de Tines

1. Ve a Configuración de SIEM > Feeds.
2. Haz clic en + Añadir nuevo feed.
3. En el campo Nombre del feed, introduce un nombre para el feed (por ejemplo, Tines Audit Logs).
4. Selecciona Amazon S3 V2 como Tipo de fuente.
5. Selecciona Tines como Tipo de registro.
6. Haz clic en Siguiente.
7. Especifique los valores de los siguientes parámetros de entrada:
   • URI de S3: s3://tines-audit-logs/tines/audit/
   • Opciones de eliminación de la fuente: selecciona la opción de eliminación que prefieras.
   • Antigüedad máxima del archivo: incluye los archivos modificados en los últimos días. El valor predeterminado es 180 días.
   • ID de clave de acceso: clave de acceso de usuario con acceso al bucket de S3.
   • Clave de acceso secreta: clave secreta del usuario con acceso al bucket de S3.
   • Espacio de nombres de recursos: el espacio de nombres de recursos.
   • Etiquetas de ingestión: la etiqueta aplicada a los eventos de este feed.
8. Haz clic en Siguiente.
9. Revise la configuración de la nueva fuente en la pantalla Finalizar y, a continuación, haga clic en Enviar.

¿Necesitas más ayuda? Recibe respuestas de los miembros de la comunidad y de los profesionales de Google SecOps.