Esta página foi traduzida pela API Cloud Translation.

Coletar registros dos serviços de IdP do CrowdStrike

Compatível com:

Google SecOps SIEM

Este documento explica como ingerir registros dos serviços de proteção de identidade (IDP) do CrowdStrike no Google Security Operations usando o Amazon S3. A integração usa a API CrowdStrike Unified Alerts para coletar eventos de proteção de identidade e os armazena no formato NDJSON para processamento pelo analisador CS_IDP integrado.

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 e gerenciamento de chaves de API.
Acesso privilegiado à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Conferir os pré-requisitos da proteção de identidade da CrowdStrike

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 Google SecOps IDP Integration.
- Descrição: insira API client for Google SecOps integration.
- Escopos: selecione o escopo Alertas: LEITURA (alerts:read), que inclui alertas de proteção de identidade.
Clique em Adicionar.
Copie e salve em um local seguro os seguintes detalhes:
- ID do cliente
- Chave secreta do cliente (mostrada apenas uma vez)
- URL base (exemplos: api.crowdstrike.com para US-1, api.us-2.crowdstrike.com para US-2, api.eu-1.crowdstrike.com para EU-1)

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-idp-logs-bucket).
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-idp-logs-bucket 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-idp-logs-bucket/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::crowdstrike-idp-logs-bucket/crowdstrike-idp/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 CrowdStrike-IDP-Lambda-Role 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-IDP-Collector

Ambiente de execução Python 3.13

Arquitetura x86_64

Função de execução CrowdStrike-IDP-Lambda-Role

Configuração	Valor
Nome	`CrowdStrike-IDP-Collector`
Ambiente de execução	Python 3.13
Arquitetura	x86_64
Função de execução	`CrowdStrike-IDP-Lambda-Role`

Depois que a função for criada, abra a guia Código, exclua o stub e cole o seguinte código:

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

HTTP = urllib3.PoolManager()

def lambda_handler(event, context):
    """
    Fetch CrowdStrike Identity Protection alerts (Unified Alerts API)
    and store RAW JSON (NDJSON) to S3 for the CS_IDP parser.
    No transformation is performed.
    """
    # Environment variables
    s3_bucket = os.environ['S3_BUCKET']
    s3_prefix = os.environ['S3_PREFIX']
    state_key = os.environ['STATE_KEY']
    client_id = os.environ['CROWDSTRIKE_CLIENT_ID']
    client_secret = os.environ['CROWDSTRIKE_CLIENT_SECRET']
    api_base = os.environ['API_BASE']

    s3 = boto3.client('s3')

    token = get_token(client_id, client_secret, api_base)
    last_ts = get_last_timestamp(s3, s3_bucket, state_key)

    # FQL filter for Identity Protection alerts only, newer than checkpoint
    fql_filter = f"product:'idp'+updated_timestamp:>'{last_ts}'"
    sort = 'updated_timestamp.asc'

    # Step 1: Get list of alert IDs
    all_ids = []
    per_page = int(os.environ.get('ALERTS_LIMIT', '1000'))  # up to 10000 per SDK docs
    offset = 0
    while True:
        page_ids = query_alert_ids(api_base, token, fql_filter, sort, per_page, offset)
        if not page_ids:
            break
        all_ids.extend(page_ids)
        if len(page_ids) < per_page:
            break
        offset += per_page

    if not all_ids:
        return {'statusCode': 200, 'body': 'No new Identity Protection alerts.'}

    # Step 2: Get alert details in batches (max 1000 IDs per request)
    details = []
    max_batch = 1000
    for i in range(0, len(all_ids), max_batch):
        batch = all_ids[i:i+max_batch]
        details.extend(fetch_alert_details(api_base, token, batch))

    if details:
        details.sort(key=lambda d: d.get('updated_timestamp', d.get('created_timestamp', '')))
        latest = details[-1].get('updated_timestamp') or details[-1].get('created_timestamp')

        key = f"{s3_prefix}cs_idp_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
        body = '\n'.join(json.dumps(d, separators=(',', ':')) for d in details)

        s3.put_object(
            Bucket=s3_bucket,
            Key=key,
            Body=body.encode('utf-8'),
            ContentType='application/x-ndjson'
        )

        update_state(s3, s3_bucket, state_key, latest)

    return {'statusCode': 200, 'body': f'Wrote {len(details)} alerts to S3.'}

