Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Collecter les journaux d'événements de menaces Jamf

Compatible avec :

Google secops SIEM

Ce document explique comment collecter les journaux d'événements de menaces Jamf en configurant un flux Google Security Operations et comment les champs de journaux sont mappés aux champs du modèle de données unifié (UDM) de Google SecOps. Ce document répertorie également la version compatible des événements de menaces Jamf.

Pour en savoir plus, consultez la section Ingérer des données dans Google SecOps.

Un déploiement typique comprend les événements de menaces Jamf et le flux Google SecOps configuré pour envoyer des journaux à Google SecOps. Chaque déploiement client peut être différent et plus complexe.

Le déploiement contient les composants suivants :

Jamf Protect : plate-forme Jamf Protect, configurée avec Jamf Security Cloud, où vous collectez les journaux de menaces réseau.
Flux Google SecOps : flux Google SecOps qui récupère les journaux de Jamf Protect et les écrit dans Google SecOps.
Google SecOps : Google SecOps conserve et analyse les journaux de Jamf Protect.

Un libellé d'ingestion identifie l'analyseur qui normalise les données de journaux brutes au format UDM structuré. Les informations de ce document s'appliquent à l'analyseur avec le libellé d'ingestion JAMF_THREAT_EVENTS.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Configuration d'un ensemble de télémétrie Jamf Protect
Jamf Protect version 4.0.0 ou ultérieure
Tous les systèmes de l'architecture de déploiement sont configurés avec le fuseau horaire UTC.

Configurer des flux à partir de Paramètres du SIEM > Flux

Vous pouvez utiliser Amazon S3 V2 ou un webhook pour configurer un flux d'ingestion dans Google SecOps.

Configurer un flux d'ingestion à l'aide d'Amazon S3 V2

Accédez à Paramètres du SIEM > Flux.
Cliquez sur Ajouter un flux.
Cliquez sur le pack de flux JAMF.
Recherchez le flux Événements de menaces Jamf Protect.
Sélectionnez Amazon S3 V2 comme Type de source.
Spécifiez les valeurs des champs suivants.
- URI S3 : URI du bucket.
  - s3://your-log-bucket-name/
    - Remplacez your-log-bucket-name par le nom réel de votre bucket S3.
- Options de suppression de la source : sélectionnez l'option de suppression en fonction de vos préférences d'ingestion.
- Âge maximal du fichier : inclut les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
- ID de clé d'accès : clé d'accès de l'utilisateur avec les autorisations de lecture à partir du bucket S3.
- Clé d'accès secrète : clé secrète de l'utilisateur avec les autorisations de lecture à partir du bucket S3.
Options avancées
- Nom du flux : valeur préremplie qui identifie le flux.
- Espace de noms de l'élément : espace de noms associé au flux.
- Libellés d'ingestion : libellés appliqués à tous les événements de ce flux.
Cliquez sur Créer un flux.

Configurer un flux d'ingestion à l'aide d'un webhook

Accédez à Paramètres du SIEM > Flux.
Cliquez sur Ajouter un flux.
Cliquez sur le pack de flux JAMF.
Recherchez le flux Événements de menaces Jamf Protect.
Dans la liste Type de source, sélectionnez Webhook.
Spécifiez les valeurs des champs suivants :
- Délimiteur de division : délimiteur utilisé pour séparer les lignes de journal, par exemple \n.
- Espace de noms de l'élément : espace de noms de l'élément.
- Libellés d'ingestion : libellé à appliquer aux événements de ce flux.
Cliquez sur Créer un flux.

Pour configurer plusieurs flux pour différents types de journaux au sein de cette famille de produits, consultez Configurer des flux par produit.

Créer une clé API pour un flux de webhook

Accédez à Google Cloud console > Identifiants.

Accéder à "Identifiants"
Cliquez sur Créer des identifiants, puis sélectionnez Clé API.
Restreignez l'accès de la clé API à l'API Google Security Operations.

Configurer Jamf Security Cloud pour un flux de webhook

Dans l'application Jamf Security Cloud, accédez à Integrations > Data Streams.
Cliquez sur Nouvelle configuration.
Sélectionnez Événements de menaces > HTTP générique > Continuer.
Dans la section Configuration de la connexion HTTP, sélectionnez https comme protocole par défaut.
Saisissez le nom d'hôte de votre serveur dans le champ Nom d'hôte/IP du serveur, par exemple us-chronicle.googleapis.com.
Saisissez le port de votre serveur dans le champ Port, par exemple 443.
Saisissez votre point de terminaison Web dans le champ Point de terminaison. (Il s'agit du champ Informations sur le point de terminaison que vous avez copié à partir de la configuration du flux de webhook. Il est déjà au format requis.)
Dans la section En-têtes supplémentaires , saisissez les paramètres suivants, où chaque en-tête est un en-tête personnalisé sensible à la casse que vous saisissez manuellement :
- Nom de l'en-tête : X-goog-api-key , puis cliquez sur Créer l'option X-goog-api-key.
- Insertion de la valeur de l'en-tête : API_KEY (clé API pour s'authentifier auprès de Google SecOps).
- Nom de l'en-tête : X-Webhook-Access-Key , puis cliquez sur Créer l'option X-Webhook-Access-Key.
- Insertion de la valeur de l'en-tête : SECRET (clé secrète que vous avez générée pour authentifier le flux).
Cliquez sur Tester la configuration.
Si l'opération réussit, cliquez sur Créer la configuration.

Pour en savoir plus sur les flux Google SecOps, consultez Créer et gérer des flux à l'aide de l'interface utilisateur de gestion des flux. Pour en savoir plus sur les exigences de chaque type de flux, consultez API de configuration des flux.

Formats de journaux d'événements de menaces Jamf compatibles

L'analyseur d'événements de menaces Jamf est compatible avec les journaux au format JSON.

Exemples de journaux d'événements de menaces Jamf compatibles

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"
  }
}

Documentation de référence sur le mappage de champs

Le tableau suivant explique comment l'analyseur Google SecOps mappe les champs de journaux d'événements de menaces Jamf aux champs du modèle de données unifié (UDM) de Google SecOps.

Documentation de référence sur le mappage de champs : identifiant d'événement vers type d'événement

Le tableau suivant répertorie les types de journaux JAMF_THREAT_EVENTS et leurs types d'événements UDM correspondants.

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`

Documentation de référence sur le mappage de champs : JAMF_THREAT_EVENTS

Le tableau suivant répertorie les champs de journaux du type de journal JAMF_THREAT_EVENTS et leurs champs UDM correspondants.

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]`

Étape suivante

Ingérer des données dans Google SecOps

Journal des modifications

Consulter le journal des modifications de cet analyseur

Vous avez encore besoin d'aide ? Obtenez des réponses auprès des membres de la communauté et des professionnels Google SecOps.