Coletar registros do PingIDM (antigo ForgeRock OpenIDM)

Versão do analisador: 4.0

Compatível com:

Este documento explica como ingerir registros do PingIDM (antigo ForgeRock OpenIDM) no Google Security Operations usando o Cloud Storage V2.

O PingIDM é uma plataforma de gerenciamento de identidade que oferece provisionamento de usuários, sincronização, gerenciamento de senhas e governança de acesso. Ele registra eventos de ciclo de vida de identidade, tentativas de autenticação, operações de reconciliação e mudanças de configuração em registros de auditoria acessíveis por REST.

Antes de começar

Verifique se você atende aos seguintes pré-requisitos:

  • Uma instância do Google SecOps.
  • Um projeto do Google Cloud com a API Cloud Storage ativada.
  • Permissões para criar e gerenciar buckets do Cloud Storage e políticas do Identity and Access Management (IAM).
  • Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler.
  • Acesso privilegiado a uma instância do ForgeRock OpenIDM ou PingIDM com credenciais administrativas.

criar o bucket do Cloud Storage

  1. Acesse o console doGoogle 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, forgerock-openidm-audit-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 do ForgeRock OpenIDM

Acessar o URL de base do ForgeRock OpenIDM

  1. Faça login na sua instância do ForgeRock OpenIDM ou PingIDM.
  2. Anote o URL de base na barra de endereço do navegador.
    • Formato: https://openidm.example.com
    • Não inclua barras finais ou caminhos como /admin.

Receber credenciais administrativas

  1. Consiga credenciais administrativas para sua instância do ForgeRock OpenIDM.
  2. Você precisará do seguinte:
    • Nome de usuário: nome de usuário administrativo (por exemplo, openidm-admin)
    • Senha: senha administrativa

Verifique as permissões

  1. Faça login no ForgeRock OpenIDM.
  2. Acesse Configurar > Preferências do sistema > Auditoria.
  3. Se você conseguir ver a configuração e os tópicos de auditoria, significa que tem as permissões necessárias.
  4. Se essa opção não estiver disponível, entre em contato com o administrador para receber permissões de leitura de auditoria.

Testar o acesso à API

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

    # Replace with your actual credentials
    OPENIDM_BASE_URL="[https://openidm.example.com](https://openidm.example.com)"
    OPENIDM_USERNAME="openidm-admin"
    OPENIDM_PASSWORD="your-admin-password"
    
    # Test API access to authentication audit topic
    curl -v \
        -H "X-OpenIDM-Username: ${OPENIDM_USERNAME}" \
        -H "X-OpenIDM-Password: ${OPENIDM_PASSWORD}" \
        -H "Accept-API-Version: resource=1.0" \
        -H "Accept: application/json" \
        "${OPENIDM_BASE_URL}/openidm/audit/authentication?_queryFilter=true&_pageSize=1"
    

Resposta esperada: HTTP 200 com JSON contendo eventos de auditoria.

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 Cloud Storage e ser invocada pelo Pub/Sub.

Criar conta de serviço

  1. No console do Google Cloud , 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: forgerock-openidm-collector-sa
    • Descrição da conta de serviço: Service account for Cloud Run function to collect ForgeRock OpenIDM 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. Administrador de objetos do Storage: para gravar registros no bucket do Cloud Storage e gerenciar arquivos de estado.
    2. Invocador do Cloud Run: para permitir que o Pub/Sub invoque a função.
    3. Invocador do Cloud Functions: para permitir a invocação de funções.
  6. Clique em Continuar e depois em Concluído.

Conceder permissões do IAM no bucket do Cloud Storage

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

Criar tópico Pub/Sub

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

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

  1. No console do Google Cloud , 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 forgerock-openidm-collector
    Região Selecione a região correspondente ao bucket do Cloud Storage (por exemplo, us-central1)
    Ambiente de execução Selecione Python 3.12 ou mais recente.
  5. Na seção Acionador:

    1. Clique em + Adicionar gatilho.
    2. Selecione Cloud Pub/Sub.
    3. Em Selecionar um tópico do Cloud Pub/Sub, escolha forgerock-openidm-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 forgerock-openidm-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 forgerock-openidm-audit-logs Nome do bucket do Cloud Storage
    GCS_PREFIX openidm Prefixo para arquivos de registro
    STATE_KEY openidm/state.json Caminho do arquivo de estado
    OPENIDM_BASE_URL https://openidm.example.com URL de base do OpenIDM
    OPENIDM_USERNAME openidm-admin Nome de usuário do administrador do OpenIDM
    OPENIDM_PASSWORD your-admin-password Senha de administrador do OpenIDM
    AUDIT_TOPICS access,activity,authentication,config,sync Tópicos separados por vírgulas
    PAGE_SIZE 100 Registros por página
    MAX_PAGES 50 Máximo de páginas por tópico
  10. Na seção Solicitações:

    • Tempo limite da solicitação: 600 segundos.
  11. Acesse a guia Configurações:

    • Recursos: 512 MiB de memória, 1 CPU.
  12. Clique em Criar. Depois que o serviço for criado, o editor de código inline será aberto.

