Wir haben die Navigationsstruktur unserer Dokumentation neu organisiert, um sie direkt an Ihre betrieblichen Arbeitsabläufe anzupassen. Weitere Informationen finden Sie in den Versionshinweisen und im Video zur Anleitung.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Jamf Threat Events-Logs erfassen

Unterstützt in:

Google secops SIEM

In diesem Dokument wird beschrieben, wie Sie Jamf Threat Events-Logs erfassen können, indem Sie einen Google Security Operations-Feed einrichten. Außerdem wird erläutert, wie Logfelder Google SecOps-Feldern des einheitlichen Datenmodells (Unified Data Model, UDM) zugeordnet werden. In diesem Dokument ist auch die unterstützte Version von Jamf Threat Events aufgeführt.

Weitere Informationen finden Sie unter Datenaufnahme in Google SecOps.

Eine typische Bereitstellung besteht aus Jamf Threat Events und dem Google SecOps-Feed, der so konfiguriert ist, dass Logs an Google SecOps gesendet werden. Die Bereitstellung kann je nach Kunde variieren und komplexer sein.

Die Bereitstellung enthält die folgenden Komponenten:

Jamf Protect: Die Jamf Protect-Plattform, die mit der Jamf Security Cloud konfiguriert ist, auf der Sie Logs zu Netzwerkbedrohungen erfassen.
Google SecOps-Feed: Der Google SecOps-Feed, der Logs von Jamf Protect abruft und in Google SecOps schreibt.
Google SecOps: Google SecOps speichert und analysiert die Logs von Jamf Protect.

Ein Aufnahmelabel gibt den Parser an, der Rohdaten in das strukturierte UDM-Format normalisiert. Die Informationen in diesem Dokument gelten für den Parser mit dem Aufnahmelabel JAMF_THREAT_EVENTS.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

Eine Jamf Protect-Telemetrie-Einrichtung
Jamf Protect Version 4.0.0 oder höher
Alle Systeme in der Bereitstellungsarchitektur sind mit der Zeitzone UTC konfiguriert.

Feeds über „SIEM-Einstellungen“ > „Feeds“ einrichten

Sie können entweder Amazon S3 V2 oder einen Webhook verwenden, um einen Aufnahmefeed in Google SecOps einzurichten.

Aufnahmefeed mit Amazon S3 V2 einrichten

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf Neuen Feed hinzufügen.
Klicken Sie auf das Feedpaket JAMF.
Suchen Sie nach dem Feed Jamf Protect Threat Events.
Wählen Sie Amazon S3 V2 als Quelltyp aus.
Geben Sie die Werte für die folgenden Felder an.
- S3-URI: Der Bucket-URI.
  - s3://your-log-bucket-name/
    - Ersetzen Sie your-log-bucket-name durch den tatsächlichen Namen Ihres S3-Buckets.
- Optionen zum Löschen der Quelle: Wählen Sie die Löschoption entsprechend Ihren Aufnahmeeinstellungen aus.
- Maximale Dateialter: Enthält Dateien, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
- Zugriffsschlüssel-ID: Der Zugriffsschlüssel des Nutzers mit Berechtigungen zum Lesen aus dem S3-Bucket.
- Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Berechtigungen zum Lesen aus dem S3-Bucket.
Erweiterte Optionen
- Feedname: Ein vorab ausgefüllter Wert, der den Feed identifiziert.
- Asset-Namespace: Der mit dem Feed verknüpfte Namespace.
- Aufnahmelabels: Labels, die auf alle Ereignisse aus diesem Feed angewendet werden.
Klicken Sie auf Feed erstellen.

Aufnahmefeed mit einem Webhook einrichten

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf Neuen Feed hinzufügen.
Klicken Sie auf das Feedpaket JAMF.
Suchen Sie nach dem Feed Jamf Protect Threat Events.
Wählen Sie in der Liste Quelltyp die Option Webhook aus.
Geben Sie Werte für die folgenden Felder an:
- Trennzeichen für Aufteilung: Das Trennzeichen, das zum Trennen von Logzeilen verwendet wird, z. B. \n.
- Asset-Namespace: Der Asset-Namespace.
- Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.
Klicken Sie auf Feed erstellen.

Informationen zum Konfigurieren mehrerer Feeds für verschiedene Logtypen in dieser Produktfamilie finden Sie unter Feeds nach Produkt konfigurieren.

API-Schlüssel für einen Webhook-Feed erstellen

Rufen Sie die Google Cloud Console > Anmeldedaten auf.

Zu den Anmeldedaten
Klicken Sie auf Anmeldedaten erstellen und wählen Sie anschließend API-Schlüssel aus.
Beschränken Sie den API-Schlüsselzugriff auf die Google Security Operations API.

Jamf Security Cloud für einen Webhook-Feed einrichten

Rufen Sie in der Jamf Security Cloud-Anwendung Integrationen > Datenstreams auf.
Klicken Sie auf Neue Konfiguration.
Wählen Sie Bedrohungsereignisse > Allgemeines HTTP > Weiter aus.
Wählen Sie im Abschnitt HTTP-Verbindungskonfiguration die Option https als Standardprotokoll aus.
Geben Sie den Hostnamen Ihres Servers im Feld Server-Hostname/IP ein, z. B. us-chronicle.googleapis.com.
Geben Sie den Serverport im Feld Port ein, z. B. 443.
Geben Sie den Webendpunkt im Feld Endpunkt ein. Dies ist das Feld Endpunktinformationen , das Sie bei der Einrichtung des Webhook-Feeds kopiert haben. Es ist bereits im erforderlichen Format.
Geben Sie im Abschnitt Zusätzliche Header die folgenden Einstellungen ein. Jeder Header ist ein benutzerdefinierter, case-sensitiver Header, den Sie manuell eingeben:
- Headername: X-goog-api-key und klicken Sie auf Option „X-goog-api-key“ erstellen.
- Headerwert einfügen: API_KEY (der API-Schlüssel für die Authentifizierung bei Google SecOps).
- Headername: X-Webhook-Access-Key und klicken Sie auf Option „X-Webhook-Access-Key“ erstellen.
- Headerwert einfügen: SECRET (der geheime Schlüssel, den Sie zur Authentifizierung des Feeds generiert haben).
Klicken Sie auf Konfiguration testen.
Klicken Sie bei Erfolg auf Konfiguration erstellen.

Weitere Informationen zu Google SecOps-Feeds finden Sie unter Feeds über die UI für die Feedverwaltung erstellen und verwalten. Informationen zu den Anforderungen für die einzelnen Feedtypen finden Sie unter Feedkonfigurations-API.

Unterstützte Jamf Threat Events-Logformate

Der Jamf Threat Events-Parser unterstützt Logs im JSON-Format.

Unterstützte Jamf Threat Events-Beispiellogs

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

Referenz zur Feldzuordnung

In der folgenden Tabelle wird erläutert, wie der Google SecOps-Parser Jamf Threat Events-Logfelder Google SecOps-Feldern des einheitlichen Datenmodells (Unified Data Model, UDM) zuordnet.

Referenz zur Feldzuordnung: Ereigniskennung zu Ereignistyp

In der folgenden Tabelle sind die JAMF_THREAT_EVENTS-Logtypen und die entsprechenden UDM-Ereignistypen aufgeführt.

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`

Referenz zur Feldzuordnung: JAMF_THREAT_EVENTS

In der folgenden Tabelle sind die Logfelder des Logtyps JAMF_THREAT_EVENTS und die entsprechenden UDM-Felder aufgeführt.

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

Nächste Schritte

Datenaufnahme in Google SecOps

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten