Recopila registros de IAM de SailPoint

Se admite en los siguientes sistemas operativos:

Google SecOps SIEM

Nota: Esta función está sujeta a las Condiciones de las Ofertas de Fase Previa a la DG de las Condiciones Específicas del Servicio de Operaciones de Seguridad de Google. Las características de la fase previa a la DG pueden tener asistencia limitada, y es posible que los cambios en las características de la fase previa a la DG no sean compatibles con otras versiones de la fase previa a la DG. Para obtener más información, consulta los Lineamientos de los Servicios de Asistencia Técnica de Google SecOps y las Condiciones Específicas del Servicio de Google SecOps.

En este documento, se explica cómo transferir registros de IAM de SailPoint a Google Security Operations con Amazon S3.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

• Una instancia de Google SecOps
• Acceso privilegiado al arrendatario o la API de SailPoint Identity Security Cloud
• Acceso con privilegios a AWS (S3, IAM, Lambda, EventBridge)

Recopila los requisitos previos de IAM de SailPoint (IDs, claves de API, IDs de organización, tokens).

1. Accede a la consola de administración de SailPoint Identity Security Cloud como administrador.
2. Ve a Global > Configuración de seguridad > Administración de APIs.
3. Haz clic en Crear cliente de API.
4. Elige Client Credentials como el tipo de otorgamiento.
5. Proporciona los siguientes detalles de configuración:
   • Nombre: Ingresa un nombre descriptivo (por ejemplo, Chronicle Export API).
   • Descripción: Ingresa una descripción para el cliente de API.
   • Permisos: Selecciona sp:scopes:all (o los permisos de lectura adecuados para los eventos de auditoría).
