Esta página foi traduzida pela API Cloud Translation.

Coletar registros do CrowdStrike FileVantage

Compatível com:

Google SecOps SIEM

Este documento explica como ingerir registros do CrowdStrike FileVantage no Google Security Operations usando o Amazon S3.

Antes de começar

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

Uma instância do Google SecOps.
Acesso privilegiado ao console do CrowdStrike Falcon.
Acesso privilegiado à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Coletar pré-requisitos do CrowdStrike FileVantage (credenciais da API)

Faça login no CrowdStrike Falcon Console (em inglês).
Acesse Suporte e recursos > Clientes e chaves de API.
Clique em Adicionar novo cliente de API.
Informe os seguintes detalhes de configuração:
- Nome do cliente: insira um nome descritivo (por exemplo, Google SecOps FileVantage Integration).
- Descrição: insira uma breve descrição da finalidade da integração.
- Escopos da API: selecione Falcon FileVantage:read.
Clique em Adicionar para concluir o processo.
Copie e salve em um local seguro os seguintes detalhes:
- ID do cliente
- Client Secret
- URL de base (determina sua região da nuvem)

Configurar o bucket do AWS S3 e o IAM para o Google SecOps

Crie um bucket do Amazon S3 seguindo este guia do usuário: Como criar um bucket
Salve o Nome e a Região do bucket para referência futura (por exemplo, crowdstrike-filevantage-logs).
Crie um usuário seguindo este guia: Como criar um usuário do IAM.
Selecione o usuário criado.
Selecione a guia Credenciais de segurança.
Clique em Criar chave de acesso na seção Chaves de acesso.
Selecione Serviço de terceiros como Caso de uso.
Clique em Próxima.
Opcional: adicione uma tag de descrição.
Clique em Criar chave de acesso.
Clique em Fazer o download do arquivo .CSV para salvar a chave de acesso e a chave de acesso secreta para referência futura.
Clique em Concluído.
Selecione a guia Permissões.
Clique em Adicionar permissões na seção Políticas de permissões.
Selecione Adicionar permissões.
Selecione Anexar políticas diretamente.
Pesquise a política AmazonS3FullAccess.
Selecione a política.
Clique em Próxima.
Clique em Adicionar permissões

Configurar a política e o papel do IAM para uploads do S3

No console da AWS, acesse IAM > Políticas.
Clique em Criar política > guia JSON.
Copie e cole a política a seguir.

JSON da política (substitua crowdstrike-filevantage-logs se você tiver inserido um nome de bucket diferente):

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

Clique em Próxima > Criar política.
Acesse IAM > Funções > Criar função > Serviço da AWS > Lambda.
Anexe a política recém-criada.
Nomeie a função como CrowdStrikeFileVantageRole e clique em Criar função.

Criar a função Lambda

No console da AWS, acesse Lambda > Functions > Create function.
Clique em Criar do zero.
Informe os seguintes detalhes de configuração:

Configuração Valor

Nome crowdstrike-filevantage-logs

Ambiente de execução Python 3.13

Arquitetura x86_64

Função de execução CrowdStrikeFileVantageRole

Configuração	Valor
Nome	`crowdstrike-filevantage-logs`
Ambiente de execução	Python 3.13
Arquitetura	x86_64
Função de execução	`CrowdStrikeFileVantageRole`

Depois que a função for criada, abra a guia Código, exclua o stub e cole o código a seguir (crowdstrike-filevantage-logs.py).

import os
import json
import boto3
import urllib3
from datetime import datetime, timezone
from urllib.parse import urlencode

