Cette page a été traduite par l'API Cloud Translation.

Collecter les journaux des événements de menace Jamf

Compatible avec:

Google SecOps Siem

Ce document explique comment collecter les journaux des événements de menace Jamf en configurant un flux Google Security Operations, et comment les champs de journal correspondent aux champs du modèle de données unifié (UDM) de Google SecOps. Ce document indique également la version de Jamf Threat Events compatible.

Pour en savoir plus, consultez Ingestion de données dans Google SecOps.

Un déploiement typique comprend les événements de menace 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, dans laquelle vous collectez les journaux des menaces réseau.
Flux Google SecOps: flux Google SecOps qui extrait 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 journal 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 préalables suivantes:

Télémétrie Jamf Protect configurée
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

Il existe deux points d'entrée différents pour configurer des flux dans la plate-forme Google SecOps:

Paramètres du SIEM > Flux
Hub de contenu > Packs de contenu

Configurez les flux dans Paramètres du SIEM > Flux.

Vous pouvez utiliser Amazon S3 ou un webhook pour configurer un flux d'ingestion dans Google SecOps, mais nous vous recommandons d'utiliser Amazon S3.

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

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

Pour configurer un seul flux, procédez comme suit:

Accédez à SIEM Settings > Feeds (Paramètres du SIEM > Flux).
Cliquez sur Ajouter un flux.
Sur la page suivante, cliquez sur Configurer un flux.
Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Journaux des événements de menace Jamf).
Sélectionnez Amazon S3 comme Type de source.
Pour créer un flux pour les événements de menace Jamf, sélectionnez Événements de menace Jamf Protect comme Type de journal.
Cliquez sur Suivant.
Enregistrez le flux, puis cliquez sur Envoyer.
Copiez l'ID de flux à partir du nom du flux à utiliser dans Événements de menace Jamf.

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

Pour les clients Google Security Operations unifiés uniquement:
Pour configurer plusieurs flux pour différents types de journaux au sein de cette famille de produits, consultez Configurer plusieurs flux.

Pour tous les clients:
Pour configurer un seul flux, procédez comme suit:

Accédez à SIEM Settings > Feeds (Paramètres du SIEM > Flux).
Cliquez sur Ajouter un flux.
Sur la page suivante, cliquez sur Configurer un flux. Ignorez cette étape si vous utilisez la plate-forme SIEM autonome Google SecOps.
Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Journaux des événements de menace Jamf).
Dans la liste Type de source, sélectionnez Webhook.
Pour créer un flux pour les événements de menace Jamf, sélectionnez Événements de menace Jamf Protect comme Type de journal.
Cliquez sur Suivant.
Facultatif: Spécifiez les valeurs des paramètres d'entrée suivants :
- Délimiteur de fractionnement: 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 Suivant.
Vérifiez la configuration de votre nouveau flux dans l'écran Finaliser, puis cliquez sur Envoyer.
Cliquez sur Générer une clé secrète pour générer une clé secrète permettant d'authentifier ce flux.
Copiez et stockez la clé secrète, car vous ne pourrez plus la consulter. Vous pouvez générer à nouveau une clé secrète, mais la régénération de la clé secrète rend l'ancienne clé secrète obsolète.
Dans l'onglet Détails, copiez l'URL du point de terminaison du flux dans le champ Informations sur le point de terminaison. Vous devez spécifier cette URL de point de terminaison dans l'application Jamf Threat Events.
Cliquez sur OK.
Spécifiez l'URL du point de terminaison dans "Événements de menace Jamf".

Configurer des flux depuis le Centre de contenu

Indiquez les valeurs des champs suivants:

Région: région dans laquelle se trouve le bucket Amazon S3.
URI S3: URI du bucket.
- s3://your-log-bucket-name/
  - Remplacez your-log-bucket-name par le nom réel de votre bucket S3.
Un URI est: sélectionnez Répertoire ou Répertoire incluant des sous-répertoires, en fonction de la structure de votre bucket.
Options de suppression de la source: sélectionnez l'option de suppression en fonction de vos préférences d'ingestion.
ID de clé d'accès: clé d'accès de l'utilisateur disposant d'autorisations de lecture à partir du bucket S3.
Clé d'accès secrète: clé secrète de l'utilisateur avec autorisations de lecture à partir du bucket S3.

Options avancées

Nom du flux: valeur préremplie qui identifie le flux.
Source Type (Type de source) : méthode utilisée pour collecter les journaux dans Google SecOps.
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.

Créer une clé API pour un flux webhook

Accédez à Google Cloud console > Identifiants.

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

Configurer Jamf Security Cloud pour un flux webhook

Dans l'application Jamf Security Cloud, accédez à Intégrations > Flux de données.
Cliquez sur Nouvelle configuration.
Sélectionnez Événements de menace > 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 Server Hostname/IP (Nom d'hôte/Adresse 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 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 d'en-tête: API_KEY (clé API permettant de 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 d'en-tête: SECRET (clé secrète que vous avez générée pour authentifier le flux)
Cliquez sur Tester la configuration.
Si la validation aboutit, cliquez sur Créer une configuration.

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

Formats de journaux des événements de menace Jamf compatibles

L'analyseur d'événements de menace Jamf accepte les journaux au format JSON.

Exemples de journaux d'événements de menace 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"
  }
}

Référence de mappage de champ

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

Référence de mappage de champ: identifiant d'événement vers type d'événement

Le tableau suivant répertorie les types de journaux JAMF_THREAT_EVENTS et les 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`

Référence de mappage de champ: JAMF_THREAT_EVENTS

Le tableau suivant répertorie les champs de journal du type de journal JAMF_THREAT_EVENTS et les 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`
	`is_alert`	The `is_alert` UDM field is set to `TRUE`.
`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]`

Étapes suivantes

Ingestion de données dans Google SecOps

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