6. Haz clic en Crear y copia las credenciales de la API generadas de forma segura.
7. Registra la URL base del arrendatario de SailPoint (por ejemplo, https://tenant.api.identitynow.com).
8. Copia y guarda en una ubicación segura los siguientes detalles:
   • IDN_CLIENT_ID
   • IDN_CLIENT_SECRET
   • IDN_BASE

Configura el bucket de AWS S3 y el IAM para Google SecOps

1. Crea un bucket de Amazon S3 siguiendo esta guía del usuario: Crea un bucket
2. Guarda el Nombre y la Región del bucket para futuras referencias (por ejemplo, sailpoint-iam-logs).
3. Crea un usuario siguiendo esta guía del usuario: Cómo crear un usuario de IAM.
4. Selecciona el usuario creado.
5. Selecciona la pestaña Credenciales de seguridad.
6. Haz clic en Crear clave de acceso en la sección Claves de acceso.
7. Selecciona Servicio de terceros como el Caso de uso.
8. Haz clic en Siguiente.
9. Opcional: Agrega una etiqueta de descripción.
10. Haz clic en Crear clave de acceso.
11. Haz clic en Descargar archivo CSV para guardar la clave de acceso y la clave de acceso secreta para usarlas más adelante.
12. Haz clic en Listo.
13. Selecciona la pestaña Permisos.
14. Haz clic en Agregar permisos en la sección Políticas de permisos.
15. Selecciona Agregar permisos.
16. Selecciona Adjuntar políticas directamente.
17. Busca y selecciona la política AmazonS3FullAccess.
18. Haz clic en Siguiente.
19. Haz clic en Agregar permisos.

Configura la política y el rol de IAM para las cargas de S3

1. En la consola de AWS, ve a IAM > Policies > Create policy > pestaña JSON.

2. Copia y pega la siguiente política:

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

   • Reemplaza sailpoint-iam-logs si ingresaste un nombre de bucket diferente:

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

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

5. Adjunta la política recién creada.

6. Nombra el rol SailPointIamToS3Role y haz clic en Crear rol.

Crea la función Lambda

1. En la consola de AWS, ve a Lambda > Functions > Create function.
2. Haz clic en Crear desde cero.

3. Proporciona los siguientes detalles de configuración:

   Configuración	Valor
   Nombre	sailpoint_iam_to_s3
   Tiempo de ejecución	Python 3.13
   Arquitectura	x86_64
   Rol de ejecución	SailPointIamToS3Role

4. Después de crear la función, abre la pestaña Code, borra el código auxiliar y, luego, ingresa el siguiente código (sailpoint_iam_to_s3.py):

   #!/usr/bin/env python3
   # Lambda: Pull SailPoint Identity Security Cloud audit events and store raw JSONL payloads to S3
   # - Uses /v3/search API with pagination for audit events.
   # - Preserves vendor-native JSON format for identity events.
   # - Retries with exponential backoff; unique S3 keys to avoid overwrites.
   # - Outputs JSONL format (one event per line) for optimal Chronicle ingestion.
   
   import os, json, time, uuid, urllib.parse
   from urllib.request import Request, urlopen
   from urllib.error import URLError, HTTPError
   
   import boto3
   
   S3_BUCKET   = os.environ["S3_BUCKET"]
   S3_PREFIX   = os.environ.get("S3_PREFIX", "sailpoint/iam/")
   STATE_KEY   = os.environ.get("STATE_KEY", "sailpoint/iam/state.json")
   WINDOW_SEC  = int(os.environ.get("WINDOW_SECONDS", "3600"))  # default 1h
   HTTP_TIMEOUT= int(os.environ.get("HTTP_TIMEOUT", "60"))
   IDN_BASE    = os.environ["IDN_BASE"]  # e.g. https://tenant.api.identitynow.com
   CLIENT_ID   = os.environ["IDN_CLIENT_ID"]
   CLIENT_SECRET = os.environ["IDN_CLIENT_SECRET"]
   SCOPE       = os.environ.get("IDN_SCOPE", "sp:scopes:all")
   PAGE_SIZE   = int(os.environ.get("PAGE_SIZE", "250"))
   MAX_PAGES   = int(os.environ.get("MAX_PAGES", "20"))
   MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "3"))
   USER_AGENT  = os.environ.get("USER_AGENT", "sailpoint-iam-to-s3/1.0")
   
   s3 = boto3.client("s3")
   
   def _load_state():
       try:
           obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
           return json.loads(obj["Body"].read())
       except Exception:
           return {}
   
   def _save_state(st):
       s3.put_object(
           Bucket=S3_BUCKET,
           Key=STATE_KEY,
           Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
   
   def _iso(ts: float) -> str:
       return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))
   
   def _get_oauth_token() -> str:
       """Get OAuth2 access token using Client Credentials flow"""
       token_url = f"{IDN_BASE.rstrip('/')}/oauth/token"
   
       data = urllib.parse.urlencode({
           'grant_type': 'client_credentials',
           'client_id': CLIENT_ID,
           'client_secret': CLIENT_SECRET,
           'scope': SCOPE
       }).encode('utf-8')
   
       req = Request(token_url, data=data, method="POST")
       req.add_header("Content-Type", "application/x-www-form-urlencoded")
       req.add_header("User-Agent", USER_AGENT)
   
       with urlopen(req, timeout=HTTP_TIMEOUT) as r:
           response = json.loads(r.read())
           return response["access_token"]
   
   def _search_events(access_token: str, created_from: str, search_after: list = None) -> list:
       """Search for audit events using SailPoint's /v3/search API
   
       IMPORTANT: SailPoint requires colons in ISO8601 timestamps to be escaped with backslashes.
       Example: 2024-01-15T10:30:00Z must be sent as 2024-01-15T10\:30\:00Z
       Reference: https://developer.sailpoint.com/discuss/t/datetime-searches/6609
       """
       search_url = f"{IDN_BASE.rstrip('/')}/v3/search"
   
       # Escape colons in timestamp for SailPoint search query
       # SailPoint requires: created:>=2024-01-15T10\:30\:00Z (colons must be escaped)
       escaped_timestamp = created_from.replace(":", "\\:")
       query_str = f'created:>={escaped_timestamp}'
   
       payload = {
           "indices": ["events"],
           "query": {"query": query_str},
           "sort": ["created", "+id"],
           "limit": PAGE_SIZE
       }
   
       if search_after:
           payload["searchAfter"] = search_after
   
       attempt = 0
       while True:
           req = Request(search_url, data=json.dumps(payload).encode('utf-8'), method="POST")
           req.add_header("Content-Type", "application/json")
           req.add_header("Accept", "application/json")
           req.add_header("Authorization", f"Bearer {access_token}")
           req.add_header("User-Agent", USER_AGENT)
   
           try:
               with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                   response = json.loads(r.read())
                   # Handle different response formats
                   if isinstance(response, list):
                       return response
                   return response.get("results", response.get("data", []))
           except (HTTPError, URLError) 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 _put_events_data(events: list, from_ts: float, to_ts: float, page_num: int) -> str:
       """Write events to S3 in JSONL format (one JSON object per line)
   
       JSONL format is preferred for Chronicle ingestion as it allows:
       - Line-by-line processing
       - Better error recovery
       - Lower memory footprint
       """
       # Create unique S3 key for events data
       ts_path = time.strftime("%Y/%m/%d", time.gmtime(to_ts))
       uniq = f"{int(time.time()*1e6)}_{uuid.uuid4().hex[:8]}"
       key = f"{S3_PREFIX}{ts_path}/sailpoint_iam_{int(from_ts)}_{int(to_ts)}_p{page_num:03d}_{uniq}.jsonl"
   
       # Convert events list to JSONL format (one JSON object per line)
       jsonl_lines = [json.dumps(event, separators=(",", ":")) for event in events]
       jsonl_content = "\n".join(jsonl_lines)
   
       s3.put_object(
           Bucket=S3_BUCKET, 
           Key=key, 
           Body=jsonl_content.encode("utf-8"), 
           ContentType="application/x-ndjson",  # JSONL MIME type
           Metadata={
               'source': 'sailpoint-iam',
               'from_timestamp': str(int(from_ts)),
               'to_timestamp': str(int(to_ts)),
               'page_number': str(page_num),
               'events_count': str(len(events)),
               'format': 'jsonl'
           }
       )
       return key
   
   def _get_item_id(item: dict) -> str:
       """Extract ID from event item, trying multiple possible fields"""
       for field in ("id", "uuid", "eventId", "_id"):
           if field in item and item[field]:
               return str(item[field])
       return ""
   
   def lambda_handler(event=None, context=None):
       st = _load_state()
       now = time.time()
       from_ts = float(st.get("last_to_ts") or (now - WINDOW_SEC))
       to_ts = now
   
       # Get OAuth token
       access_token = _get_oauth_token()
   
       created_from = _iso(from_ts)
       print(f"Fetching SailPoint IAM events from: {created_from}")
   
       # Handle pagination state
       last_created = st.get("last_created")
       last_id = st.get("last_id")
       search_after = [last_created, last_id] if (last_created and last_id) else None
   
       pages = 0
       total_events = 0
       written_keys = []
       newest_created = last_created or created_from
       newest_id = last_id or ""
   
       while pages < MAX_PAGES:
           events = _search_events(access_token, created_from, search_after)
   
           if not events:
               break
   
           # Write page to S3 in JSONL format
           key = _put_events_data(events, from_ts, to_ts, pages + 1)
           written_keys.append(key)
           total_events += len(events)
   
           # Update pagination state from last item
           last_event = events[-1]
           last_event_created = last_event.get("created") or last_event.get("metadata", {}).get("created")
           last_event_id = _get_item_id(last_event)
   
           if last_event_created:
               newest_created = last_event_created
           if last_event_id:
               newest_id = last_event_id
   
           search_after = [newest_created, newest_id]
           pages += 1
   
           # If we got less than page size, we're done
           if len(events) < PAGE_SIZE:
               break
   
       print(f"Successfully retrieved {total_events} events across {pages} pages")
   
       # Save state for next run
       st["last_to_ts"] = to_ts
       st["last_created"] = newest_created
       st["last_id"] = newest_id
       st["last_successful_run"] = now
       _save_state(st)
   
       return {
           "statusCode": 200,
           "body": {
               "success": True,
               "pages": pages,
               "total_events": total_events,
               "s3_keys": written_keys,
               "from_timestamp": from_ts,
               "to_timestamp": to_ts,
               "last_created": newest_created,
               "last_id": newest_id,
               "format": "jsonl"
           }
       }
   
   if __name__ == "__main__":
       print(lambda_handler())
   

   Nota: Esta secuencia de comandos se proporciona como ejemplo y no se admite oficialmente. Agradecemos tus comentarios sobre cómo podemos mejorarla. Para enviar comentarios, haz clic en Enviar comentarios > Comentarios sobre el producto de seguridad de SecOps de Google en esta página.