def lambda_handler(event, context):
    """
    Lambda function to fetch CrowdStrike FileVantage logs and store them in S3
    """

    # Environment variables
    s3_bucket = os.environ['S3_BUCKET']
    s3_prefix = os.environ['S3_PREFIX']
    state_key = os.environ['STATE_KEY']
    client_id = os.environ['FALCON_CLIENT_ID']
    client_secret = os.environ['FALCON_CLIENT_SECRET']
    base_url = os.environ['FALCON_BASE_URL']

    # Initialize clients
    s3_client = boto3.client('s3')
    http = urllib3.PoolManager()

    try:
        # Get OAuth token
        token_url = f"{base_url}/oauth2/token"
        token_headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Accept': 'application/json'
        }
        token_data = urlencode({
            'client_id': client_id,
            'client_secret': client_secret,
            'grant_type': 'client_credentials'
        })

        token_response = http.request('POST', token_url, body=token_data, headers=token_headers)

        if token_response.status != 200:
            print(f"Failed to get OAuth token: {token_response.status}")
            return {'statusCode': 500, 'body': 'Authentication failed'}

        token_data = json.loads(token_response.data.decode('utf-8'))
        access_token = token_data['access_token']

        # Get last checkpoint
        last_timestamp = get_last_checkpoint(s3_client, s3_bucket, state_key)

        # Fetch file changes
        changes_url = f"{base_url}/filevantage/queries/changes/v1"
        headers = {
            'Authorization': f'Bearer {access_token}',
            'Accept': 'application/json'
        }

        # Build query parameters
        params = {
            'limit': 500,
            'sort': 'action_timestamp.asc'
        }

        if last_timestamp:
            params['filter'] = f"action_timestamp:>'{last_timestamp}'"

        query_url = f"{changes_url}?{urlencode(params)}"
        response = http.request('GET', query_url, headers=headers)

        if response.status != 200:
            print(f"Failed to query changes: {response.status}")
            return {'statusCode': 500, 'body': 'Failed to fetch changes'}

        response_data = json.loads(response.data.decode('utf-8'))
        change_ids = response_data.get('resources', [])

        if not change_ids:
            print("No new changes found")
            return {'statusCode': 200, 'body': 'No new changes'}

        # Get detailed change information
        details_url = f"{base_url}/filevantage/entities/changes/v1"
        batch_size = 100
        all_changes = []
        latest_timestamp = last_timestamp

        for i in range(0, len(change_ids), batch_size):
            batch_ids = change_ids[i:i + batch_size]
            details_params = {'ids': batch_ids}
            details_query_url = f"{details_url}?{urlencode(details_params, doseq=True)}"

            details_response = http.request('GET', details_query_url, headers=headers)

            if details_response.status == 200:
                details_data = json.loads(details_response.data.decode('utf-8'))
                changes = details_data.get('resources', [])
                all_changes.extend(changes)

                # Track latest timestamp
                for change in changes:
                    change_time = change.get('action_timestamp')
                    if change_time and (not latest_timestamp or change_time > latest_timestamp):
                        latest_timestamp = change_time

        if all_changes:
            # Store logs in S3
            timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
            s3_key = f"{s3_prefix}filevantage_changes_{timestamp}.json"

            s3_client.put_object(
                Bucket=s3_bucket,
                Key=s3_key,
                Body='\n'.join(json.dumps(change) for change in all_changes),
                ContentType='application/json'
            )

            # Update checkpoint
            save_checkpoint(s3_client, s3_bucket, state_key, latest_timestamp)

            print(f"Stored {len(all_changes)} changes in S3: {s3_key}")

        return {
            'statusCode': 200,
            'body': f'Processed {len(all_changes)} changes'
        }

    except Exception as e:
        print(f"Error: {str(e)}")
        return {'statusCode': 500, 'body': f'Error: {str(e)}'}

def get_last_checkpoint(s3_client, bucket, key):
    """Get the last processed timestamp from S3 state file"""
    try:
        response = s3_client.get_object(Bucket=bucket, Key=key)
        state = json.loads(response['Body'].read().decode('utf-8'))
        return state.get('last_timestamp')
    except s3_client.exceptions.NoSuchKey:
        return None
    except Exception as e:
        print(f"Error reading checkpoint: {e}")
        return None

