Coletar registros do Saviynt Enterprise Identity Cloud

Compatível com:

Neste documento, explicamos como ingerir registros do Saviynt Enterprise Identity Cloud (EIP) no Google Security Operations usando o Google Cloud Storage V2.

O Saviynt Enterprise Identity Cloud (EIP) é uma plataforma de governança de identidade e segurança na nuvem usada para gerenciamento de acesso, gerenciamento do ciclo de vida de identidade e compliance. Ele gera dados de registro de auditoria para todas as atividades de segurança realizadas no repositório de identidade.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

  • Uma instância do Google SecOps
  • Um projeto do GCP com a API Cloud Storage ativada
  • Permissões para criar e gerenciar buckets do GCS
  • Permissões para gerenciar políticas do IAM em buckets do GCS
  • Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler
  • Acesso privilegiado à EIP do Saviynt com permissões de administrador

Criar um bucket do Google Cloud Storage

  1. Acesse o Console do Google Cloud.
  2. Selecione seu projeto ou crie um novo.
  3. No menu de navegação, acesse Cloud Storage > Buckets.
  4. Clique em Criar bucket.
  5. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nomeie seu bucket Insira um nome globalmente exclusivo (por exemplo, saviynt-eip-logs)
    Tipo de local Escolha de acordo com suas necessidades (região, birregional, multirregional)
    Local Selecione o local (por exemplo, us-central1).
    Classe de armazenamento Padrão (recomendado para registros acessados com frequência)
    Controle de acesso Uniforme (recomendado)
    Ferramentas de proteção Opcional: ativar o controle de versões de objetos ou a política de retenção
  6. Clique em Criar.

Coletar credenciais da API Saviynt EIP