5. Ve a Configuración > Variables de entorno > Editar > Agregar nueva variable de entorno.

6. Ingresa las siguientes variables de entorno y reemplaza los valores por los tuyos.

   Variables de entorno

   Clave	Valor de ejemplo
   S3_BUCKET	sailpoint-iam-logs
   S3_PREFIX	sailpoint/iam/
   STATE_KEY	sailpoint/iam/state.json
   WINDOW_SECONDS	3600
   HTTP_TIMEOUT	60
   MAX_RETRIES	3
   USER_AGENT	sailpoint-iam-to-s3/1.0
   IDN_BASE	https://tenant.api.identitynow.com
   IDN_CLIENT_ID	your-client-id (del paso 2)
   IDN_CLIENT_SECRET	your-client-secret (del paso 2)
   IDN_SCOPE	sp:scopes:all
   PAGE_SIZE	250
   MAX_PAGES	20

7. Después de crear la función, permanece en su página (o abre Lambda > Functions > tu-función).

8. Selecciona la pestaña Configuración.

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

10. 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 en ejecución cuando el temporizador llega a los 5 minutos, AWS Lambda la finalizará. Cualquier ejecución más corta simplemente finaliza de forma normal, y solo se te factura el tiempo de ejecución real.

Crea una programación de EventBridge

