Esta página foi traduzida pela API Cloud Translation.

Coletar registros de eventos de ameaças do Jamf

Compatível com:

Google SecOps SIEM

Este documento descreve como coletar registros de eventos de ameaças do Jamf configurando um feed do Google Security Operations e como os campos de registro são mapeados para os campos do modelo unificado de dados (UDM) do Google SecOps. Este documento também lista a versão compatível do Jamf Threat Events.

Para mais informações, consulte Ingestão de dados no Google SecOps.

Uma implantação típica consiste em eventos de ameaça do Jamf e no feed do Google SecOps configurado para enviar registros ao Google SecOps. Cada implantação de cliente pode ser diferente e mais complexa.

A implantação contém os seguintes componentes:

Jamf Protect: a plataforma Jamf Protect, configurada com o Jamf Security Cloud, em que você coleta registros de ameaças à rede.
Feed do Google SecOps: busca registros do Jamf Protect e os grava no Google SecOps.
Google SecOps: o Google SecOps retém e analisa os registros do Jamf Protect.

Um rótulo de ingestão identifica o analisador que normaliza dados de registro brutos para o formato UDM estruturado. As informações neste documento se aplicam ao analisador com o rótulo de ingestão JAMF_THREAT_EVENTS.

Antes de começar

Verifique se você atende aos seguintes pré-requisitos:

Uma configuração de telemetria do Jamf Protect
Jamf Protect versão 4.0.0 ou mais recente
Todos os sistemas na arquitetura de implantação são configurados com o fuso horário UTC.

Configure feeds em Configurações do SIEM > Feeds

É possível usar o Amazon S3 V2 ou um webhook para configurar um feed de ingestão no Google SecOps.

Configurar um feed de ingestão usando o Amazon S3 V2

Acesse Configurações do SIEM > Feeds.
Clique em Adicionar novo feed.
Clique no pacote de feed JAMF.
Localize o feed Eventos de ameaça do Jamf Protect.
Selecione Amazon S3 V2 como o Tipo de origem.
Especifique os valores dos campos a seguir.
- URI do S3: o URI do bucket.
  - s3://your-log-bucket-name/
    - Substitua your-log-bucket-name pelo nome real do seu bucket do S3.
- Opções de exclusão de origem: selecione a opção de exclusão de acordo com suas preferências de ingestão.
- 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: a chave de acesso do usuário com permissões para ler do bucket do S3.
- Chave de acesso secreta: a chave secreta do usuário com permissões para ler do bucket do S3.
Opções avançadas
- Nome do feed: um valor pré-preenchido que identifica o feed.
- Namespace do recurso: namespace associado ao feed.
- Rótulos de ingestão: rótulos aplicados a todos os eventos deste feed.
Clique em Criar feed.

Configurar um feed de ingestão usando um webhook

Acesse Configurações do SIEM > Feeds.
Clique em Adicionar novo feed.
Clique no pacote de feed JAMF.
Localize o feed Eventos de ameaça do Jamf Protect.
Na lista Tipo de origem, selecione Webhook.
Especifique valores para os seguintes campos:
- Delimitador de divisão: o delimitador usado para separar linhas de registro, como \n.
- Namespace do recurso: o namespace do recurso.
- Rótulos de ingestão: o rótulo a ser aplicado aos eventos deste feed.
Clique em Criar feed.

Para configurar vários feeds para diferentes tipos de registros nessa família de produtos, consulte Configurar feeds por produto.

Criar uma chave de API para um feed de webhook

Acesse o console doGoogle Cloud > Credenciais.

Ir para Credenciais
Clique em Criar credenciais e, em seguida, selecione Chave de API.
Restrinja o acesso da chave de API à API Google Security Operations.

Configurar o Jamf Security Cloud para um feed de webhook

No aplicativo Jamf Security Cloud, acesse Integrações > Fluxos de dados.
Clique em Nova configuração.
Selecione Eventos de ameaça > HTTP genérico > Continuar.
Na seção Configuração de conexão HTTP, selecione https como o protocolo padrão.
Insira o nome do host do servidor no campo Nome do host/IP do servidor, como us-chronicle.googleapis.com.
Insira a porta do servidor no campo Porta, como 443.
Insira seu endpoint da Web no campo Endpoint. Esse é o campo Informações do endpoint que você copiou da configuração do feed de webhook. Ele já está no formato necessário.
Na seção Cabeçalhos adicionais, insira as seguintes configurações. Cada cabeçalho é personalizado e diferencia maiúsculas de minúsculas, sendo inserido manualmente:
- Nome do cabeçalho: X-goog-api-key e clique em Criar opção X-goog-api-key.
- Inserção de valor do cabeçalho: API_KEY (a chave de API para autenticar no Google SecOps).
- Nome do cabeçalho: X-Webhook-Access-Key e clique em Criar opção X-Webhook-Access-Key.
- Inserção de valor do cabeçalho: SECRET (a chave secreta que você gerou para autenticar o feed).
Clique em Configuração de teste.
Se a validação for bem-sucedida, clique em Criar configuração.

