Coletar registros de auditoria do Tenable
Neste documento, explicamos como ingerir registros de auditoria do Tenable no Google Security Operations usando o Cloud Storage V2.
O Tenable Vulnerability Management (antigo Tenable.io) é uma plataforma de gestão de vulnerabilidades baseada na nuvem (cloud.tenable.com) que registra autenticações de usuários, acessos à API, mudanças de configuração e ações administrativas em um registro de atividades. A API REST da Tenable Gestão de Vulnerabilidades oferece acesso programático a esses eventos de registro de atividades.
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
- Acesso privilegiado ao Tenable Gestão de Vulnerabilidades (cloud.tenable.com) com o papel de Administrador.
- Chaves de API do Tenable Vulnerability Management (chave de acesso e chave secreta) geradas em uma conta de usuário com o papel de Administrador
Criar um bucket do Cloud Storage
- Acesse o Console do Google Cloud.
- Selecione seu projeto ou crie um novo.
- No menu de navegação, acesse Cloud Storage > Buckets.
- Clique em Criar bucket.
Informe os seguintes detalhes de configuração:
Configuração Valor Nomeie seu bucket Insira um nome globalmente exclusivo (por exemplo, tenable-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 Clique em Criar.
Coletar credenciais da API Tenable de gestão de vulnerabilidades
Gerar chaves de API
- Faça login no Tenable Vulnerability Management.
- No canto superior direito de qualquer página, clique no círculo azul do usuário e em Meu perfil. A página Minha conta é exibida.
- Acesse a guia Chaves de API.
Clique em Gerar. A janela Gerar chaves de API aparece com um aviso.
"Atenção: a geração de chaves substitui as chaves de API existentes nessa conta de usuário, incluindo as que já são usadas por outras integrações. Use uma conta de usuário dedicada para essa integração ou atualize todos os aplicativos que usavam as chaves anteriores."
Leia o aviso e clique em Gerar.
Copie e salve os seguintes detalhes em um local seguro:
- Chave de acesso: a chave de acesso da API.
- Chave secreta: a chave secreta da API.
Verificar o acesso à API
Teste suas credenciais antes de prosseguir com a integração:
# Replace with your actual credentials ACCESS_KEY="your-access-key" SECRET_KEY="your-secret-key" curl -s -H "X-ApiKeys: accessKey=${ACCESS_KEY};secretKey=${SECRET_KEY}" \ "https://cloud.tenable.com/audit-log/v1/events?limit=1" | head -c 500
Verifique as permissões
Para verificar se a conta tem as permissões necessárias:
- Faça login no Tenable Vulnerability Management.
- No menu de navegação à esquerda, clique em Configurações.
- Clique no bloco Controle de acesso.
- Clique na guia Usuários e, em seguida, na conta de usuário usada para essa integração.
Verifique se a conta tem a função de Administrador. O endpoint do registro de atividades exige a função do usuário Administrador: nenhuma função personalizada concede acesso ao registro de atividades, e qualquer outra função recebe uma resposta HTTP 403.
Se você não tiver as permissões necessárias, entre em contato com o administrador do Tenable Vulnerability Management.
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 a conta de serviço
- No Console do GCP, acesse IAM e administrador > Contas de serviço.
- Clique em Criar conta de serviço.
- Informe os seguintes detalhes de configuração:
- Nome da conta de serviço: insira
tenable-audit-collector-sa. - Descrição da conta de serviço: insira
Service account for Cloud Run function to collect Tenable Audit logs.
- Nome da conta de serviço: insira
- Clique em Criar e continuar.
- Na seção Conceder acesso a essa conta de serviço ao projeto, adicione os seguintes papéis:
- Clique em Selecionar papel.
- Pesquise e selecione Administrador de objetos do Storage.
- Clique em + Adicionar outro papel.
- Pesquise e selecione Invocador do Cloud Run.
- Clique em + Adicionar outro papel.
- Pesquise e selecione Invocador do Cloud Functions.
- Clique em Continuar.
- Clique em Concluído.
Esses papéis são necessários para:
- Administrador de objetos do Storage: grava registros no bucket do Cloud Storage e gerencia 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 Cloud Storage
Conceda à conta de serviço permissões de gravação no bucket do Cloud Storage:
- Acesse Cloud Storage > Buckets.
- Clique no nome do bucket (por exemplo,
tenable-audit-logs). - Acesse a guia Permissões.
- Clique em Conceder acesso.
- Informe os seguintes detalhes de configuração:
- Adicionar principais: insira o e-mail da conta de serviço (por exemplo,
tenable-audit-collector-sa@PROJECT_ID.iam.gserviceaccount.com) - Atribuir papéis: selecione Administrador de objetos do Storage.
- Adicionar principais: insira o e-mail da conta de serviço (por exemplo,
- Clique em Salvar.
Criar um tópico do 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.
- No Console do GCP, acesse Pub/Sub > Tópicos.
- Selecione Criar tópico.
- Informe os seguintes detalhes de configuração:
- ID do tópico: insira
tenable-audit-trigger. - Não mude as outras configurações.
- ID do tópico: insira
- 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 REST do Tenable Gestão de Vulnerabilidades e gravá-los no Cloud Storage.
- No Console do GCP, acesse o Cloud Run.
- Clique em Criar serviço.
- Selecione Função (use um editor in-line para criar uma função).
Na seção Configurar, forneça os seguintes detalhes de configuração:
Configuração Valor Nome do serviço tenable-audit-collectorRegiã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. Na seção Acionador (opcional):
- Clique em + Adicionar gatilho.
- Selecione Cloud Pub/Sub.
- Em Selecionar um tópico do Cloud Pub/Sub, escolha o tópico
tenable-audit-trigger. - Clique em Salvar.
Na seção Autenticação:
- Selecione Exigir autenticação.
- Verifique o Identity and Access Management (IAM).
Role para baixo e abra Contêineres, rede, segurança.
Acesse a guia Segurança:
- Conta de serviço: selecione a conta de serviço
tenable-audit-collector-sa.
- Conta de serviço: selecione a conta de serviço
Acesse a guia Contêineres:
- Clique em Variáveis e secrets.
- Clique em + Adicionar variável para cada variável de ambiente:
Nome da variável Valor de exemplo Descrição GCS_BUCKETtenable-audit-logsNome do bucket do Cloud Storage GCS_PREFIXtenablePrefixo para arquivos de registro STATE_KEYtenable-state.jsonCaminho do estado, fora do prefixo do registro TENABLE_ACCESS_KEYyour-access-keyChave de acesso do Tenable Gestão de Vulnerabilidades TENABLE_SECRET_KEYyour-secret-keyChave secreta do Tenable Gestão de Vulnerabilidades MAX_RECORDS5000Máximo de registros por execução PAGE_SIZE1000Registros por página LOOKBACK_HOURS24Período de lookback inicial OVERLAP_MINUTES2Minutos relidos antes da marca-d'água para capturar eventos indexados com atraso Na seção Variáveis e secrets, acesse Solicitações:
- Tempo limite da solicitação: insira
600segundos (10 minutos)
- Tempo limite da solicitação: insira
Acesse a guia Configurações:
- Na seção Recursos:
- Memória: selecione 512 MiB ou mais.
- CPU: selecione 1.
- Na seção Recursos:
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)
- Número mínimo de instâncias: insira
Clique em Criar.
Aguarde a criação do serviço (1 a 2 minutos).
Depois que o serviço for criado, o editor de código inline será aberto automaticamente.
Adicionar o código da função
- Insira main no campo Ponto de entrada.
No editor de código inline, crie dois arquivos:
- Primeiro arquivo: main.py:
import functions_framework from google.cloud import storage from google.cloud.exceptions import NotFound import json import os import re 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', 'tenable') # STATE_KEY must stay OUTSIDE GCS_PREFIX. The feed ingests every object under # its bucket URI and, with a deletion option selected, deletes what it # transferred. A state file inside the prefix would be ingested as log data and # then deleted, resetting collection and re-ingesting duplicates. STATE_KEY = os.environ.get('STATE_KEY', 'tenable-state.json') TENABLE_ACCESS_KEY = os.environ.get('TENABLE_ACCESS_KEY') TENABLE_SECRET_KEY = os.environ.get('TENABLE_SECRET_KEY') MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000')) # The audit-log API accepts a limit up to 10000. PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000')) LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24')) # The query re-reads this many minutes before the watermark so that events # Tenable indexes late are still collected. Re-read events are dropped by id. OVERLAP_MINUTES = int(os.environ.get('OVERLAP_MINUTES', '2')) TENABLE_API_BASE = 'https://cloud.tenable.com' class FetchError(Exception): """Raised when the Tenable API call fails. The watermark must never advance on a failed fetch, otherwise every event in the failed window is skipped permanently. """ def parse_datetime(value: str) -> datetime: """Parse a Tenable `received` timestamp into an aware datetime. Tenable returns ISO 8601 with either whole seconds (2018-12-31T23:09:40Z) or fractional seconds (2024-01-16T15:12:47.334Z). Fractional digits are trimmed to microseconds because fromisoformat accepts at most six. """ text = str(value).strip() if text.endswith('Z'): text = text[:-1] + '+00:00' text = re.sub(r'\.(\d{6})\d+', r'.\1', text) dt = datetime.fromisoformat(text) if dt.tzinfo is None: dt = dt.replace(tzinfo=timezone.utc) return dt.astimezone(timezone.utc) @functions_framework.cloud_event def main(cloud_event): """Fetch Tenable Vulnerability Management activity log events and write them to Cloud Storage. Args: cloud_event: CloudEvent object containing the Pub/Sub message. """ if not all([GCS_BUCKET, TENABLE_ACCESS_KEY, TENABLE_SECRET_KEY]): # Raise rather than return: a bare return acks the Pub/Sub message and # reports the run as successful, silently discarding the schedule tick. raise RuntimeError('Missing required environment variables') bucket = storage_client.bucket(GCS_BUCKET) state = load_state(bucket, STATE_KEY) now = datetime.now(timezone.utc) watermark = None if state.get('last_event_time'): watermark = parse_datetime(state['last_event_time']) seen_ids = set(state.get('seen_ids', [])) if watermark is None: start_time = now - timedelta(hours=LOOKBACK_HOURS) else: start_time = watermark - timedelta(minutes=OVERLAP_MINUTES) print(f"Fetching logs from {start_time.isoformat()} to {now.isoformat()}") # A FetchError propagates: the run fails, the watermark is untouched, and the # next invocation retries the same window. records, newest_event_time = fetch_logs( start_time=start_time, page_size=PAGE_SIZE, max_records=MAX_RECORDS, ) # Drop events already written by an earlier run. Without this the overlap # window re-emits its events on every invocation, and an idle tenant has its # newest events rewritten to a new object every hour. fresh = [r for r in records if str(r.get('id', '')) not in seen_ids] print(f"Fetched {len(records)} records, {len(fresh)} new after deduplication") if not fresh: print("No new log records found. Watermark left unchanged.") return if not newest_event_time: raise FetchError('Records were returned but no `received` timestamp could be parsed') timestamp = now.strftime('%Y%m%dT%H%M%SZ') 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 fresh) + '\n' blob.upload_from_string(ndjson, content_type='application/x-ndjson') print(f"Wrote {len(fresh)} records to gs://{GCS_BUCKET}/{object_key}") # Advance the watermark only after the data is durably written. new_watermark = parse_datetime(newest_event_time) if watermark and new_watermark < watermark: new_watermark = watermark # Retain only the ids still inside the overlap window, so the state file # stays small while covering every event the next query can re-read. cutoff = new_watermark - timedelta(minutes=OVERLAP_MINUTES) retained = [] for record in records: received = record.get('received') if not received: continue try: if parse_datetime(received) >= cutoff: retained.append(str(record.get('id', ''))) except ValueError: continue save_state(bucket, STATE_KEY, { 'last_event_time': new_watermark.isoformat(), 'seen_ids': sorted(i for i in set(retained) if i), }) print(f"Successfully processed {len(fresh)} records") def load_state(bucket, key): """Read the collector state from Cloud Storage. Only a missing object is treated as a cold start. Any other error is raised: swallowing it would silently reset collection to the full lookback window and re-ingest that entire period. """ blob = bucket.blob(key) try: return json.loads(blob.download_as_text()) except NotFound: print('No state file found. Starting from the lookback window.') return {} def save_state(bucket, key, state: dict): """Write the collector state to Cloud Storage. Failures are raised, not logged. If the state write fails after the data was uploaded, the next run repeats the same window and duplicates it. """ blob = bucket.blob(key) blob.upload_from_string( json.dumps(state, indent=2), content_type='application/json', ) print(f"Saved state: last_event_time={state.get('last_event_time')}") def fetch_logs(start_time: datetime, page_size: int, max_records: int): """Fetch audit events from the Tenable Vulnerability Management API. Uses offset pagination, which is what the endpoint documents: the request accepts `limit` (maximum 10000) and `offset`, and the response `pagination` object returns `offset`, `limit`, `count` and `total`. Args: start_time: Exclusive lower bound for the `received` timestamp page_size: Records per page (the API accepts up to 10000) max_records: Maximum total records to fetch in one run Returns: Tuple of (records list, newest `received` value as an ISO 8601 string). Raises: FetchError: on any API or transport failure, so the caller cannot mistake a failed fetch for an empty result and advance the watermark. """ endpoint = f"{TENABLE_API_BASE}/audit-log/v1/events" headers = { 'X-ApiKeys': f'accessKey={TENABLE_ACCESS_KEY};secretKey={TENABLE_SECRET_KEY}', 'Accept': 'application/json', 'User-Agent': 'GoogleSecOps-TenableAuditCollector/1.0' } records = [] newest_time = None page_num = 0 backoff = 1.0 rate_limit_retries = 0 MAX_RATE_LIMIT_RETRIES = 5 offset = 0 while True: page_num += 1 if len(records) >= max_records: # Stop cleanly. The remaining events stay ahead of the watermark and # are collected by the next run. print(f"Reached max_records limit ({max_records})") break # Every parameter is rebuilt per page. `sort=received:asc` is required: # a time watermark is only correct over an ascending scan, otherwise a # truncated run advances the watermark past events it never read. params = { 'f': f'date.gt:{start_time.strftime("%Y-%m-%dT%H:%M:%SZ")}', 'sort': 'received:asc', 'limit': min(page_size, max_records - len(records)), 'offset': offset, } url = f"{endpoint}?" + '&'.join(f"{k}={v}" for k, v in params.items()) try: response = http.request('GET', url, headers=headers) except Exception as e: raise FetchError(f'Request to {endpoint} failed: {e}') from e if response.status == 429: rate_limit_retries += 1 if rate_limit_retries > MAX_RATE_LIMIT_RETRIES: raise FetchError('Rate limited repeatedly; giving up without advancing the watermark') raw_retry_after = response.headers.get('Retry-After') try: # Retry-After may also be an HTTP date, which int() cannot parse. retry_after = int(raw_retry_after) if raw_retry_after else int(backoff) except (TypeError, ValueError): retry_after = 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 rate_limit_retries = 0 if response.status != 200: body = response.data.decode('utf-8') raise FetchError(f'HTTP {response.status} from the Tenable audit log API: {body}') try: data = json.loads(response.data.decode('utf-8')) except json.JSONDecodeError as e: raise FetchError(f'Malformed JSON response from the Tenable audit log API: {e}') from e page_results = data.get('events', []) if not page_results: print("No more results (empty page)") break print(f"Page {page_num}: Retrieved {len(page_results)} events") records.extend(page_results) for event in page_results: received = event.get('received') if not received: continue try: if newest_time is None or parse_datetime(received) > parse_datetime(newest_time): newest_time = received except ValueError as e: print(f"Warning: Could not parse event time {received!r}: {e}") offset += len(page_results) total = data.get('pagination', {}).get('total') if total is not None and offset >= total: print("No more pages (all matching events retrieved)") break print(f"Retrieved {len(records)} total records from {page_num} pages") return records, newest_time- Segundo arquivo: requirements.txt:
functions-framework==3.* google-cloud-storage==2.* urllib3>=2.0.0Clique em Implantar para salvar e implantar a função.
Aguarde a conclusão da implantação (2 a 3 minutos).
Criar um 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.
- No Console do GCP, acesse o Cloud Scheduler.
- Clique em Criar job.
Informe os seguintes detalhes de configuração:
Configuração Valor Nome tenable-audit-collector-hourlyRegiã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 tenable-audit-trigger.Corpo da mensagem {}(objeto JSON vazio)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
- No console do Cloud Scheduler, encontre seu job.
- Clique em Forçar execução para acionar o job manualmente.
- Aguarde alguns segundos.
- Acesse Cloud Run > Serviços.
- Clique em
tenable-audit-collector. - Clique na guia Registros.
Verifique se a função foi executada com sucesso. Procure por:
Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00 Page 1: Retrieved X events Fetched X records, Y new after deduplication Wrote Y records to gs://tenable-audit-logs/tenable/logs_YYYYMMDDTHHMMSSZ.ndjson Saved state: last_event_time=YYYY-MM-DDTHH:MM:SS+00:00 Successfully processed Y recordsAcesse Cloud Storage > Buckets.
Clique no nome do bucket (
tenable-audit-logs).Navegue até a pasta
tenable/.Verifique se um novo arquivo
.ndjsonfoi criado com o carimbo de data/hora atual.
Em uma execução em que nada de novo chegou, a função registra No new log records found. Watermark left unchanged. e não grava nenhum objeto. Isso é esperado: reescrever os mesmos eventos os duplicaria no Google SecOps.
Se você encontrar erros nos registros:
- HTTP 401: verifique as chaves de API nas variáveis de ambiente.
- HTTP 403: a conta não é de administrador. O endpoint do registro de atividades requer a função do usuário Administrador [64].
- HTTP 429: limitação de taxa. A função tenta novamente com espera e, em seguida, falha na execução sem avançar a marca-d'água, para que nenhum evento seja ignorado.
- Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas.
Configurar um feed no Google SecOps para ingerir registros de auditoria do Tenable
- Acesse Configurações > Gerenciamento de dados > Feeds. Se você estiver em uma plataforma somente SIEM, acesse Configurações > Feeds.
- Clique em Adicionar novo feed.
- Clique em Configurar um único feed.
- No campo Nome do feed, insira um nome para o feed (por exemplo,
Tenable Audit Logs). - Selecione Google Cloud Storage V2 como o Tipo de origem.
- Selecione Auditoria do Tenable como o Tipo de registro.
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.comCopie o endereço de e-mail.
Clique em Próxima.
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://tenable-audit-logs/tenable/- Substitua:
tenable-audit-logs: o nome do bucket do Cloud Storage.tenable: prefixo/caminho de pasta opcional em que os registros são armazenados (deixe em branco para a raiz).
- Substitua:
Opção de exclusão da fonte: selecione a opção de exclusão de acordo com sua preferência:
- Nunca excluir arquivos: nunca exclua arquivos da origem (recomendado para testes).
Excluir arquivos transferidos e diretórios vazios: exclua arquivos e diretórios vazios da origem após a conclusão de uma busca.
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 que será aplicado aos eventos desse feed.
Clique em Próxima.
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 de dois papéis no bucket do Cloud Storage: Leitor de objetos do Storage para ler os objetos de registro e um papel no nível do bucket para ler os metadados do bucket.
- Acesse Cloud Storage > Buckets.
- Clique no nome do bucket.
- Acesse a guia Permissões.
- Clique em Conceder acesso.
- Informe os seguintes detalhes de configuração:
- Adicionar participantes: cole o e-mail da conta de serviço do Google SecOps.
- Atribuir papéis: selecione as duas opções a seguir:
- Leitor de objetos do Storage: lê os objetos de registro.
- Leitor de bucket legado do Storage: lê os metadados do bucket. Se você selecionou a opção de exclusão Excluir arquivos transferidos e diretórios vazios, selecione Gravador de bucket legado do Storage, que também concede a permissão de exclusão.
- Clique em Salvar.
Tabela de mapeamento de UDM
| Campo de registro | Mapeamento de UDM | Lógica |
|---|---|---|
crud_label |
additional.fields |
Mesclado |
fields_label |
additional.fields |
Mesclado |
field_name |
extensions.auth.mechanism |
Mapeado: X-Access-Type → mech_label |
mech_label |
extensions.auth.mechanism |
Mesclado |
extension_value |
extensions.auth.type |
Mapeado diretamente |
description |
metadata.description |
Mapeado diretamente |
received |
metadata.event_timestamp |
Analisado como ISO8601 |
has_principal |
metadata.event_type |
Valores mapeados (5 no total, por exemplo, true → USER_LOGIN, true → USER_CREATION, true → `USER... |
has_user |
metadata.event_type |
Mapeado: true → USER_UNCATEGORIZED |
action |
metadata.product_event_type |
Mapeado diretamente |
id |
metadata.product_log_id |
Mapeado diretamente |
field_name |
principal.asset.ip |
Mapeado: X-Forwarded-For → ip |
ip |
principal.asset.ip |
Mesclado |
field_name |
principal.ip |
Mapeado: X-Forwarded-For → ip |
ip |
principal.ip |
Mesclado |
actor.name |
principal.user.email_addresses |
Mesclado |
actor.id |
principal.user.userid |
Mapeado diretamente |
AUTH_VIOLOATION |
security_result.category |
Mesclado |
is_failure |
security_result.category |
Mapeado: true → AUTH_VIOLOATION |
is_anonymous_label |
security_result.detection_fields |
Mesclado |
is_failure_label |
security_result.detection_fields |
Mesclado |
target1.name |
target.user.email_addresses |
Mesclado |
target1.type |
target.user.role_name |
Mapeado diretamente |
target1.id |
target.user.userid |
Mapeado diretamente |
| N/A | extensions.auth.type |
Constante: AUTHTYPE_UNSPECIFIED |
| N/A | metadata.event_type |
Constante: USER_LOGIN |
| N/A | metadata.product_name |
Constante: TENABLE AUDIT |
| N/A | metadata.vendor_name |
Constante: TENABLE |
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.