Receber credenciais de API

  1. Faça login no Admin Console do Saviynt EIP.
  2. Acesse Administrador > Configurações > Conexões.
  3. Crie ou identifique um usuário da API com as seguintes permissões:
    • webservice_api_authenticateUser
    • api_v5_fetchRuntimeControlsData
  4. Observe os seguintes detalhes:
    • Nome de usuário: o nome de usuário da conta de usuário da API.
    • Senha: a senha da conta de usuário da API.
    • URL do host do Saviynt: o URL do locatário do Saviynt (por exemplo, https://YOUR_SAVIYNT_HOST).

Determinar o nome da análise

  1. No Admin Console do Saviynt, acesse Admin > Runtime Controls.
  2. Anote o Nome do Analytics dos dados de auditoria que você quer exportar (por exemplo, AuditTrailAnalytics).

Verifique as permissões

Para verificar se o usuário da API tem as permissões necessárias:

  1. Faça login no Admin Console do Saviynt EIP.
  2. Acesse Administrador > Gerenciamento de usuários.
  3. Clique na conta de usuário da API.
  4. Verifique se o usuário tem as permissões de acesso webservice_api_authenticateUser e api_v5_fetchRuntimeControlsData.
  5. Se as permissões estiverem ausentes, entre em contato com o administrador do Saviynt.

Testar o acesso à API

  • Teste suas credenciais antes de prosseguir com a integração:

    # Replace with your actual credentials
    SAVIYNT_HOST="https://YOUR_SAVIYNT_HOST"
    USERNAME="your-username"
    PASSWORD="your-password"
    
    # Get authentication token
    TOKEN=$(curl -s -X POST "${SAVIYNT_HOST}/ECM/api/login" \
      -H "Content-Type: application/json" \
      -d "{\"username\": \"${USERNAME}\", \"password\": \"${PASSWORD}\"}" \
      | jq -r '.access_token')
    
    # Test API access
    curl -v -H "Authorization: Bearer ${TOKEN}" \
      -H "Content-Type: application/json" \
      -X POST "${SAVIYNT_HOST}/ECM/api/v5/fetchRuntimeControlsDataV2" \
      -d '{"analyticsname": "YOUR_ANALYTICS_NAME", "timeFrame": 5}'
    

Criar uma conta de serviço para a função do Cloud Run

A função do Cloud Run precisa de uma conta de serviço com permissões para gravar no bucket do GCS e ser invocada pelo Pub/Sub.

Criar conta de serviço

  1. No Console do GCP, acesse IAM e administrador > Contas de serviço.
  2. Clique em Criar conta de serviço.
  3. Informe os seguintes detalhes de configuração:
    • Nome da conta de serviço: insira saviynt-eip-collector-sa.
    • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Saviynt EIP logs.
  4. Clique em Criar e continuar.
  5. Na seção Conceder acesso a essa conta de serviço ao projeto, adicione os seguintes papéis:
    1. Clique em Selecionar papel.
    2. Pesquise e selecione Administrador de objetos do Storage.
    3. Clique em + Adicionar outro papel.
    4. Pesquise e selecione Invocador do Cloud Run.
    5. Clique em + Adicionar outro papel.
    6. Pesquise e selecione Invocador do Cloud Functions.
  6. Clique em Continuar.
  7. Clique em Concluído.

Esses papéis são necessários para:

  • Administrador de objetos do Storage: gravar registros no bucket do GCS e gerenciar arquivos de estado
  • Invocador do Cloud Run: permite que o Pub/Sub invoque a função.
  • Invocador do Cloud Functions: permite a invocação de funções.

Conceder permissões do IAM no bucket do GCS

Conceda à conta de serviço permissões de gravação no bucket do GCS:

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (por exemplo, saviynt-eip-logs).
  3. Acesse a guia Permissões.
  4. Clique em Conceder acesso.
  5. Informe os seguintes detalhes de configuração:
    • Adicionar participantes: insira o e-mail da conta de serviço (por exemplo, saviynt-eip-collector-sa@your-project.iam.gserviceaccount.com).
    • Atribuir papéis: selecione Administrador de objetos do Storage.
  6. Clique em Salvar.

Criar tópico Pub/Sub

Crie um tópico do Pub/Sub em que o Cloud Scheduler vai publicar e a função do Cloud Run vai se inscrever.

  1. No Console do GCP, acesse Pub/Sub > Tópicos.
  2. Selecione Criar tópico.
  3. Informe os seguintes detalhes de configuração:
    • ID do tópico: insira saviynt-eip-trigger.
    • Não mude as outras configurações.
  4. Clique em Criar.

Criar uma função do Cloud Run para coletar registros

A função do Cloud Run será acionada por mensagens do Pub/Sub do Cloud Scheduler para buscar registros da API Saviynt EIP e gravá-los no GCS.

  1. No Console do GCP, acesse o Cloud Run.
  2. Clique em Criar serviço.
  3. Selecione Função (use um editor in-line para criar uma função).
  4. Na seção Configurar, forneça os seguintes detalhes de configuração:

    Configuração Valor
    Nome do serviço saviynt-eip-collector
    Região Selecione a região correspondente ao bucket do GCS (por exemplo, us-central1).
    Ambiente de execução Selecione Python 3.12 ou mais recente.
  5. Na seção Acionador (opcional):

    1. Clique em + Adicionar gatilho.
    2. Selecione Cloud Pub/Sub.
    3. Em Selecionar um tópico do Cloud Pub/Sub, escolha o tópico saviynt-eip-trigger.
    4. Clique em Salvar.
  6. Na seção Autenticação:

    1. Selecione Exigir autenticação.
    2. Verifique o Identity and Access Management (IAM).
  7. Role para baixo e abra Contêineres, rede, segurança.

  8. Acesse a guia Segurança:

    • Conta de serviço: selecione a conta de serviço saviynt-eip-collector-sa.
  9. Acesse a guia Contêineres:

    1. Clique em Variáveis e secrets.
    2. Clique em + Adicionar variável para cada variável de ambiente:
    Nome da variável Valor de exemplo Descrição
    GCS_BUCKET saviynt-eip-logs Nome do bucket do GCS
    GCS_PREFIX saviynt Prefixo para arquivos de registro
    STATE_KEY saviynt/state.json Caminho do arquivo de estado
    SAVIYNT_HOST https://YOUR_SAVIYNT_HOST URL do locatário do Saviynt
    SAVIYNT_USER your-api-username Nome de usuário da API
    SAVIYNT_PASS your-api-password Senha do usuário da API
    ANALYTICS_NAME AuditTrailAnalytics Nome do registro do Analytics
    TIMEFRAME_MINUTES 60 Período em minutos para cada consulta
    MAX_RECORDS 10000 Máximo de registros por execução
    LOOKBACK_HOURS 24 Período de lookback inicial
  10. Na guia Variáveis e secrets, navegue até a seção Solicitações:

    • Tempo limite da solicitação: insira 600 segundos (10 minutos).
  11. Acesse a guia Configurações em Contêineres:

    • Na seção Recursos:
      • Memória: selecione 512 MiB ou mais.
      • CPU: selecione 1.
  12. Na seção Escalonamento de revisão:

    • Número mínimo de instâncias: insira 0.
    • Número máximo de instâncias: insira 100 (ou ajuste com base na carga esperada).
  13. Clique em Criar.

  14. Aguarde a criação do serviço (1 a 2 minutos).

  15. Depois que o serviço for criado, o editor de código inline será aberto automaticamente.

Adicionar código da função

  1. Insira main em Ponto de entrada da função.
  2. No editor de código inline, crie dois arquivos:

    • Primeiro arquivo main.py::

      import functions_framework
      from google.cloud import storage
      import json
      import os
      import urllib3
      from datetime import datetime, timezone, timedelta
      import time
      
      # 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', 'saviynt')
      STATE_KEY = os.environ.get('STATE_KEY', 'saviynt/state.json')
      SAVIYNT_HOST = os.environ.get('SAVIYNT_HOST', '').rstrip('/')
      SAVIYNT_USER = os.environ.get('SAVIYNT_USER', '')
      SAVIYNT_PASS = os.environ.get('SAVIYNT_PASS', '')
      ANALYTICS_NAME = os.environ.get('ANALYTICS_NAME', '')
      TIMEFRAME_MINUTES = int(os.environ.get('TIMEFRAME_MINUTES', '60'))
      MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
      LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
      
      def parse_datetime(value: str) -> datetime:
        """Parse ISO datetime string to datetime object."""
        if value.endswith("Z"):
          value = value[:-1] + "+00:00"
        return datetime.fromisoformat(value)
      
      def get_token():
        """Get authentication token from Saviynt login API."""
        login_url = f"{SAVIYNT_HOST}/ECM/api/login"
      
        body = json.dumps({
          "username": SAVIYNT_USER,
          "password": SAVIYNT_PASS
        })
      
        headers = {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      
        backoff = 1.0
        max_retries = 3
      
        for attempt in range(max_retries):
          response = http.request('POST', login_url, body=body.encode('utf-8'), headers=headers)
      
          if response.status == 429:
            retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
            print(f"Rate limited (429) on login request. Retrying after {retry_after}s...")
            time.sleep(retry_after)
            backoff = min(backoff * 2, 30.0)
            continue
      
          if response.status != 200:
            raise RuntimeError(f"Failed to authenticate: {response.status} - {response.data.decode('utf-8')}")
      
          data = json.loads(response.data.decode('utf-8'))
          return data['access_token']
      
        raise RuntimeError(f"Failed to get token after {max_retries} retries due to rate limiting")
      
      @functions_framework.cloud_event
      def main(cloud_event):
        """
        Cloud Run function triggered by Pub/Sub to fetch Saviynt EIP logs and write to GCS.
      
        Args:
          cloud_event: CloudEvent object containing Pub/Sub message
        """
      
        if not all([GCS_BUCKET, SAVIYNT_HOST, SAVIYNT_USER, SAVIYNT_PASS, ANALYTICS_NAME]):
          print('Error: Missing required environment variables')
          return
      
        try:
          bucket = storage_client.bucket(GCS_BUCKET)
      
          # Load state
          state = load_state(bucket, STATE_KEY)
      
          now = datetime.now(timezone.utc)
      
          print(f"Fetching audit logs with analytics={ANALYTICS_NAME}, timeFrame={TIMEFRAME_MINUTES}")
      
          # Get access token
          token = get_token()
      
          # Fetch logs
          records = fetch_logs(
            token=token,
            analytics_name=ANALYTICS_NAME,
            timeframe_minutes=TIMEFRAME_MINUTES,
            max_records=MAX_RECORDS,
          )
      
          if not records:
            print("No new log records found.")
            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}/logs_{timestamp}.ndjson"
          blob = bucket.blob(object_key)
      
          ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in records]) + '\n'
          blob.upload_from_string(ndjson, content_type='application/x-ndjson')
      
          print(f"Wrote {len(records)} records to gs://{GCS_BUCKET}/{object_key}")
      
          save_state(bucket, STATE_KEY, now.isoformat())
          print(f"Successfully processed {len(records)} records")
      
        except Exception as e:
          print(f'Error processing logs: {str(e)}')
          raise
      
      def load_state(bucket, key):
        """Load state from GCS."""
        try:
          blob = bucket.blob(key)
          if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
        except Exception as e:
          print(f"Warning: Could not load state: {e}")
      
        return {}
      
      def save_state(bucket, key, last_event_time_iso: str):
        """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 fetch_logs(token: str, analytics_name: str, timeframe_minutes: int, max_records: int):
        """
        Fetch audit logs from Saviynt fetchRuntimeControlsDataV2 API with rate limiting.
      
        Args:
          token: Authentication token
          analytics_name: Name of the analytics record
          timeframe_minutes: Timeframe in minutes for the query
          max_records: Maximum total records to fetch
      
        Returns:
          List of records
        """
        endpoint = f"{SAVIYNT_HOST}/ECM/api/v5/fetchRuntimeControlsDataV2"
      
        headers = {
          'Authorization': f'Bearer {token}',
          'Content-Type': 'application/json',
          'Accept': 'application/json',
          'User-Agent': 'GoogleSecOps-SaviyntCollector/1.0'
        }
      
        body = json.dumps({
          "analyticsname": analytics_name,
          "timeFrame": timeframe_minutes
        })
      
        backoff = 1.0
        max_retries = 3
      
        for attempt in range(max_retries):
          try:
            response = http.request('POST', endpoint, body=body.encode('utf-8'), 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, 30.0)
              continue
      
            backoff = 1.0
      
            if response.status != 200:
              print(f"HTTP Error: {response.status}")
              response_text = response.data.decode('utf-8')
              print(f"Response body: {response_text}")
              return []
      
            data = json.loads(response.data.decode('utf-8'))
      
            # Saviynt returns results in a 'result' or 'results' key
            records = data.get('result', data.get('results', []))
      
            if isinstance(records, list):
              if len(records) > max_records:
                records = records[:max_records]
              print(f"Retrieved {len(records)} audit records")
              return records
            else:
              # If the response is a single object, wrap it
              print(f"Retrieved 1 audit record")
              return [records]
      
          except Exception as e:
            print(f"Error fetching logs: {e}")
            if attempt < max_retries - 1:
              time.sleep(backoff)
              backoff = min(backoff * 2, 30.0)
              continue
            return []
      
        return []
      
    • Segundo arquivo requirements.txt::

      functions-framework==3.*
      google-cloud-storage==2.*
      urllib3>=2.0.0
      
  3. Clique em Implantar para salvar e implantar a função.

  4. Aguarde a conclusão da implantação (2 a 3 minutos).

Criar o job do Cloud Scheduler

O Cloud Scheduler vai publicar mensagens no tópico do Pub/Sub em intervalos regulares, acionando a função do Cloud Run.

  1. No Console do GCP, acesse o Cloud Scheduler.
  2. Clique em Criar job.
  3. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nome saviynt-eip-collector-hourly
    Região Selecione a mesma região da função do Cloud Run
    Frequência 0 * * * * (de hora em hora)
    Fuso horário Selecione o fuso horário (UTC recomendado)
    Tipo de destino Pub/Sub
    Tópico Selecione o tópico saviynt-eip-trigger.
    Corpo da mensagem {} (objeto JSON vazio)
  4. Clique em Criar.

Opções de frequência de programação

Escolha a frequência com base no volume de registros e nos requisitos de latência:

Frequência Expressão Cron Caso de uso
A cada 5 minutos */5 * * * * Alto volume e baixa latência
A cada 15 minutos */15 * * * * Volume médio
A cada hora 0 * * * * Padrão (recomendado)
A cada 6 horas 0 */6 * * * Processamento em lote de baixo volume
Diário 0 0 * * * Coleta de dados históricos

Testar a integração

  1. No console do Cloud Scheduler, encontre seu job (saviynt-eip-collector-hourly).
  2. Clique em Forçar execução para acionar manualmente.
  3. Aguarde alguns segundos e acesse Cloud Run > Serviços > saviynt-eip-collector > Registros.
  4. Verifique se a função foi executada com sucesso. Procure por:

    Fetching audit logs with analytics=AuditTrailAnalytics, timeFrame=60
    Retrieved X audit records
    Wrote X records to gs://saviynt-eip-logs/saviynt/logs_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X records
    
  5. Verifique o bucket do GCS (saviynt-eip-logs) para confirmar se os registros foram gravados.

Se você encontrar erros nos registros:

  • HTTP 401: verifique as credenciais da API nas variáveis de ambiente.
  • HTTP 403: verifique se o usuário da API tem as permissões necessárias no console de administração do Saviynt.
  • HTTP 429: limitação de taxa. A função vai tentar novamente de forma automática com espera
  • Falha na autenticação: verifique se SAVIYNT_HOST, SAVIYNT_USER e SAVIYNT_PASS estão corretos.

Configurar um feed no Google SecOps para ingerir registros do Saviynt EIP

  1. Acesse Configurações > Gerenciamento de dados > Feeds. Se você estiver em uma plataforma somente SIEM, acesse Configurações > Feeds.
  2. Clique em Adicionar novo feed.
  3. Clique em Configurar um único feed.
  4. No campo Nome do feed, insira um nome para o feed (por exemplo, Saviynt EIP Logs).
  5. Selecione Google Cloud Storage V2 como o Tipo de origem.
  6. Selecione Saviynt Enterprise Identity Cloud como o Tipo de registro.
  7. Clique em Get Service Account. Um e-mail exclusivo da conta de serviço será exibido, por exemplo:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. Copie o endereço de e-mail. Você vai usá-la na próxima etapa.

  9. Clique em Próxima.

  10. Especifique valores para os seguintes parâmetros de entrada:

    • URL do bucket de armazenamento: insira o URI do bucket do GCS com o caminho do prefixo:

      gs://saviynt-eip-logs/saviynt/
      
      • Substitua:
        • saviynt-eip-logs: o nome do bucket do GCS.
        • saviynt: prefixo/caminho de pasta opcional em que os registros são armazenados (deixe em branco para a raiz).
    • Opção de exclusão da fonte: selecione a opção de exclusão de acordo com sua preferência:

      • Nunca: nunca exclui arquivos após as transferências (recomendado para testes).
      • Excluir arquivos transferidos: exclui arquivos após a transferência.
      • Excluir arquivos transferidos e diretórios vazios: exclui arquivos e diretórios vazios após a transferência.

    • Idade máxima do arquivo: inclua arquivos modificados nos últimos dias (o padrão é 180 dias).

    • Namespace do recurso: o namespace do recurso.

    • Rótulos de ingestão: o rótulo a ser aplicado aos eventos desse feed.

  11. Clique em Próxima.

  12. Revise a configuração do novo feed na tela Finalizar e clique em Enviar.

Conceder permissões do IAM à conta de serviço do Google SecOps

A conta de serviço do Google SecOps precisa do papel Leitor de objetos do Storage no bucket do GCS.

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (saviynt-eip-logs).
  3. Acesse a guia Permissões.
  4. Clique em Conceder acesso.
  5. Informe os seguintes detalhes de configuração:
    • Adicionar principais: cole o e-mail da conta de serviço do Google SecOps.
    • Atribuir papéis: selecione Leitor de objetos do Storage.
  6. Clique em Salvar.

Tabela de mapeamento de UDM

Campo de registro Mapeamento de UDM Lógica
action_taken sr.action_details Detalhes da ação
categoria sr.category_details Detalhes da categoria
Message,message metadata.description A descrição do evento
metadata.event_type Tipo de evento
Tipo de objeto metadata.product_event_type Tipo de evento específico do produto
eventId metadata.product_log_id ID do registro do produto
Endereço IP principal.ip Endereço IP
consulta principal.process.command_line Linha de comando do processo
actionUri principal.url URL
accessed_by principal.user.email_addresses Endereços de e-mail do usuário
accessed_by principal.user.userid ID do usuário
sr security_result Resultado de segurança
metadata.product_name Nome do produto
metadata.vendor_name Nome do fornecedor

Registro de alterações

Confira o registro de alterações deste analisador

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais do Google SecOps.