Coletar registros de auditoria do Lucid

Compatível com:

Este documento explica como ingerir registros de auditoria do Lucid no Google Security Operations usando o Cloud Storage V2.

A Lucid Software oferece um pacote de colaboração visual que inclui o Lucidchart, o Lucidspark e o Lucidscale. A API Audit Logs, disponível exclusivamente para clientes do Enterprise Shield, captura eventos de segurança e compliance em toda a organização, incluindo acesso à conta, atividade em documentos, gerenciamento de usuários, ações de administradores e operações de equipe.

Antes de começar

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

  • Uma instância do Google SecOps
  • Um projeto do Google Cloud com a API Storage do Cloud Storage ativada.
  • Permissões para criar e gerenciar buckets do Cloud Storage
  • Permissões para gerenciar políticas do Identity and Access Management (IAM) em buckets do Cloud Storage
  • Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler
  • Uma conta do Lucid Enterprise Shield com privilégios de administrador ou proprietário da conta
  • Acesso ao Portal do Desenvolvedor da Lucid com as ferramentas para desenvolvedores ativadas.

Ativar as ferramentas para desenvolvedores no Lucid

Antes de criar credenciais de API, você precisa ter acesso ao portal do desenvolvedor da Lucid. Há duas maneiras de ativar as ferramentas para desenvolvedores:

Opção 1: ativar nas configurações do usuário

  1. Faça login em lucid.app.
  2. Clique no ícone do seu perfil no canto superior direito.
  3. Selecione Configurações da conta.
  4. Marque a caixa de seleção Ativar ferramentas para desenvolvedores.

Opção 2: ativar pela atribuição de função de administrador

  1. Faça login no lucid.app como proprietário da conta ou administrador da equipe.
  2. Acesse o painel de admin.
  3. Acesse a seção Usuários.
  4. Selecione o usuário de destino.
  5. Edite as funções do usuário e atribua a função de Desenvolvedor.

Configurar o acesso à API Lucid

Para permitir que o Google SecOps recupere registros de auditoria, crie um cliente OAuth 2.0 e gere um token de acesso no nível da conta com o escopo account.audit.logs.

Criar um aplicativo e um cliente OAuth 2.0

  1. Acesse o Portal do Desenvolvedor da Lucid.
  2. Clique em Criar aplicativo.
  3. Insira um nome para o aplicativo (por exemplo, Chronicle SIEM Integration).
  4. Clique no aplicativo recém-criado para acessar as configurações dele.
  5. Acesse a guia OAuth 2.0.
  6. Insira um nome para o cliente OAuth 2.0 (por exemplo, Chronicle Audit Log Collector).

  7. Clique em Criar cliente OAuth 2.0.

Registrar as credenciais do cliente

Depois de criar o cliente OAuth 2.0, o portal vai mostrar suas credenciais:

  • ID do cliente: seu identificador exclusivo de cliente.
  • Chave secreta do cliente: sua chave secreta da API.

Importante: copie e salve a chave secreta do cliente imediatamente. Se a chave secreta do cliente for comprometida, clique no botão Redefinir chave secreta do cliente na página de configurações do OAuth 2.0. A redefinição da chave secreta revoga imediatamente o acesso até que a nova chave seja atualizada na sua integração.

Registrar um URI de redirecionamento

  1. Na página de configurações do OAuth 2.0, clique em Adicionar URI de redirecionamento.
  2. Insira o URI de redirecionamento da sua integração. Se estiver usando o redirecionamento de teste fornecido pela Lucid, insira:

    https://lucid.app/oauth2/clients/<CLIENT_ID>/redirect
    

    Substitua <CLIENT_ID> pelo ID do cliente real.

Receber um token de acesso no nível da conta

