Recolha registos da plataforma ZeroFox

Compatível com:

Google secops SIEM

Nota: esta funcionalidade está abrangida pelos Termos das Ofertas de Pré-DG dos Termos Específicos do serviço Google Security Operations. As funcionalidades de pré-DG podem ter suporte limitado e as alterações às funcionalidades de pré-DG podem não ser compatíveis com outras versões de pré-DG. Para mais informações, consulte as diretrizes dos serviços de apoio técnico do Google SecOps e os Termos Específicos dos Serviços do Google SecOps.

Este documento explica como carregar registos da plataforma ZeroFox para o Google Security Operations através do Amazon S3.

Antes de começar

Certifique-se de que cumpre os seguintes pré-requisitos:

• Uma instância do Google SecOps.
• Acesso privilegiado ao inquilino da plataforma ZeroFox.
• Acesso privilegiado à AWS (S3, Identity and Access Management [IAM], Lambda e EventBridge).

Obtenha os pré-requisitos do ZeroFox

1. Inicie sessão na plataforma ZeroFox em https://cloud.zerofox.com.
2. Aceda a Conetores de dados > Feeds de dados da API.
   • URL direto (após início de sessão): https://cloud.zerofox.com/data_connectors/api
   • Se não vir este item de menu, contacte o seu administrador do ZeroFox para aceder.
3. Clique em Gerar token ou Criar token de acesso pessoal.
4. Indique os seguintes detalhes de configuração:
   • Nome: introduza um nome descritivo (por exemplo, Google SecOps S3 Ingestion).
   • Expiração: selecione um período de rotação de acordo com a política de segurança da sua organização.
   • Autorizações/Feeds: selecione autorizações de leitura para: Alerts, CTI feeds e outros tipos de dados que quer exportar
5. Clique em Gerar.
6. Copie e guarde o token de acesso pessoal gerado numa localização segura (não vai poder vê-lo novamente).
7. Guarde o ZEROFOX_BASE_URL: https://api.zerofox.com (predefinição para a maioria dos inquilinos)

Configure o contentor do AWS S3 e o IAM para o Google SecOps

1. Crie um contentor do Amazon S3 seguindo este guia do utilizador: Criar um contentor
2. Guarde o nome e a região do contentor para referência futura (por exemplo, zerofox-platform-logs).
3. Crie um utilizador seguindo este guia do utilizador: criar um utilizador do IAM.
4. Selecione o utilizador criado.
5. Selecione o separador Credenciais de segurança.
6. Clique em Criar chave de acesso na secção Chaves de acesso.
7. Selecione Serviço de terceiros como Exemplo de utilização.
8. Clicar em Seguinte.
9. Opcional: adicione uma etiqueta de descrição.
10. Clique em Criar chave de acesso.
11. Clique em Transferir ficheiro .CSV para guardar a chave de acesso e a chave de acesso secreta para referência futura.
12. Clique em Concluído.
13. Selecione o separador Autorizações.
14. Clique em Adicionar autorizações na secção Políticas de autorizações.
15. Selecione Adicionar autorizações.
16. Selecione Anexar políticas diretamente.
17. Pesquise a política AmazonS3FullAccess.
18. Selecione a política.
19. Clicar em Seguinte.
20. Clique em Adicionar autorizações.

Configure a política e a função de IAM para carregamentos do S3

1. Na consola da AWS, aceda a IAM > Políticas.
2. Clique em Criar política > separador JSON.
3. Copie e cole a seguinte política.

4. JSON da política (substitua zerofox-platform-logs se tiver introduzido um nome de contentor diferente):

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

5. Clique em Seguinte > Criar política.

6. Aceda a IAM > Funções > Criar função > Serviço AWS > Lambda.

7. Anexe a política criada recentemente.

8. Dê o nome ZeroFoxPlatformToS3Role à função e clique em Criar função.

Crie a função Lambda

1. Na consola da AWS, aceda a Lambda > Functions > Create function.
2. Clique em Criar do zero.

3. Faculte os seguintes detalhes de configuração:

   Definição	Valor
   Nome	zerofox_platform_to_s3
   Runtime	Python 3.13
   Arquitetura	x86_64
   Função de execução	ZeroFoxPlatformToS3Role