def get_token(client_id, client_secret, api_base):
    """Get OAuth2 token from CrowdStrike API"""
    url = f"https://{api_base}/oauth2/token"
    data = f"client_id={client_id}&client_secret={client_secret}&grant_type=client_credentials"
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    r = HTTP.request('POST', url, body=data, headers=headers)
    if r.status != 200:
        raise Exception(f'Auth failed: {r.status} {r.data}')
    return json.loads(r.data.decode('utf-8'))['access_token']

def query_alert_ids(api_base, token, fql_filter, sort, limit, offset):
    """Query alert IDs using filters"""
    url = f"https://{api_base}/alerts/queries/alerts/v2"
    params = {'filter': fql_filter, 'sort': sort, 'limit': str(limit), 'offset': str(offset)}
    qs = urlencode(params)
    r = HTTP.request('GET', f"{url}?{qs}", headers={'Authorization': f'Bearer {token}'})
    if r.status != 200:
        raise Exception(f'Query alerts failed: {r.status} {r.data}')
    resp = json.loads(r.data.decode('utf-8'))
    return resp.get('resources', [])

def fetch_alert_details(api_base, token, composite_ids):
    """Fetch detailed alert data by composite IDs"""
    url = f"https://{api_base}/alerts/entities/alerts/v2"
    body = {'composite_ids': composite_ids}
    headers = {'Authorization': f'Bearer {token}', 'Content-Type': 'application/json'}
    r = HTTP.request('POST', url, body=json.dumps(body).encode('utf-8'), headers=headers)
    if r.status != 200:
        raise Exception(f'Fetch alert details failed: {r.status} {r.data}')
    resp = json.loads(r.data.decode('utf-8'))
    return resp.get('resources', [])

def get_last_timestamp(s3, bucket, key, default='2023-01-01T00:00:00Z'):
    """Get last processed timestamp from S3 state file"""
    try:
        obj = s3.get_object(Bucket=bucket, Key=key)
        state = json.loads(obj['Body'].read().decode('utf-8'))
        return state.get('last_timestamp', default)
    except s3.exceptions.NoSuchKey:
        return default

def update_state(s3, bucket, key, ts):
    """Update last processed timestamp in S3 state file"""
    state = {'last_timestamp': ts, 'updated': datetime.now(timezone.utc).isoformat()}
    s3.put_object(Bucket=bucket, Key=key, Body=json.dumps(state).encode('utf-8'), ContentType='application/json')

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-idp-logs-bucket`
`S3_PREFIX`	`crowdstrike-idp/`
`STATE_KEY`	`crowdstrike-idp/state.json`
`CROWDSTRIKE_CLIENT_ID`	`<your-client-id>`
`CROWDSTRIKE_CLIENT_SECRET`	`<your-client-secret>`
`API_BASE`	`api.crowdstrike.com` (US-1), `api.us-2.crowdstrike.com` (US-2), `api.eu-1.crowdstrike.com` (EU-1)
`ALERTS_LIMIT`	`1000` (opcional, máx. de 10.000 por página)

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. Qualquer execução mais curta termina 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 (15 minutes).
- Destino: sua função Lambda CrowdStrike-IDP-Collector.
- Nome: CrowdStrike-IDP-Collector-15m.
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-idp-logs-bucket/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::crowdstrike-idp-logs-bucket"
    }
  ]
}

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 dos serviços de proteção de identidade do CrowdStrike

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 Identity Protection Services logs).
Selecione Amazon S3 V2 como o Tipo de origem.
Selecione Serviços de proteção de identidade da Crowdstrike como o Tipo de registro.
Clique em Próxima.
Especifique valores para os seguintes parâmetros de entrada:
- URI do S3: s3://crowdstrike-idp-logs-bucket/crowdstrike-idp/
- 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.