Recolha registos de contexto do Jamf Pro

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 do serviço de apoio técnico do Google SecOps e os Termos Específicos do Serviço Google SecOps.

Este documento explica como carregar registos de contexto do Jamf Pro (contexto do dispositivo e do utilizador) para o Google Security Operations através do AWS S3 com o agendamento do Lambda e do EventBridge.

Antes de começar

• Instância do Google SecOps
• Acesso privilegiado ao inquilino do Jamf Pro
• Acesso privilegiado à AWS (S3, IAM, Lambda, EventBridge)

Configure a função da API Jamf

1. Inicie sessão na IU da Web do Jamf.
2. Aceda a Definições > secção Sistema > Funções e clientes da API.
3. Selecione o separador Funções da API.
4. Clique em Novo.
5. Introduza um nome a apresentar para a função da API (por exemplo, context_role).

6. Em Privilégios da função da API Jamf Pro, escreva o nome de um privilégio e, em seguida, selecione-o no menu.

   • Inventário de computadores
   • Inventário de dispositivos móveis
   Nota: pode continuar a adicionar mais privilégios até terminar.

7. Clique em Guardar.

Configure o cliente da API Jamf

1. No Jamf Pro, aceda a Definições > secção Sistema > Funções e clientes da API.
2. Selecione o separador Clientes da API.
3. Clique em Novo.
4. Introduza um nome a apresentar para o cliente API (por exemplo, context_client).
5. No campo Funções da API, adicione a função context_role que criou anteriormente.
6. Em Tempo de vida da chave de acesso, introduza o tempo em segundos para que as chaves de acesso sejam válidas.
7. Clique em Guardar.
8. Clique em Edit.
9. Clique em Ativar cliente API.
10. Clique em Guardar.

Configure o segredo do cliente do Jamf

1. No Jamf Pro, aceda ao cliente da API recém-criado.
2. Clique em Gerar segredo do cliente.
3. Num ecrã de confirmação, clique em Criar segredo.
4. Guarde os seguintes parâmetros numa localização segura:
   • URL base: https://<your>.jamfcloud.com
   • ID de cliente: UUID.
   • Segredo do cliente: o valor é apresentado uma vez.

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

1. Crie um contentor do Amazon S3 seguindo este manual do utilizador: Criar um contentor.
2. Guarde o nome e a região do contentor para referência futura (por exemplo, jamfpro).
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 a 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 e selecione a política AmazonS3FullAccess.
18. Clicar em Seguinte.
19. Clique em Adicionar autorizações.

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