Adicionar código da função

  1. Insira main no campo Ponto de entrada.
  2. Crie dois arquivos no editor:

    • main.py:
    import functions_framework
    from google.cloud import storage
    import json
    import os
    import urllib3
    from datetime import datetime, timezone
    
    # 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', 'openidm')
    STATE_KEY = os.environ.get('STATE_KEY', 'openidm/state.json')
    OPENIDM_BASE_URL = os.environ.get('OPENIDM_BASE_URL')
    OPENIDM_USERNAME = os.environ.get('OPENIDM_USERNAME')
    OPENIDM_PASSWORD = os.environ.get('OPENIDM_PASSWORD')
    AUDIT_TOPICS = os.environ.get('AUDIT_TOPICS', 'access,activity,authentication,config,sync').split(',')
    PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
    MAX_PAGES = int(os.environ.get('MAX_PAGES', '50'))
    
    @functions_framework.cloud_event
    def main(cloud_event):
        """
        Cloud Run function triggered by Pub/Sub to fetch ForgeRock OpenIDM logs and write to GCS.
        """
        if not all([GCS_BUCKET, OPENIDM_BASE_URL, OPENIDM_USERNAME, OPENIDM_PASSWORD]):
            print('Error: Missing required environment variables')
            return
    
        try:
            bucket = storage_client.bucket(GCS_BUCKET)
            state = load_state(bucket, STATE_KEY)
    
            all_events = []
            for topic in AUDIT_TOPICS:
                topic = topic.strip()
                print(f"Fetching audit logs for topic: {topic}")
                events = fetch_audit_logs(topic, state.get(topic, {}))
                all_events.extend(events)
    
                if events:
                    latest_timestamp = max(e.get('timestamp', '') for e in events)
                    state[topic] = {
                        'last_timestamp': latest_timestamp,
                        'last_run': datetime.now(timezone.utc).isoformat(),
                        'events_count': len(events)
                    }
    
            if all_events:
                write_to_gcs(bucket, all_events)
                save_state(bucket, STATE_KEY, state)
                print(f"Successfully processed {len(all_events)} audit events")
            else:
                print("No new audit events to process")
    
        except Exception as e:
            print(f'Error processing logs: {str(e)}')
            raise
    
    def load_state(bucket, key):
        try:
            blob = bucket.blob(key)
            if blob.exists():
                return json.loads(blob.download_as_text())
        except Exception as e:
            print(f"Warning: Could not load state: {e}")
        return {}
    
    def save_state(bucket, key, state):
        try:
            blob = bucket.blob(key)
            blob.upload_from_string(json.dumps(state, indent=2), content_type='application/json')
        except Exception as e:
            print(f"Warning: Could not save state: {e}")
    
    def fetch_audit_logs(topic, topic_state):
        base_url = OPENIDM_BASE_URL.rstrip('/')
        all_events = []
        last_timestamp = topic_state.get('last_timestamp')
        query_filter = 'true' if not last_timestamp else f'timestamp gt "{last_timestamp}"'
        page_offset = 0
        page_count = 0
    
        while page_count < MAX_PAGES:
            try:
                url = f"{base_url}/openidm/audit/{topic}"
                params = {
                    '_queryFilter': query_filter,
                    '_pageSize': str(PAGE_SIZE),
                    '_pagedResultsOffset': str(page_offset),
                    '_sortKeys': 'timestamp'
                }
    
                headers = {
                    'X-OpenIDM-Username': OPENIDM_USERNAME,
                    'X-OpenIDM-Password': OPENIDM_PASSWORD,
                    'Accept-API-Version': 'resource=1.0',
                    'Accept': 'application/json'
                }
    
                response = http.request('GET', url, fields=params, headers=headers)
                if response.status != 200:
                    print(f"API error for topic {topic}: {response.status}")
                    break
    
                data = json.loads(response.data.decode('utf-8'))
                events = data.get('result', [])
                if not events:
                    break
    
                all_events.extend(events)
                page_offset += PAGE_SIZE
                page_count += 1
                if len(events) < PAGE_SIZE:
                    break
            except Exception as e:
                print(f"Error for topic {topic}: {str(e)}")
                break
        return all_events
    
    def write_to_gcs(bucket, events):
        timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
        filename = f"{GCS_PREFIX}/openidm_audit_{timestamp}.json"
        ndjson_content = '\n'.join([json.dumps(event) for event in events])
        bucket.blob(filename).upload_from_string(ndjson_content, content_type='application/x-ndjson')
    
    • requirements.txt:
    functions-framework==3.*
    google-cloud-storage==2.*
    urllib3>=2.0.0
    
  3. Clique em Implantar. A implantação leva de 2 a 3 minutos.