A API Audit Logs exige um token de conta (não um token de usuário). Um administrador da conta precisa autorizar o cliente OAuth 2.0 a criar um token em nome da conta.

  1. Direcione um administrador de conta para o seguinte URL de autorização em um navegador:

    https://lucid.app/oauth2/authorizeAccount?client_id=<CLIENT_ID>&redirect_uri=<REDIRECT_URI>&scope=account.audit.logs
    

    Substitua <CLIENT_ID> e <REDIRECT_URI> pelos valores reais.

  2. O administrador analisa as permissões solicitadas na tela de permissão e clica em Permitir.

  3. O Lucid redireciona para o URI de redirecionamento com um parâmetro de consulta de autorização code.

  4. Troque o código de autorização por um token de acesso fazendo uma solicitação POST para o endpoint do token:

    curl --request POST \
      --url https://api.lucid.co/oauth2/token \
      --header 'Content-Type: application/json' \
      --data '{
        "grant_type": "authorization_code",
        "client_id": "<CLIENT_ID>",
        "client_secret": "<CLIENT_SECRET>",
        "code": "<AUTHORIZATION_CODE>",
        "redirect_uri": "<REDIRECT_URI>"
      }'
    
  5. A resposta inclui um access_token e um refresh_token. Registre os dois valores com segurança.

Verificar o acesso à API

  • Confirme se o token de acesso funciona fazendo uma solicitação de teste:

    curl --request GET \
      --url 'https://api.lucid.co/auditLogs?pageSize=1' \
      --header 'Authorization: Bearer <ACCESS_TOKEN>' \
      --header 'Lucid-Api-Version: 1' \
      --header 'Accept: application/json'
    

Uma resposta bem-sucedida retorna uma matriz JSON de eventos de registro de auditoria.

Permissões de API necessárias

  • O cliente OAuth 2.0 requer o seguinte escopo:

    Escopo Tipo de token Finalidade
    account.audit.logs Conta Recuperar eventos do registro de auditoria da conta

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, lucid-audit-logs-gcs)
    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.

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

  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: insira lucid-audit-collector-sa.
    • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Lucid audit 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.