1. Ve a Amazon EventBridge > Scheduler > Create schedule.
2. Proporciona los siguientes detalles de configuración:
   • Programación recurrente: Frecuencia (1 hour).
   • Destino: Tu función Lambda sailpoint_iam_to_s3.
   • Nombre: sailpoint-iam-1h.
3. Haz clic en Crear programación.

Opcional: Crea un usuario y claves de IAM de solo lectura para Google SecOps

1. Ve a Consola de AWS > IAM > Usuarios > Agregar usuarios.
2. Haz clic en Agregar usuarios.
3. Proporciona los siguientes detalles de configuración:
   • Usuario: Ingresa secops-reader.
   • Tipo de acceso: Selecciona Clave de acceso: Acceso programático.
4. Haz clic en Crear usuario.
5. Adjunta una política de lectura mínima (personalizada): Usuarios > secops-reader > Permisos > Agregar permisos > Adjuntar políticas directamente > Crear política.

6. En el editor de JSON, ingresa la siguiente política:

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

7. Configura el nombre como secops-reader-policy.

8. Ve a Crear política > busca o selecciona > Siguiente > Agregar permisos.

9. Ve a Credenciales de seguridad > Claves de acceso > Crear clave de acceso.

10. Descarga el archivo CSV (estos valores se ingresan en el feed).

Configura un feed en Google SecOps para transferir registros de IAM de SailPoint

1. Ve a Configuración de SIEM > Feeds.
2. Haz clic en + Agregar feed nuevo.
3. En la siguiente página, haz clic en Configurar un solo feed.
4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, SailPoint IAM logs).
5. Selecciona Amazon S3 V2 como el Tipo de fuente.
6. Selecciona IAM de SailPoint como el Tipo de registro.
7. Haz clic en Siguiente.
8. Especifica valores para los siguientes parámetros de entrada:
   • URI de S3: s3://sailpoint-iam-logs/sailpoint/iam/
   • Opciones de borrado de la fuente: Selecciona la opción de borrado según tu preferencia.
   • Antigüedad máxima del archivo: 180 días de forma predeterminada
   • ID de clave de acceso: Clave de acceso del usuario con acceso al bucket de S3.
   • Clave de acceso secreta: Clave secreta del usuario con acceso al bucket de S3.
   • Espacio de nombres del recurso: Es el espacio de nombres del recurso.
   • Etiquetas de transmisión: Es la etiqueta que se aplica 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