4. Depois de criar a função, abra o separador Código, elimine o fragmento e cole o seguinte código (zerofox_platform_to_s3.py).

   #!/usr/bin/env python3
   # Lambda: Pull ZeroFox Platform data (alerts/incidents/logs) to S3 (no transform)
   
   import os, json, time, urllib.parse
   from urllib.request import Request, urlopen
   from urllib.error import HTTPError, URLError
   import boto3
   
   S3_BUCKET     = os.environ["S3_BUCKET"]
   S3_PREFIX     = os.environ.get("S3_PREFIX", "zerofox/platform/")
   STATE_KEY     = os.environ.get("STATE_KEY", "zerofox/platform/state.json")
   LOOKBACK_SEC  = int(os.environ.get("LOOKBACK_SECONDS", "3600"))
   PAGE_SIZE     = int(os.environ.get("PAGE_SIZE", "200"))
   MAX_PAGES     = int(os.environ.get("MAX_PAGES", "20"))
   HTTP_TIMEOUT  = int(os.environ.get("HTTP_TIMEOUT", "60"))
   HTTP_RETRIES  = int(os.environ.get("HTTP_RETRIES", "3"))
   URL_TEMPLATE  = os.environ.get("URL_TEMPLATE", "")
   AUTH_HEADER   = os.environ.get("AUTH_HEADER", "")  # e.g. "Authorization: Bearer <token>"
   
   ZEROFOX_BASE_URL = os.environ.get("ZEROFOX_BASE_URL", "https://api.zerofox.com")
   ZEROFOX_API_TOKEN = os.environ.get("ZEROFOX_API_TOKEN", "")
   
   s3 = boto3.client("s3")
   
   def _iso(ts: float) -> str:
       return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))
   
   def _load_state() -> dict:
       try:
           obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
           b = obj["Body"].read()
           return json.loads(b) if b else {}
       except Exception:
           return {"last_since": _iso(time.time() - LOOKBACK_SEC)}
   
   def _save_state(st: dict) -> None:
       s3.put_object(
           Bucket=S3_BUCKET, Key=STATE_KEY,
           Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
   
   def _headers() -> dict:
       hdrs = {"Accept": "application/json", "Content-Type": "application/json"}
       if AUTH_HEADER:
           try:
               k, v = AUTH_HEADER.split(":", 1)
               hdrs[k.strip()] = v.strip()
           except ValueError:
               hdrs["Authorization"] = AUTH_HEADER.strip()
       elif ZEROFOX_API_TOKEN:
           hdrs["Authorization"] = f"Bearer {ZEROFOX_API_TOKEN}"
       return hdrs
   
   def _http_get(url: str) -> dict:
       attempt = 0
       while True:
           try:
               req = Request(url, method="GET")
               for k, v in _headers().items():
                   req.add_header(k, v)
               with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                   body = r.read()
                   try:
                       return json.loads(body.decode("utf-8"))
                   except json.JSONDecodeError:
                       return {"raw": body.decode("utf-8", errors="replace")}
           except HTTPError as e:
               if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                   retry_after = int(e.headers.get("Retry-After", 1 + attempt))
                   time.sleep(max(1, retry_after))
                   attempt += 1
                   continue
               raise
           except URLError:
               if attempt < HTTP_RETRIES:
                   time.sleep(1 + attempt)
                   attempt += 1
                   continue
               raise
   
   def _put_json(obj: dict, label: str) -> str:
       ts = time.gmtime()
       key = f"{S3_PREFIX}/{time.strftime('%Y/%m/%d/%H%M%S', ts)}-zerofox-{label}.json"
       s3.put_object(
           Bucket=S3_BUCKET, Key=key,
           Body=json.dumps(obj, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
       return key
   
   def _extract_next_token(payload: dict):
       next_token = (payload.get("next") or payload.get("next_token") or 
                     payload.get("nextPageToken") or payload.get("next_page_token"))
       if isinstance(next_token, dict):
           return next_token.get("token") or next_token.get("cursor") or next_token.get("value")
       return next_token
   
   def _extract_items(payload: dict) -> list:
       for key in ("results", "data", "alerts", "items", "logs", "events"):
           if isinstance(payload.get(key), list):
               return payload[key]
       return []
   
   def _extract_newest_timestamp(items: list, current: str) -> str:
       newest = current
       for item in items:
           timestamp = (item.get("timestamp") or item.get("created_at") or 
                       item.get("last_modified") or item.get("event_time") or 
                       item.get("log_time") or item.get("updated_at"))
           if isinstance(timestamp, str) and timestamp > newest:
               newest = timestamp
       return newest
   
   def lambda_handler(event=None, context=None):
       st = _load_state()
       since = st.get("last_since") or _iso(time.time() - LOOKBACK_SEC)
   
       # Use URL_TEMPLATE if provided, otherwise construct default alerts endpoint
       if URL_TEMPLATE:
           base_url = URL_TEMPLATE.replace("{SINCE}", urllib.parse.quote(since))
       else:
           base_url = f"{ZEROFOX_BASE_URL}/v1/alerts?since={urllib.parse.quote(since)}"
   
       page_token = ""
       pages = 0
       total_items = 0
       newest_since = since
   
       while pages < MAX_PAGES:
           # Construct URL with pagination
           if URL_TEMPLATE:
               url = (base_url
                     .replace("{PAGE_TOKEN}", urllib.parse.quote(page_token))
                     .replace("{PAGE_SIZE}", str(PAGE_SIZE)))
           else:
               url = f"{base_url}&limit={PAGE_SIZE}"
               if page_token:
                   url += f"&page_token={urllib.parse.quote(page_token)}"
   
           payload = _http_get(url)
           _put_json(payload, f"page-{pages:05d}")
   
           items = _extract_items(payload)
           total_items += len(items)
           newest_since = _extract_newest_timestamp(items, newest_since)
   
           pages += 1
           next_token = _extract_next_token(payload)
           if not next_token:
               break
           page_token = str(next_token)
   
       if newest_since and newest_since != st.get("last_since"):
           st["last_since"] = newest_since
           _save_state(st)
   
       return {"ok": True, "pages": pages, "items": total_items, "since": since, "new_since": newest_since}
   
   if __name__ == "__main__":
       print(lambda_handler())
   

5. Aceda a Configuração > Variáveis de ambiente.

6. Clique em Editar > Adicionar nova variável de ambiente.

7. Introduza as variáveis de ambiente fornecidas na tabela seguinte, substituindo os valores de exemplo pelos seus valores.

   Variáveis de ambiente

   Chave	Valor de exemplo
   S3_BUCKET	zerofox-platform-logs
   S3_PREFIX	zerofox/platform/
   STATE_KEY	zerofox/platform/state.json
   ZEROFOX_BASE_URL	https://api.zerofox.com
   ZEROFOX_API_TOKEN	your-zerofox-personal-access-token
   LOOKBACK_SECONDS	3600
   PAGE_SIZE	200
   MAX_PAGES	20
   HTTP_TIMEOUT	60
   HTTP_RETRIES	3
   URL_TEMPLATE	(opcional) Modelo de URL personalizado com {SINCE}, {PAGE_TOKEN}, {PAGE_SIZE}
   AUTH_HEADER	(opcional) Authorization: Bearer <token> para autenticação personalizada

8. Depois de criar a função, permaneça na respetiva página (ou abra Lambda > Functions > a sua função).

9. Selecione o separador Configuração.

10. No painel Configuração geral, clique em Editar.

11. Altere Tempo limite para 5 minutos (300 segundos) e clique em Guardar.

    Nota: o limite de tempo é um limite superior rígido, o que significa que, se a função ainda estiver em execução quando o temporizador atingir os 5 minutos, o AWS Lambda termina-a. Qualquer execução mais curta termina normalmente. A faturação é feita apenas com base no tempo de execução real.

Crie um horário do EventBridge

1. Aceda a Amazon EventBridge > Scheduler > Create schedule.
2. Indique os seguintes detalhes de configuração:
   • Agenda recorrente: Taxa (1 hour).
   • Destino: a sua função Lambda zerofox_platform_to_s3.
   • Nome: zerofox-platform-1h.
3. Clique em Criar programação.

(Opcional) Crie um utilizador e chaves da IAM só de leitura para o Google SecOps

1. Aceda a AWS Console > IAM > Users.
2. Clique em Adicionar utilizadores.
3. Indique os seguintes detalhes de configuração:
   • Utilizador: introduza secops-reader.
   • Tipo de acesso: selecione Chave de acesso – Acesso programático.
4. Clique em Criar utilizador.
5. Anexe a política de leitura mínima (personalizada): Users > secops-reader > Permissions > Add permissions > Attach policies directly > Create policy.

6. JSON:

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

7. Nome = secops-reader-policy.

8. Clique em Criar política > procure/selecione > Seguinte > Adicionar autorizações.

9. Crie uma chave de acesso para secops-reader: Credenciais de segurança > Chaves de acesso.

10. Clique em Criar chave de acesso.

11. Transfira o .CSV. (Vai colar estes valores no feed).

Configure um feed no Google SecOps para carregar registos da plataforma ZeroFox

1. Aceda a Definições do SIEM > Feeds.
2. Clique em + Adicionar novo feed.
3. No campo Nome do feed, introduza um nome para o feed (por exemplo, ZeroFox Platform Logs).
4. Selecione Amazon S3 V2 como o Tipo de origem.
5. Selecione ZeroFox Platform como o Tipo de registo.
6. Clicar em Seguinte.
7. Especifique valores para os seguintes parâmetros de entrada:
   • URI do S3: s3://zerofox-platform-logs/zerofox/platform/
   • Opções de eliminação de origens: selecione a opção de eliminação de acordo com a sua preferência.
   • Idade máxima do ficheiro: inclua ficheiros modificados no último número de dias. A predefinição é 180 dias.
   • ID da chave de acesso: chave de acesso do utilizador com acesso ao contentor do S3.
   • Chave de acesso secreta: chave secreta do utilizador com acesso ao contentor do S3.
   • Espaço de nomes do recurso: o espaço de nomes do recurso.
   • Etiquetas de carregamento: a etiqueta aplicada aos eventos deste feed.
8. Clicar em Seguinte.
9. Reveja a nova configuração do feed no ecrã Finalizar e, de seguida, clique em Enviar.

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