Para mais informações sobre feeds do Google SecOps, consulte Criar e gerenciar feeds usando a interface de gerenciamento de feeds. Para informações sobre os requisitos de cada tipo de feed, consulte API de configuração de feed.

Formatos de registro de eventos de ameaças do Jamf compatíveis

O analisador de eventos de ameaças do Jamf é compatível com registros no formato JSON.

Exemplos de registros de eventos de ameaças do Jamf compatíveis

JSON

{
  "event": {
    "metadata": {
      "schemaVersion": "1.0",
      "vendor": "Jamf",
      "product": "Threat Events Stream"
    },
    "timestamp": "2023-01-11T13:10:40.410Z",
    "alertId": "debd2e4b-9da1-454e-952d-18a00b42ffce",
    "account": {
      "customerId": "dummycustomerid",
      "parentId": "dummyparentid",
      "name": "Jamf Internal Test Accounts (root) - Jamf - CE Security Team"
    },
    "device": {
      "deviceId": "e9671102-5ccf-4e66-a6b3-b117ba257d5f",
      "os": "UNKNOWN 13.2.1",
      "deviceName": "Mac (13.2.1)",
      "userDeviceName": "darrow",
      "externalId": "0c221ae4-50af-5e39-8275-4424cc87ab8e"
    },
    "eventType": {
      "id": "303",
      "description": "Risky Host/Domain - Malware",
      "name": "ACCESS_BAD_HOST"
    },
    "app": {
      "id": "ru.freeapps.calc",
      "name": "MyFreeCalculator",
      "version": "10.4",
      "sha1": "c3499c2729730a7f807efb8676a92dcb6f8a3f8f",
      "sha256": "50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545"
    },
    "destination": {
      "name": "dummy.domain.org",
      "ip": "0000:1111:2222:3333:4444:5",
      "port": "80"
    },
    "source": {
      "ip": "198.51.100.1",
      "port": "243"
    },
    "location": "GB",
    "accessPoint": null,
    "accessPointBssid": "23:8f:cf:00:9d:23",
    "severity": 8,
    "user": {
      "email": "test.user@domain.io",
      "name": "Test User"
    },
    "eventUrl": "dummy.domain.com",
    "action": "Blocked"
  }
}

Referência de mapeamento de campos

A tabela a seguir explica como o analisador do Google SecOps mapeia os campos de registros de eventos de ameaças do Jamf para os campos do modelo de dados unificado (UDM) do Google SecOps.

Referência de mapeamento de campos: identificador de evento para tipo de evento

A tabela a seguir lista os tipos de registros JAMF_THREAT_EVENTS e os tipos de eventos da UDM correspondentes.

Event Identifier	Event Type	Security Category
`MALICIOUS_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`ADWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`BANKER_MALWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`POTENTIALLY_UNWANTED_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`RANSOMWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`ROOTING_MALWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`SMS_MALWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`SPYWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`TROJAN_MALWARE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`THIRD_PARTY_APP_STORES_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`ADMIN_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`SIDE_LOADED_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`VULNERABLE_APP_IN_INVENTORY`	`SCAN_UNCATEGORIZED`	`SOFTWARE_MALICIOUS, SOFTWARE_PUA`
`SSL_TRUST_COMPROMISE`	`SCAN_NETWORK`	`NETWORK_SUSPICIOUS`
`JAILBREAK`	`SCAN_UNCATEGORIZED`	`EXPLOIT`
`IOS_PROFILE`	`SCAN_UNCATEGORIZED`
`OUTDATED_OS`	`SCAN_VULN_HOST`	`SOFTWARE_MALICIOUS`
`OUTDATED_OS_LOW`	`SCAN_VULN_HOST`	`SOFTWARE_MALICIOUS`
`OUT_OF_DATE_OS`	`SCAN_UNCATEGORIZED`
`LOCK_SCREEN_DISABLED`	`SCAN_UNCATEGORIZED`
`STORAGE_ENCRYPTION_DISABLED`	`SCAN_UNCATEGORIZED`
`UNKNOWN_SOURCES_ENABLED`	`SCAN_UNCATEGORIZED`
`DEVELOPER_MODE_ENABLED`	`SCAN_UNCATEGORIZED`
`USB_DEBUGGING_ENABLED`	`SCAN_UNCATEGORIZED`
`USB_APP_VERIFICATION_DISABLED`	`SCAN_UNCATEGORIZED`
`FIREWALL_DISABLED`	`SCAN_UNCATEGORIZED`	`POLICY_VIOLATION`
`USER_PASSWORD_DISABLED`	`SCAN_UNCATEGORIZED`
`ANTIVIRUS_DISABLED`	`SCAN_UNCATEGORIZED`
`APP_INACTIVITY`	`SCAN_UNCATEGORIZED`
`MISSING_ANDROID_SECURITY_PATCHES`	`SCAN_UNCATEGORIZED`
`ACCESS_SPAM_HOST`	`SCAN_HOST`	`NETWORK_SUSPICIOUS`
`ACCESS_PHISHING_HOST`	`SCAN_HOST`	`PHISHING`
`ACCESS_BAD_HOST`	`SCAN_HOST`	`NETWORK_MALICIOUS`
`RISKY_APP_DOWNLOAD`	`SCAN_UNCATEGORIZED`	`SOFTWARE_SUSPICIOUS`
`ACCESS_CRYPTOJACKING_HOST`	`SCAN_HOST`	`NETWORK_SUSPICIOUS`
`SSL_MITM_TRUSTED_VALID_CERT`	`SCAN_NETWORK`	`NETWORK_SUSPICIOUS`
`SSL_MITM_UNTRUSTED_VALID_CERT`	`SCAN_NETWORK`	`NETWORK_SUSPICIOUS`
`SSL_STRIP_MITM`	`SCAN_NETWORK`	`NETWORK_MALICIOUS`
`SSL_MITM_UNTRUSTED_INVALID_CERT`	`SCAN_NETWORK`	`NETWORK_MALICIOUS`
`SSL_MITM_TRUSTED_INVALID_CERT`	`SCAN_NETWORK`	`NETWORK_MALICIOUS`
`LEAK_CREDIT_CARD`	`SCAN_UNCATEGORIZED`	`ACL_VIOLATION`
`LEAK_PASSWORD`	`SCAN_UNCATEGORIZED`	`ACL_VIOLATION`
`LEAK_EMAIL`	`SCAN_UNCATEGORIZED`	`ACL_VIOLATION`
`LEAK_USERID`	`SCAN_UNCATEGORIZED`	`ACL_VIOLATION`
`LEAK_LOCATION`	`SCAN_UNCATEGORIZED`	`ACL_VIOLATION`