1. JSON da política (substitua jamfpro se tiver introduzido um nome de contentor diferente):

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutJamfObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::jamfpro/*"
       }
     ]
   }
   

2. Aceda a AWS console > IAM > Policies > Create policy > separador JSON.

3. Copie e cole a política.

4. Clique em Seguinte > Criar política.

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

6. Anexe a política criada recentemente.

7. Dê o nome WriteJamfToS3Role à 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	jamf_pro_to_s3
Runtime	Python 3.13
Arquitetura	x86_64
Autorizações	WriteJamfToS3Role

1. Depois de criar a função, abra o separador Código, elimine o stub e introduza o seguinte código (jamf_pro_to_s3.py):

   import os
   import io
   import json
   import gzip
   import time
   import logging
   from datetime import datetime, timezone
   
   import boto3
   import requests
   
   log = logging.getLogger()
   log.setLevel(logging.INFO)
   
   BASE_URL = os.environ.get("JAMF_BASE_URL", "").rstrip("/")
   CLIENT_ID = os.environ.get("JAMF_CLIENT_ID")
   CLIENT_SECRET = os.environ.get("JAMF_CLIENT_SECRET")
   S3_BUCKET = os.environ.get("S3_BUCKET")
   S3_PREFIX = os.environ.get("S3_PREFIX", "jamf-pro/context/")
   PAGE_SIZE = int(os.environ.get("PAGE_SIZE", "200"))
   
   SECTIONS = [
       "GENERAL",
       "HARDWARE",
       "OPERATING_SYSTEM",
       "USER_AND_LOCATION",
       "DISK_ENCRYPTION",
       "SECURITY",
       "EXTENSION_ATTRIBUTES",
       "APPLICATIONS",
       "CONFIGURATION_PROFILES",
       "LOCAL_USER_ACCOUNTS",
       "CERTIFICATES",
       "SERVICES",
       "PRINTERS",
       "SOFTWARE_UPDATES",
       "GROUP_MEMBERSHIPS",
       "CONTENT_CACHING",
       "STORAGE",
       "FONTS",
       "PACKAGE_RECEIPTS",
       "PLUGINS",
       "ATTACHMENTS",
       "LICENSED_SOFTWARE",
       "IBEACONS",
       "PURCHASING",
   ]
   
   s3 = boto3.client("s3")
   
   def _now_iso():
       return datetime.now(timezone.utc).isoformat()
   
   def get_token():
       """OAuth2 client credentials > access_token"""
       url = f"{BASE_URL}/api/oauth/token"
       data = {
           "grant_type": "client_credentials",
           "client_id": CLIENT_ID,
           "client_secret": CLIENT_SECRET,
       }
       headers = {"Content-Type": "application/x-www-form-urlencoded"}
       r = requests.post(url, data=data, headers=headers, timeout=30)
       r.raise_for_status()
       j = r.json()
       return j["access_token"], int(j.get("expires_in", 1200))
   
   def fetch_page(token: str, page: int):
       """GET /api/v1/computers-inventory with sections & pagination"""
       url = f"{BASE_URL}/api/v1/computers-inventory"
       params = [("page", page), ("page-size", PAGE_SIZE)] + [("section", s) for s in SECTIONS]
       hdrs = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
       r = requests.get(url, params=params, headers=hdrs, timeout=60)
       r.raise_for_status()
       return r.json()
   
   def to_context_event(item: dict) -> dict:
       inv = item.get("inventory", {}) or {}
       general = inv.get("general", {}) or {}
       hardware = inv.get("hardware", {}) or {}
       osinfo = inv.get("operatingSystem", {}) or {}
       loc = inv.get("location", {}) or inv.get("userAndLocation", {}) or {}
   
       computer = {
           "udid": general.get("udid") or hardware.get("udid"),
           "deviceName": general.get("name") or general.get("deviceName"),
           "serialNumber": hardware.get("serialNumber") or general.get("serialNumber"),
           "model": hardware.get("model") or general.get("model"),
           "osVersion": osinfo.get("version") or general.get("osVersion"),
           "osBuild": osinfo.get("build") or general.get("osBuild"),
           "macAddress": hardware.get("macAddress"),
           "alternateMacAddress": hardware.get("wifiMacAddress"),
           "ipAddress": general.get("ipAddress"),
           "reportedIpV4Address": general.get("reportedIpV4Address"),
           "reportedIpV6Address": general.get("reportedIpV6Address"),
           "modelIdentifier": hardware.get("modelIdentifier"),
           "assetTag": general.get("assetTag"),
       }
   
       user_block = {
           "userDirectoryID": loc.get("username") or loc.get("userDirectoryId"),
           "emailAddress": loc.get("emailAddress"),
           "realName": loc.get("realName"),
           "phone": loc.get("phone") or loc.get("phoneNumber"),
           "position": loc.get("position"),
           "department": loc.get("department"),
           "building": loc.get("building"),
           "room": loc.get("room"),
       }
   
       return {
           "webhook": {"name": "api.inventory"},
           "event_type": "ComputerInventory",
           "event_action": "snapshot",
           "event_timestamp": _now_iso(),
           "event_data": {
               "computer": {k: v for k, v in computer.items() if v not in (None, "")},
               **{k: v for k, v in user_block.items() if v not in (None, "")},
           },
           "_jamf": {
               "id": item.get("id"),
               "inventory": inv,
           },
       }
   
   def write_ndjson_gz(objs, when: datetime):
       buf = io.BytesIO()
       with gzip.GzipFile(filename="-", mode="wb", fileobj=buf, mtime=int(time.time())) as gz:
           for obj in objs:
               line = json.dumps(obj, separators=(",", ":")) + "\n"
               gz.write(line.encode("utf-8"))
       buf.seek(0)
   
       prefix = S3_PREFIX.strip("/") + "/" if S3_PREFIX else ""
       key = f"{prefix}{when:%Y/%m/%d}/jamf_pro_context_{int(when.timestamp())}.ndjson.gz"
       s3.put_object(Bucket=S3_BUCKET, Key=key, Body=buf.getvalue())
       return key
   
   def lambda_handler(event, context):
       assert BASE_URL and CLIENT_ID and CLIENT_SECRET and S3_BUCKET, "Missing required env vars"
   
       token, _ttl = get_token()
       page = 0
       total = 0
       batch = []
       now = datetime.now(timezone.utc)
   
       while True:
           payload = fetch_page(token, page)
           results = payload.get("results") or payload.get("computerInventoryList") or []
           if not results:
               break
   
           for item in results:
               batch.append(to_context_event(item))
               total += 1
   
           if len(batch) >= 5000:
               key = write_ndjson_gz(batch, now)
               log.info("wrote %s records to s3://%s/%s", len(batch), S3_BUCKET, key)
               batch = []
   
           if len(results) < PAGE_SIZE:
               break
           page += 1
   
       if batch:
           key = write_ndjson_gz(batch, now)
           log.info("wrote %s records to s3://%s/%s", len(batch), S3_BUCKET, key)
   
       return {"ok": True, "count": total}
   

2. Aceda a Configuração > Variáveis de ambiente > Editar > Adicionar nova variável de ambiente.

3. Introduza as seguintes variáveis de ambiente, substituindo-as pelos seus valores.

   Variáveis de ambiente

   Chave	Exemplo
   S3_BUCKET	jamfpro
   S3_PREFIX	jamf-pro/context/
   AWS_REGION	Selecione a sua região
   JAMF_CLIENT_ID	Introduza o ID de cliente do Jamf
   JAMF_CLIENT_SECRET	Introduza o segredo do cliente do Jamf
   JAMF_BASE_URL	Introduza o URL do Jamf e substitua <your> em https://<your>.jamfcloud.com
   PAGE_SIZE	200

4. Depois de criar a função, permaneça na respetiva página (ou abra Lambda > Functions > your-function).

5. Selecione o separador Configuração.

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

7. 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. Só lhe é cobrado o 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:
   • Agendamento recorrente: tarifa (1 hour).
   • Destino: a sua função Lambda.
   • Nome: jamfpro-context-schedule-1h.
3. Clique em Criar programação.

Configure um feed no Google SecOps para carregar registos de contexto do Jamf Pro

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, Jamf Pro Context logs).
4. Selecione Amazon S3 V2 como o Tipo de origem.
5. Selecione Contexto do Jamf Pro como o Tipo de registo.
6. Clicar em Seguinte.
7. Especifique valores para os seguintes parâmetros de entrada:
   • URI do S3: o URI do contentor
     • s3://jamfpro/jamf-pro/context/
       • Substitua jamfpro pelo nome real do contentor.
   • 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 a aplicar aos eventos deste feed.
8. Clicar em Seguinte.
9. Reveja a nova configuração do feed no ecrã Finalizar e clique em Enviar.

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