Criar o job do Cloud Scheduler

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

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

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

Frequência Expressão Cron Caso de uso
A cada 5 minutos */5 * * * * Alto volume e baixa latência
A cada hora 0 * * * * Padrão (recomendado)
Diário 0 0 * * * Coleta em lote

Testar a integração

  1. No Cloud Scheduler, clique em Forçar execução no job.
  2. Verifique a execução nos registros do Cloud Run. Procure por: Successfully processed X audit events.
  3. Confirme se um novo arquivo json existe no bucket do Cloud Storage na pasta openidm/.

Recuperar a conta de serviço do Google SecOps

Configurar um feed no Google SecOps

  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 de notícias > Configurar um único feed de notícias.
  3. Nome do feed: ForgeRock OpenIDM Audit Logs.
  4. Tipo de origem: Google Cloud Storage V2.
  5. Tipo de registro: FORGEROCK_OPENIDM.
  6. Clique em Receber conta de serviço e copie o e-mail fornecido (por exemplo, chronicle-12345...).
  7. Clique em Próxima.
  8. URL do bucket de armazenamento: gs://forgerock-openidm-audit-logs/openidm/.
  9. Opção de exclusão da fonte: selecione de acordo com sua preferência (por exemplo, Nunca).
  10. Clique em Próxima, revise e clique em Enviar.

Conceder permissões do IAM

  1. Acesse Cloud Storage > Buckets.
  2. Selecione o bucket e clique na guia Permissões.
  3. Clique em Conceder acesso.
  4. Adicionar participantes: cole o e-mail da conta de serviço do Google SecOps.
  5. 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
fluenttag_label, topic_label, context_roles_label additional.fields Pares de chave-valor para contexto.
Via intermediary.hostname Nome do host do proxy/intermediário.
x_forwarded_ip, caller.callerIps intermediary.ip IP do intermediário.
timestamp metadata.event_timestamp Carimbo de data/hora do evento.
transactionId metadata.product_deployment_id ID da transação exclusivo.
eventName metadata.product_event_type Nome do evento da ForgeRock.
_id metadata.product_log_id Identificador de registro exclusivo.
request_method network.http.method Método HTTP usado.
response.statusCode network.http.response_code Código de status HTTP.
user_agent network.http.user_agent String completa do user agent.
client.ip, context.ipAddress principal.ip IP de origem do ator.
userId, principalData.0 principal.user.userid ID do usuário que está realizando a ação.
security_action security_result.action Decisão de segurança tomada.
level security_result.severity Nível de gravidade mapeado.
server.ip target.ip IP do sistema de destino.
http.request.path target.url URL/caminho de destino.
N/A metadata.product_name Defina como ForgeRock OpenIDM.
N/A metadata.vendor_name Defina como ForgeRock.
elapsed_time" and "X-Content-Type-Options additional.fields Mapeado do registro de alterações
trackingIds.0 metadata.product_log_id Mapeado do registro de alterações
context.userRolesProperty", "context.authenticationId", and "context.authenticationIdProperty principal.user.attribute.roles Mapeado do registro de alterações
context.component", "context.moduleId", and "context.queryId principal.resource.attribute.labels Mapeado do registro de alterações
context.roles", "_normalized.fieldNames", and "_eventId additional.fields Mapeado do registro de alterações

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.