Conceder permissões do IAM no bucket do Cloud Storage

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (lucid-audit-logs-gcs).
  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 (lucid-audit-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: insira lucid-audit-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 de auditoria da API Lucid Audit Logs e gravá-los no Cloud Storage.

  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 lucid-audit-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 Gatilho (opcional):

    1. Clique em + Adicionar gatilho.
    2. Selecione Cloud Pub/Sub.
    3. Em Selecionar um tópico do Cloud Pub/Sub, escolha lucid-audit-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 lucid-audit-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 lucid-audit-logs-gcs Nome do bucket do Cloud Storage
    GCS_PREFIX lucid-audit Prefixo para arquivos de registro
    STATE_KEY lucid-audit/state.json Caminho do arquivo de estado
    LUCID_CLIENT_ID your-oauth-client-id ID do cliente OAuth 2.0 do Lucid
    LUCID_CLIENT_SECRET your-oauth-client-secret Chave secreta do cliente OAuth 2.0 do Lucid
    LUCID_REFRESH_TOKEN your-refresh-token Token de atualização do OAuth 2.0 da Lucid
    LOOKBACK_HOURS 24 Período de lookback inicial
    PAGE_SIZE 200 Registros por página da API (máximo de 200)
    MAX_PAGES 50 Máximo de páginas por execução
  10. Na seção Variáveis e secrets, role para baixo até Solicitações:

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

    • 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.
  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 no campo Ponto de entrada.
  2. No editor de código inline, crie dois arquivos:
  • main.py:

    import functions_framework
    from google.cloud import storage
    import json
    import os
    import urllib3
    from datetime import datetime, timezone, timedelta
    import re
    
    http = urllib3.PoolManager(
        timeout=urllib3.Timeout(connect=10.0, read=60.0),
        retries=False,
    )
    
    storage_client = storage.Client()
    
    GCS_BUCKET = os.environ.get('GCS_BUCKET')
    GCS_PREFIX = os.environ.get('GCS_PREFIX', 'lucid-audit')
    STATE_KEY = os.environ.get('STATE_KEY', 'lucid-audit/state.json')
    LUCID_CLIENT_ID = os.environ.get('LUCID_CLIENT_ID')
    LUCID_CLIENT_SECRET = os.environ.get('LUCID_CLIENT_SECRET')
    LUCID_REFRESH_TOKEN = os.environ.get('LUCID_REFRESH_TOKEN')
    LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
    PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
    MAX_PAGES = int(os.environ.get('MAX_PAGES', '50'))
    
    API_BASE = 'https://api.lucid.co'
    
    @functions_framework.cloud_event
    def main(cloud_event):
        if not all([GCS_BUCKET, LUCID_CLIENT_ID, LUCID_CLIENT_SECRET, LUCID_REFRESH_TOKEN]):
            print('Error: Missing required environment variables')
            return
    
        try:
            bucket = storage_client.bucket(GCS_BUCKET)
            state = load_state(bucket)
            now = datetime.now(timezone.utc)
    
            if isinstance(state, dict) and state.get('last_event_time'):
                try:
                    last_val = state['last_event_time']
                    if last_val.endswith('Z'):
                        last_val = last_val[:-1] + '+00:00'
                    last_time = datetime.fromisoformat(last_val)
                    last_time = last_time - timedelta(minutes=2)
                except Exception as e:
                    print(f"Warning: Could not parse last_event_time: {e}")
                    last_time = now - timedelta(hours=LOOKBACK_HOURS)
            else:
                last_time = now - timedelta(hours=LOOKBACK_HOURS)
    
            print(f"Fetching audit logs from {last_time.isoformat()} to {now.isoformat()}")
    
            access_token, new_refresh_token = refresh_access_token()
    
            if new_refresh_token:
                save_refresh_token(bucket, new_refresh_token)
    
            records, newest_event_time = fetch_audit_logs(access_token, last_time, now)
    
            if not records:
                print("No new audit log records found.")
                save_state(bucket, now.isoformat())
                return
    
            timestamp = now.strftime('%Y%m%d_%H%M%S')
            object_key = f"{GCS_PREFIX}/lucid_audit_{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}")
    
            if newest_event_time:
                save_state(bucket, newest_event_time)
            else:
                save_state(bucket, now.isoformat())
    
            print(f"Successfully processed {len(records)} audit log records")
    
        except Exception as e:
            print(f'Error processing logs: {str(e)}')
            raise
    
    def refresh_access_token():
        url = f"{API_BASE}/oauth2/token"
        body = json.dumps({
            'grant_type': 'refresh_token',
            'refresh_token': LUCID_REFRESH_TOKEN,
            'client_id': LUCID_CLIENT_ID,
            'client_secret': LUCID_CLIENT_SECRET
        }).encode('utf-8')
    
        response = http.request(
            'POST', url,
            body=body,
            headers={'Content-Type': 'application/json'}
        )
    
        if response.status != 200:
            raise Exception(
                f"Token refresh failed: {response.status} - "
                f"{response.data.decode('utf-8')}"
            )
    
        data = json.loads(response.data.decode('utf-8'))
        access_token = data.get('access_token')
        new_refresh_token = data.get('refresh_token')
    
        if not access_token:
            raise Exception("No access_token in token refresh response")
    
        print("Successfully refreshed Lucid API access token")
        return access_token, new_refresh_token
    
    def fetch_audit_logs(access_token, start_time, end_time):
        records = []
        newest_time = None
        page_num = 0
        next_page_url = None
    
        since_str = start_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
        until_str = end_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
    
        while page_num < MAX_PAGES:
            page_num += 1
    
            if next_page_url:
                url = next_page_url
            else:
                url = (
                    f"{API_BASE}/auditLogs"
                    f"?pageSize={PAGE_SIZE}"
                    f"&since={since_str}"
                    f"&until={until_str}"
                )
    
            headers = {
                'Authorization': f'Bearer {access_token}',
                'Lucid-Api-Version': '1',
                'Accept': 'application/json'
            }
    
            response = http.request('GET', url, headers=headers)
    
            if response.status == 429:
                print(f"Rate limited on page {page_num}. Stopping pagination.")
                break
    
            if response.status != 200:
                print(
                    f"API error on page {page_num}: {response.status} - "
                    f"{response.data.decode('utf-8')}"
                )
                break
    
            page_results = json.loads(response.data.decode('utf-8'))
    
            if not page_results:
                print(f"No more results at page {page_num}")
                break
    
            records.extend(page_results)
            print(f"Page {page_num}: Retrieved {len(page_results)} events "
                  f"(total: {len(records)})")
    
            for event in page_results:
                try:
                    event_time = event.get('eventTimestamp')
                    if event_time:
                        if newest_time is None or event_time > newest_time:
                            newest_time = event_time
                except Exception as e:
                    print(f"Warning: Could not parse event time: {e}")
    
            link_header = response.headers.get('Link', '')
            next_page_url = parse_link_header(link_header)
    
            if not next_page_url:
                print(f"No next page link found. Pagination complete.")
                break
    
            if len(page_results) < PAGE_SIZE:
                break
    
        print(f"Total audit log records fetched: {len(records)} from {page_num} pages")
        return records, newest_time
    
    def parse_link_header(link_header):
        if not link_header:
            return None
    
        match = re.search(r'<([^>]+)>;\s*rel="next"', link_header)
        if match:
            return match.group(1)
        return None
    
    def load_state(bucket):
        try:
            blob = bucket.blob(STATE_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, last_event_time_iso):
        try:
            state = {
                'last_event_time': last_event_time_iso,
                'last_run': datetime.now(timezone.utc).isoformat()
            }
            blob = bucket.blob(STATE_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 save_refresh_token(bucket, new_refresh_token):
        try:
            token_key = f"{GCS_PREFIX}/refresh_token.json"
            blob = bucket.blob(token_key)
            blob.upload_from_string(
                json.dumps({'refresh_token': new_refresh_token}, indent=2),
                content_type='application/json'
            )
            print("Saved new refresh token to GCS")
        except Exception as e:
            print(f"Warning: Could not save refresh token: {e}")
    
  • requirements.txt:

      functions-framework==3.*
      google-cloud-storage==2.*
      urllib3>=2.0.0
      ```
    
  1. Clique em Implantar para salvar e implantar a função.
  2. Aguarde a conclusão da implantação (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 lucid-audit-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 Selecionar lucid-audit-trigger
    Corpo da mensagem {} (objeto JSON vazio)
  4. Clique em Criar.

Testar a integração

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

    Fetching audit logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
    Successfully refreshed Lucid API access token
    Page 1: Retrieved X events (total: X)
    Wrote X records to gs://lucid-audit-logs-gcs/lucid-audit/lucid_audit_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X audit log records
    
  8. Acesse Cloud Storage > Buckets.

  9. Clique em lucid-audit-logs-gcs.

  10. Navegue até a pasta lucid-audit/.

  11. Verifique se um novo arquivo .ndjson foi criado com o carimbo de data/hora atual.

Se você encontrar erros nos registros:

  • HTTP 401: verifique se as variáveis de ambiente LUCID_CLIENT_ID, LUCID_CLIENT_SECRET e LUCID_REFRESH_TOKEN estão corretas.
  • HTTP 403: verifique se o cliente OAuth 2.0 tem o escopo account.audit.logs e se o token é de conta.
  • HTTP 429: limitação de taxa. A função vai interromper a paginação e retomar na próxima execução programada.
  • Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas na configuração da função do Cloud Run.

Categorias de eventos do registro de auditoria

Os registros de auditoria do Lucid são organizados nas seguintes categorias de eventos:

Categoria Descrição
Logins Eventos associados a logins de usuários
Conteúdo Eventos associados ao acesso e à modificação de documentos e pastas
Administração Eventos associados à atividade do administrador e às mudanças na conta
User Eventos associados a ações do usuário nas configurações pessoais
Equipe Eventos associados a operações de equipe

Para ver uma lista completa dos tipos de eventos e os esquemas deles, consulte a documentação Eventos de registro de auditoria do Lucid.

Ambiente do FedRAMP

Os usuários no ambiente do Lucid FedRAMP usam endpoints de autorização e de API diferentes. Consulte a documentação do ambiente do Lucid FedRAMP para ver os URLs de endpoint corretos.

Recuperar a conta de serviço do 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.
  3. Clique em Configurar um único feed.
  4. No campo Nome do feed, insira um nome para o feed (por exemplo, Lucid Audit Logs).
  5. Selecione Google Cloud Storage V2 como o Tipo de origem.
  6. Selecione Lucid 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 esse endereço de e-mail para usar 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 Cloud Storage com o caminho do prefixo:

      gs://lucid-audit-logs-gcs/lucid-audit/
      
    • 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 no último número de dias (o padrão é 180 dias).

    • Namespace do recurso: o namespace do recurso

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

  11. Clique em Próxima.

  12. Revise a configuração do seu novo feed de notícias 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 de Leitor de objetos do Storage no bucket do Cloud Storage.

  1. Acesse Cloud Storage > Buckets.
  2. Clique em lucid-audit-logs-gcs.
  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
document_opened additional.fields Mesclado com rótulos criados de cada campo de origem, se não estiver vazio
share_link_enable additional.fields
restricted_account_enable additional.fields
event1.documentIds additional.fields
team_folder additional.fields
method_type additional.fields
extensions.auth.type extensions.auth.type Defina como "AUTHTYPE_UNSPECIFIED" para eventos de login/logout.
eventTimestamp metadata.event_timestamp Convertido usando a correspondência de data ISO8601 ou yyyy-MM-ddTHH:mm:ss.SSSSSSZ
has_user_login metadata.event_type Definido com base nas flags has_*: USER_LOGIN se has_user_login e has_target_user, USER_LOGOUT se has_user_logout e has_target_user, USER_RESOURCE_UPDATE_CONTENT se has_user_resource_updated, has_target_resource e has_principal_user, USER_CREATION se has_principal_user, has_target_application e has_target_user, USER_RESOURCE_CREATION se has_target_resource e has_principal_user, FILE_CREATION se has_target_file, has_principal e has_target, USER_RESOURCE_ACCESS se has_target_resource, USER_COMMUNICATION se has_principal_user, STATUS_UPDATE se has_principal e has_target forem falsos, caso contrário, GENERIC_EVENT
has_user_logout metadata.event_type
has_user_resource_updated metadata.event_type
has_principal_user metadata.event_type
has_target_resource metadata.event_type
has_target_file metadata.event_type
has_principal metadata.event_type
has_target_user metadata.event_type
has_target_application metadata.event_type
has_target metadata.event_type
event1.event1Type metadata.product_event_type Valor copiado diretamente
actor.actorIp principal.asset.ip Valor copiado diretamente se não estiver vazio
actor.actorIp principal.ip Valor copiado diretamente se não estiver vazio
actor.actorAccountId principal.resource.id Valor copiado diretamente se não estiver vazio
actor.actorClient principal.resource.name Valor copiado diretamente se não estiver vazio
flowId principal.resource.product_object_id Valor copiado diretamente se não estiver vazio
actor.actorType principal.user.attribute.roles Mesclado de actor_type se eventType não for login/logout e actor_type não estiver vazio
actor.actorEmail principal.user.email_addresses Mesclado se actor_email não estiver vazio e for um e-mail válido, e eventType não for login/logout
actor.actorUserId principal.user.userid Valor copiado diretamente se não estiver vazio e o eventType não for login/logout
event1.registrationMethod security_result.description Valor copiado diretamente se não estiver vazio
event1.source target.application Valor copiado diretamente se não estiver vazio
event1.publishedLink.link target.file.full_path Valor copiado diretamente se não estiver vazio
event1.filename target.file.names Mesclado se não estiver vazio
targetData._targetType target.resource.attribute.labels Mesclado com rótulos criados de cada campo de origem, se não estiver vazio
targetData._targetId target.resource.attribute.labels
event1.format target.resource.attribute.labels
event1.method target.resource.attribute.labels
event1.publishedLink.format target.resource.attribute.labels
accountId target.resource.id Valor copiado diretamente se não estiver vazio
event1.destinationFolderName target.resource.name Defina como destinationFolderName se não estiver vazio, caso contrário, como folderName se não estiver vazio, caso contrário, como publishedLink.name se não estiver vazio
event1.folderName target.resource.name
event1.publishedLink.name target.resource.name
event1.documentId target.resource.product_object_id Valor copiado diretamente se não estiver vazio
actor.actorType target.user.attribute.roles Mesclado de actor_type se eventType for login/logout e de event_role se não estiver vazio
event1.role target.user.attribute.roles
actor.actorEmail target.user.email_addresses Mesclado de actor_email se login/logout e válido, e de userEmail em _target
targetData.userEmail target.user.email_addresses
event1.destinationFolderId target.user.product_object_id Definido como destinationFolderId se não estiver vazio, caso contrário, folderId se não estiver vazio
event1.folderId target.user.product_object_id
targetData.displayName target.user.user_display_name Valor copiado diretamente se não estiver vazio
actor.actorUserId target.user.userid Valor copiado diretamente se não estiver vazio e eventType for login/logout
event1.product metadata.product_name Valor do produto, se não estiver vazio. Caso contrário, "LUCID"
metadata.vendor_name metadata.vendor_name Defina como "LUCID".

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.