def save_checkpoint(s3_client, bucket, key, timestamp):
    """Save the last processed timestamp to S3 state file"""
    try:
        state = {
            'last_timestamp': timestamp,
            'updated_at': datetime.now(timezone.utc).isoformat()
        }
        s3_client.put_object(
            Bucket=bucket,
            Key=key,
            Body=json.dumps(state),
            ContentType='application/json'
        )
    except Exception as e:
        print(f"Error saving checkpoint: {e}")

Acesse Configuração > Variáveis de ambiente.
Clique em Editar > Adicionar nova variável de ambiente.

Insira as variáveis de ambiente fornecidas na tabela a seguir, substituindo os valores de exemplo pelos seus.

Variáveis de ambiente

Chave	Valor de exemplo
`S3_BUCKET`	`crowdstrike-filevantage-logs`
`S3_PREFIX`	`filevantage/`
`STATE_KEY`	`filevantage/state.json`
`FALCON_CLIENT_ID`	`<your-client-id>`
`FALCON_CLIENT_SECRET`	`<your-client-secret>`
`FALCON_BASE_URL`	`https://api.crowdstrike.com` (US-1) / `https://api.us-2.crowdstrike.com` (US-2) / `https://api.eu-1.crowdstrike.com` (EU-1)

Depois que a função for criada, permaneça na página dela ou abra Lambda > Functions > sua-função.
Selecione a guia Configuração.
No painel Configuração geral, clique em Editar.
Mude Tempo limite para 5 minutos (300 segundos) e clique em Salvar.

Observação: o tempo limite é um limite superior fixo. Isso significa que, se a função ainda estiver em execução quando o timer atingir 5 minutos, o AWS Lambda vai encerrá-la. Execuções mais curtas terminam normalmente, e você só recebe cobranças pelo tempo de execução real.

Criar uma programação do EventBridge

Acesse Amazon EventBridge > Scheduler > Criar programação.
Informe os seguintes detalhes de configuração:
- Programação recorrente: Taxa (1 hour).
- Destino: sua função Lambda crowdstrike-filevantage-logs.
- Nome: crowdstrike-filevantage-logs-1h.
Clique em Criar programação.

(Opcional) Criar um usuário e chaves do IAM somente leitura para o Google SecOps

Acesse Console da AWS > IAM > Usuários.
Clique em Add users.
Informe os seguintes detalhes de configuração:
- Usuário: insira secops-reader.
- Tipo de acesso: selecione Chave de acesso – Acesso programático.
Clique em Criar usuário.
Anexe a política de leitura mínima (personalizada): Usuários > secops-reader > Permissões > Adicionar permissões > Anexar políticas diretamente > Criar política.

JSON:

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

Name = secops-reader-policy.
Clique em Criar política > pesquisar/selecionar > Próxima > Adicionar permissões.
Crie uma chave de acesso para secops-reader: Credenciais de segurança > Chaves de acesso.
Clique em Criar chave de acesso.
Faça o download do .CSV. Cole esses valores no feed.

Configurar um feed no Google SecOps para ingerir registros do CrowdStrike FileVantage

Acesse Configurações do SIEM > Feeds.
Clique em + Adicionar novo feed.
No campo Nome do feed, insira um nome para o feed (por exemplo, CrowdStrike FileVantage logs).
Selecione Amazon S3 V2 como o Tipo de origem.
Selecione CrowdStrike Filevantage como o Tipo de registro.
Clique em Próxima.
Especifique valores para os seguintes parâmetros de entrada:
- URI do S3: s3://crowdstrike-filevantage-logs/filevantage/
- Opções de exclusão de fontes: selecione a opção de exclusão de acordo com sua preferência.
- Idade máxima do arquivo: inclui arquivos modificados no último número de dias. O padrão é de 180 dias.
- ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3.
- Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3.
- Namespace do recurso: o namespace do recurso.
- Rótulos de ingestão: o rótulo aplicado aos eventos deste feed.
Clique em Próxima.
Revise a nova configuração do feed na tela Finalizar e clique em Enviar.

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