action	metadata.description	Es el valor del campo action del registro sin procesar.
actor.name	principal.user.user_display_name	Es el valor del campo actor.name del registro sin procesar.
attributes.accountName	principal.user.group_identifiers	Es el valor del campo attributes.accountName del registro sin procesar.
attributes.appId	target.asset_id	"ID de la app: " concatenado con el valor del campo attributes.appId del registro sin procesar.
attributes.attributeName	additional.fields[0].value.string_value	Es el valor del campo attributes.attributeName del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Nombre del atributo".
attributes.attributeValue	additional.fields[1].value.string_value	Es el valor del campo attributes.attributeValue del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Attribute Value".
attributes.cloudAppName	target.application	Es el valor del campo attributes.cloudAppName del registro sin procesar.
attributes.hostName	target.hostname, target.asset.hostname	Es el valor del campo attributes.hostName del registro sin procesar.
attributes.interface	additional.fields[2].value.string_value	Es el valor del campo attributes.interface del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Interface".
attributes.operation	security_result.action_details	Es el valor del campo attributes.operation del registro sin procesar.
attributes.previousValue	additional.fields[3].value.string_value	Es el valor del campo attributes.previousValue del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Valor anterior".
attributes.provisioningResult	security_result.detection_fields.value	Valor del campo attributes.provisioningResult del registro sin procesar, colocado dentro de un objeto security_result.detection_fields. La clave se establece en "Provisioning Result".
attributes.sourceId	principal.labels[0].value	Valor del campo attributes.sourceId del registro sin procesar, colocado dentro de un objeto principal.labels. La clave se establece en "ID de fuente".
attributes.sourceName	principal.labels[1].value	Valor del campo attributes.sourceName del registro sin procesar, colocado dentro de un objeto principal.labels. La clave se establece en "Nombre de la fuente".
auditClassName	metadata.product_event_type	Es el valor del campo auditClassName del registro sin procesar.
created	metadata.event_timestamp.seconds, metadata.event_timestamp.nanos	Valor del campo created del registro sin procesar, convertido a marca de tiempo si instant.epochSecond no está presente.
id	metadata.product_log_id	Es el valor del campo id del registro sin procesar.
instant.epochSecond	metadata.event_timestamp.seconds	Es el valor del campo instant.epochSecond del registro sin procesar, que se usa para la marca de tiempo.
ipAddress	principal.asset.ip, principal.ip	Es el valor del campo ipAddress del registro sin procesar.
interface	additional.fields[0].value.string_value	Es el valor del campo interface del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "interface".
loggerName	intermediary.application	Es el valor del campo loggerName del registro sin procesar.
message	metadata.description, security_result.description	Se usa para diversos fines, como establecer la descripción en los metadatos y security_result, y extraer contenido XML.
name	security_result.description	Es el valor del campo name del registro sin procesar.
operation	target.resource.attribute.labels[0].value, metadata.product_event_type	Valor del campo operation del registro sin procesar, colocado dentro de un objeto target.resource.attribute.labels. La clave se establece en "operation". También se usa para metadata.product_event_type.
org	principal.administrative_domain	Es el valor del campo org del registro sin procesar.
pod	principal.location.name	Es el valor del campo pod del registro sin procesar.
referenceClass	additional.fields[1].value.string_value	Es el valor del campo referenceClass del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "referenceClass".
referenceId	additional.fields[2].value.string_value	Es el valor del campo referenceId del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "referenceId".
sailPointObjectName	additional.fields[3].value.string_value	Es el valor del campo sailPointObjectName del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "sailPointObjectName".
serverHost	principal.hostname, principal.asset.hostname	Es el valor del campo serverHost del registro sin procesar.
stack	additional.fields[4].value.string_value	Es el valor del campo stack del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Stack".
status	security_result.severity_details	Es el valor del campo status del registro sin procesar.
target	additional.fields[4].value.string_value	Es el valor del campo target del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "target".
target.name	principal.user.userid	Es el valor del campo target.name del registro sin procesar.
technicalName	security_result.summary	Es el valor del campo technicalName del registro sin procesar.
thrown.cause.message	xml_body, detailed_message	Es el valor del campo thrown.cause.message del registro sin procesar, que se usa para extraer contenido XML.
thrown.message	xml_body, detailed_message	Es el valor del campo thrown.message del registro sin procesar, que se usa para extraer contenido XML.
trackingNumber	additional.fields[5].value.string_value	Es el valor del campo trackingNumber del registro sin procesar, colocado dentro de un objeto additional.fields. La clave se establece en "Número de seguimiento".
type	metadata.product_event_type	Es el valor del campo type del registro sin procesar.
_version	metadata.product_version	Es el valor del campo _version del registro sin procesar.
N/A	metadata.event_timestamp	Se deriva de los campos instant.epochSecond o created.
N/A	metadata.event_type	Se determina según la lógica del analizador en función de varios campos, incluidos has_principal_user, has_target_application, technicalName y action. El valor predeterminado es "GENERIC_EVENT".
N/A	metadata.log_type	Se debe establecer en "SAILPOINT_IAM".
N/A	metadata.product_name	Establécelo en "IAM".
N/A	metadata.vendor_name	Se establece en "SAILPOINT".
N/A	extensions.auth.type	Se establece en "AUTHTYPE_UNSPECIFIED" en ciertas condiciones.
N/A	target.resource.attribute.labels[0].key	Se establece en "operación".

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