Referência de mapeamento de campo: JAMF_THREAT_EVENTS

A tabela a seguir lista os campos de registro do tipo JAMF_THREAT_EVENTS e os campos correspondentes da UDM.

Log field	UDM mapping	Logic
`event.account.parentId`	`about.resource_ancestors.product_object_id`
`event.account.name`	`about.resource.name`
`event.account.customerId`	`about.resource.product_object_id`
`event.timestamp`	`metadata.event_timestamp`
`event.eventType.name`	`metadata.product_event_type`
`event.alertId`	`metadata.product_log_id`
`event.metadata.product`	`metadata.product_name`
`event.metadata.vendor`	`metadata.vendor_name`
`event.source.port`	`princiap.port`
`event.device.deviceName`	`principal.asset.assetid`
`event.location`	`principal.asset.location.country_or_region`
	`principal.asset.platform_software.platform`	`The platform_name` is extracted from the `event.device.deviceName` log field using a Grok pattern. If the `platform_name` value is equal to `Mac`, then the `principal.asset.platform_software.platform` UDM field is set to `MAC`.
`event.device.os`	`principal.asset.platform_software.platform_version`
`event.device.deviceId`	`principal.asset.product_object_id`
`event.source.ip`	`principal.ip`
`event.accessPointBssid`	`principal.mac`
`event.user.email`	`principal.user.email_addresses`
`event.user.name`	`principal.user.user_display_name`
`sourceUserName`	`principal.user.user_display_name`
`event.device.externalId`	`principal.asset.attribute.labels [event_device_externalId]`
`event.device.userDeviceName`	`principal.asset.attribute.labels [event_device_userDeviceName]`
`event.accessPoint`	`principal.labels [event_accessPoint]`
`event.action`	`security_result.action`	The `security_result.action` UDM field is set to one of the following values: `ALLOW` if the `event.action` log field value is equal to `Resolved` or `Detected`. `BLOCK` if the `event.action` log field value is equal to `Blocked`.
`event.action`	`security_result.action_details`
`event.eventType.name`	`security_result.category_details`
`event.eventType.description`	`security_result.description`
`event.severity`	`security_result.severity_details`
`event.eventType.id`	`security_result.threat_id`
`event.eventType.name`	`security_result.threat_name`
`event.eventUrl`	`security_result.url_back_to_product`
`event.destination.port`	`target.port`
`event.app.name`	`target.application`
`event.app.name`	`target.file.full_path`
`event.app.sha1`	`target.file.sha1`
`event.app.sha256`	`target.file.sha256`
`event.destination.ip`	`target.ip`
`event.destination.name`	`target.url`
`event.app.version`	`target.labels [event_app_version]`
`event.app.id`	`target.labels [event_app_id]`
`event.metadata.schemaVersion`	`about.labels [event_metadata_schemaVersion]`

A seguir

Ingestão de dados no Google SecOps

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