Cisco AMP for Endpoints-Logs erfassen

Unterstützt in:

Google SecOps SIEM

Hinweis: Dieses Feature unterliegt den Bedingungen des Pre-GA-Angebots in den dienstspezifischen Nutzungsbedingungen für Google Security Operations. Pre-GA-Features werden eventuell nur eingeschränkt unterstützt und Änderungen an diesen Features sind möglicherweise nicht mit anderen Pre-GA-Versionen kompatibel. Weitere Informationen finden Sie in den Richtlinien für den technischen Support von Google SecOps und den dienstspezifischen Nutzungsbedingungen für Google SecOps.

In diesem Dokument wird beschrieben, wie Sie Cisco AMP for Endpoints-Logs mit Amazon S3 in Google Security Operations aufnehmen. Der Parser wandelt Rohlogs im JSON-Format in ein strukturiertes Format um, das dem Chronicle UDM entspricht. Es extrahiert Felder aus verschachtelten JSON-Objekten, ordnet sie dem UDM-Schema zu, identifiziert Ereigniskategorien, weist Schweregrade zu und generiert schließlich eine einheitliche Ereignisausgabe, wobei Sicherheitswarnungen gekennzeichnet werden, wenn bestimmte Bedingungen erfüllt sind.

Hinweise

• Eine Google SecOps-Instanz
• Privilegierter Zugriff auf die Cisco AMP for Endpoints-Konsole
• Privilegierter Zugriff auf AWS (S3, IAM, Lambda, EventBridge)

Voraussetzungen für Cisco AMP for Endpoints erfassen (IDs, API-Schlüssel, Organisations-IDs, Tokens)

1. Melden Sie sich in der Cisco AMP for Endpoints-Konsole an.
2. Rufen Sie Konten > API-Anmeldedaten auf.
3. Klicken Sie auf New API Credential (Neue API-Anmeldedaten), um einen neuen API-Schlüssel und eine neue Client-ID zu erstellen.
4. Geben Sie die folgenden Konfigurationsdetails an:
   • Name der Anwendung: Geben Sie einen Namen ein, z. B. Chronicle SecOps Integration.
   • Umfang: Wählen Sie Nur lesen für das einfache Abrufen von Ereignissen oder Lesen und schreiben aus, wenn Sie Ereignisstreams erstellen möchten.
5. Klicken Sie auf Erstellen.
6. Kopieren Sie die folgenden Details und speichern Sie sie an einem sicheren Ort:
   • Drittanbieter-API-Client-ID
   • API-Schlüssel
   • API-Basis-URL: Je nach Region:
     • USA: https://api.amp.cisco.com
     • EU: https://api.eu.amp.cisco.com
     • APJC: https://api.apjc.amp.cisco.com

AWS S3-Bucket und IAM für Google SecOps konfigurieren

1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. cisco-amp-logs).
3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
4. Wählen Sie den erstellten Nutzer aus.
5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
7. Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
8. Klicken Sie auf Weiter.
9. Optional: Fügen Sie ein Beschreibungstag hinzu.
10. Klicken Sie auf Zugriffsschlüssel erstellen.
11. Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
12. Klicken Sie auf Fertig.
13. Wählen Sie den Tab Berechtigungen aus.
14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
15. Wählen Sie Berechtigungen hinzufügen aus.
16. Wählen Sie Richtlinien direkt anhängen aus.
17. Suchen Sie nach der Richtlinie AmazonS3FullAccess.
18. Wählen Sie die Richtlinie aus.
19. Klicken Sie auf Weiter.
20. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und ‑Rolle für S3-Uploads konfigurieren

1. Rufen Sie in der AWS-Konsole IAM > Richtlinien auf.
2. Klicken Sie auf Richtlinie erstellen> Tab „JSON“.

3. Geben Sie die folgende Richtlinie ein:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::cisco-amp-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::cisco-amp-logs/cisco-amp-events/state.json"
       }
     ]
   }
   

   • Ersetzen Sie cisco-amp-logs, wenn Sie einen anderen Bucket-Namen eingegeben haben.

4. Klicken Sie auf Weiter > Richtlinie erstellen.

5. Rufen Sie IAM > Rollen > Rolle erstellen > AWS-Service > Lambda auf.

6. Hängen Sie die neu erstellte Richtlinie an.

7. Geben Sie der Rolle den Namen cisco-amp-lambda-role und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
2. Klicken Sie auf Von Grund auf erstellen.

3. Geben Sie die folgenden Konfigurationsdetails an:

   Einstellung	Wert
   Name	cisco-amp-events-collector
   Laufzeit	Python 3.13
   Architektur	x86_64
   Ausführungsrolle	cisco-amp-lambda-role

4. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und geben Sie den folgenden Code ein (cisco-amp-events-collector.py):

   import json
   import boto3
   import urllib3
   import base64
   from datetime import datetime, timedelta
   import os
   import logging
   
   # Configure logging
   logger = logging.getLogger()
   logger.setLevel(logging.INFO)
   
   # AWS S3 client and HTTP pool manager
   s3_client = boto3.client('s3')
   http = urllib3.PoolManager()
   
   def lambda_handler(event, context):
       """
       AWS Lambda handler to fetch Cisco AMP events and store them in S3
       """
   
       try:
           # Get environment variables
           s3_bucket = os.environ['S3_BUCKET']
           s3_prefix = os.environ['S3_PREFIX']
           state_key = os.environ['STATE_KEY']
           api_client_id = os.environ['AMP_CLIENT_ID']
           api_key = os.environ['AMP_API_KEY']
           api_base = os.environ['API_BASE']
   
           # Optional parameters
           page_size = int(os.environ.get('PAGE_SIZE', '500'))
           max_pages = int(os.environ.get('MAX_PAGES', '10'))
   
           logger.info(f"Starting Cisco AMP events collection for bucket: {s3_bucket}")
   
           # Get last run timestamp from state file
           last_timestamp = get_last_timestamp(s3_bucket, state_key)
           if not last_timestamp:
               last_timestamp = (datetime.utcnow() - timedelta(days=1)).isoformat() + 'Z'
   
           # Create Basic Auth header
           auth_header = base64.b64encode(f"{api_client_id}:{api_key}".encode()).decode()
           headers = {
               'Authorization': f'Basic {auth_header}',
               'Accept': 'application/json'
           }
   
           # Build initial API URL
           base_url = f"{api_base}/v1/events"
           next_url = f"{base_url}?limit={page_size}&start_date={last_timestamp}"
   
           all_events = []
           page_count = 0
   
           while next_url and page_count < max_pages:
               logger.info(f"Fetching page {page_count + 1} from: {next_url}")
   
               # Make API request using urllib3
               response = http.request('GET', next_url, headers=headers, timeout=60)
   
               if response.status != 200:
                   raise RuntimeError(f"API request failed: {response.status} {response.data[:256]!r}")
   
               data = json.loads(response.data.decode('utf-8'))
   
               # Extract events from response
               events = data.get('data', [])
               if events:
                   all_events.extend(events)
                   logger.info(f"Collected {len(events)} events from page {page_count + 1}")
   
                   # Check for next page
                   next_url = data.get('metadata', {}).get('links', {}).get('next')
                   page_count += 1
               else:
                   logger.info("No events found on current page")
                   break
   
           logger.info(f"Total events collected: {len(all_events)}")
   
           # Store events in S3 if any were collected
           if all_events:
               timestamp_str = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
               s3_key = f"{s3_prefix}cisco_amp_events_{timestamp_str}.ndjson"
   
               # Convert events to NDJSON format (one JSON object per line)
               ndjson_content = 'n'.join(json.dumps(event) for event in all_events)
   
               # Upload to S3
               s3_client.put_object(
                   Bucket=s3_bucket,
                   Key=s3_key,
                   Body=ndjson_content.encode('utf-8'),
                   ContentType='application/x-ndjson'
               )
   
               logger.info(f"Uploaded {len(all_events)} events to s3://{s3_bucket}/{s3_key}")
   
           # Update state file with current timestamp
           current_timestamp = datetime.utcnow().isoformat() + 'Z'
           update_state(s3_bucket, state_key, current_timestamp)
   
           return {
               'statusCode': 200,
               'body': json.dumps({
                   'message': 'Success',
                   'events_collected': len(all_events),
                   'pages_processed': page_count
               })
           }
   
       except Exception as e:
           logger.error(f"Error in lambda_handler: {str(e)}")
           return {
               'statusCode': 500,
               'body': json.dumps({
                   'error': str(e)
               })
           }
   
   def get_last_timestamp(bucket, state_key):
       """
       Get the last run timestamp from S3 state file
       """
       try:
           response = s3_client.get_object(Bucket=bucket, Key=state_key)
           state_data = json.loads(response['Body'].read().decode('utf-8'))
           return state_data.get('last_timestamp')
       except s3_client.exceptions.NoSuchKey:
           logger.info("No state file found, starting from 24 hours ago")
           return None
       except Exception as e:
           logger.warning(f"Error reading state file: {str(e)}")
           return None
   
   def update_state(bucket, state_key, timestamp):
       """
       Update the state file with the current timestamp
       """
       try:
           state_data = {
               'last_timestamp': timestamp,
               'updated_at': datetime.utcnow().isoformat() + 'Z'
           }
   
           s3_client.put_object(
               Bucket=bucket,
               Key=state_key,
               Body=json.dumps(state_data).encode('utf-8'),
               ContentType='application/json'
           )
   
           logger.info(f"Updated state file with timestamp: {timestamp}")
   
       except Exception as e:
           logger.error(f"Error updating state file: {str(e)}")
   

5. Rufen Sie Konfiguration > Umgebungsvariablen auf.

6. Klicken Sie auf Bearbeiten> Neue Umgebungsvariable hinzufügen.

7. Geben Sie die folgenden Umgebungsvariablen ein und ersetzen Sie die Platzhalter durch Ihre Werte.

   Schlüssel	Beispielwert
   S3_BUCKET	cisco-amp-logs
   S3_PREFIX	cisco-amp-events/
   STATE_KEY	cisco-amp-events/state.json
   AMP_CLIENT_ID	<your-client-id>
   AMP_API_KEY	<your-api-key>
   API_BASE	https://api.amp.cisco.com (oder die URL Ihrer Region)
   PAGE_SIZE	500
   MAX_PAGES	10

8. Bleiben Sie nach dem Erstellen der Funktion auf der zugehörigen Seite oder öffnen Sie Lambda > Funktionen > cisco-amp-events-collector.

9. Wählen Sie den Tab Konfiguration aus.

10. Klicken Sie im Bereich Allgemeine Konfiguration auf Bearbeiten.

11. Ändern Sie Zeitlimit in 5 Minuten (300 Sekunden) und klicken Sie auf Speichern.

    Hinweis :Das Zeitlimit ist eine harte Obergrenze. Wenn die Funktion also noch ausgeführt wird, wenn der Timer 5 Minuten erreicht, wird sie von AWS Lambda beendet. Kürzere Ausführungen werden einfach normal beendet. Ihnen wird nur die tatsächliche Laufzeit in Rechnung gestellt.

EventBridge-Zeitplan erstellen

1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).
2. Geben Sie die folgenden Konfigurationsdetails an:
   • Wiederkehrender Zeitplan: Preis (1 hour).
   • Ziel: Ihre Lambda-Funktion cisco-amp-events-collector.
   • Name: cisco-amp-events-collector-1h.
3. Klicken Sie auf Zeitplan erstellen.

Optional: IAM-Nutzer mit Lesezugriff und Schlüssel für Google SecOps erstellen

1. Rufen Sie die AWS-Konsole > IAM > Nutzer > Nutzer hinzufügen auf.
2. Klicken Sie auf Add users (Nutzer hinzufügen).
3. Geben Sie die folgenden Konfigurationsdetails an:
   • Nutzer: Geben Sie secops-reader ein.
   • Zugriffstyp: Wählen Sie Zugriffsschlüssel – programmatischer Zugriff aus.
4. Klicken Sie auf Nutzer erstellen.
5. Minimale Leseberechtigung (benutzerdefiniert) anhängen: Nutzer > secops-reader > Berechtigungen > Berechtigungen hinzufügen > Richtlinien direkt anhängen > Richtlinie erstellen.

6. Geben Sie im JSON-Editor die folgende Richtlinie ein:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["s3:GetObject"],
         "Resource": "arn:aws:s3:::cisco-amp-logs/*"
       },
       {
         "Effect": "Allow",
         "Action": ["s3:ListBucket"],
         "Resource": "arn:aws:s3:::cisco-amp-logs"
       }
     ]
   }
   

7. Legen Sie secops-reader-policy als Name fest.

8. Gehen Sie zu Richtlinie erstellen> suchen/auswählen > Weiter > Berechtigungen hinzufügen.

9. Rufen Sie Sicherheitsanmeldedaten > Zugriffsschlüssel > Zugriffsschlüssel erstellen auf.

10. Laden Sie die CSV herunter (diese Werte werden in den Feed eingegeben).

Feed in Google SecOps konfigurieren, um Cisco AMP for Endpoints-Logs aufzunehmen

1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
2. Klicken Sie auf + Neuen Feed hinzufügen.
3. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Cisco AMP for Endpoints logs.
4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
5. Wählen Sie Cisco AMP als Logtyp aus.
6. Klicken Sie auf Weiter.
7. Geben Sie Werte für die folgenden Eingabeparameter an:
   • S3-URI: s3://cisco-amp-logs/cisco-amp-events/
   • Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus.
   • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
   • Zugriffsschlüssel-ID: Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
   • Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
   • Asset-Namespace: Der Asset-Namespace.
   • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
8. Klicken Sie auf Weiter.
9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Logfeld	UDM-Zuordnung	Logik
Aktiv	read_only_udm.principal.asset.active	Direkt aus computer.active zugeordnet
connector_guid	read_only_udm.principal.asset.uuid	Direkt aus computer.connector_guid zugeordnet
Datum	read_only_udm.metadata.event_timestamp.seconds	Direkt aus date zugeordnet, nachdem die Daten in einen Zeitstempel konvertiert wurden
Erkennung	read_only_udm.security_result.threat_name	Direkt aus detection zugeordnet
detection_id	read_only_udm.security_result.detection_fields.value	Direkt aus detection_id zugeordnet
disposition	read_only_udm.security_result.description	Direkt aus file.disposition zugeordnet
error.error_code	read_only_udm.security_result.detection_fields.value	Direkt aus error.error_code zugeordnet
error.description	read_only_udm.security_result.detection_fields.value	Direkt aus error.description zugeordnet
event_type	read_only_udm.metadata.product_event_type	Direkt aus event_type zugeordnet
event_type_id	read_only_udm.metadata.product_log_id	Direkt aus event_type_id zugeordnet
external_ip	read_only_udm.principal.asset.external_ip	Direkt aus computer.external_ip zugeordnet
file.file_name	read_only_udm.target.file.names	Direkt aus file.file_name zugeordnet
file.file_path	read_only_udm.target.file.full_path	Direkt aus file.file_path zugeordnet
file.identity.md5	read_only_udm.security_result.about.file.md5	Direkt aus file.identity.md5 zugeordnet
file.identity.md5	read_only_udm.target.file.md5	Direkt aus file.identity.md5 zugeordnet
file.identity.sha1	read_only_udm.security_result.about.file.sha1	Direkt aus file.identity.sha1 zugeordnet
file.identity.sha1	read_only_udm.target.file.sha1	Direkt aus file.identity.sha1 zugeordnet
file.identity.sha256	read_only_udm.security_result.about.file.sha256	Direkt aus file.identity.sha256 zugeordnet
file.identity.sha256	read_only_udm.target.file.sha256	Direkt aus file.identity.sha256 zugeordnet
file.parent.disposition	read_only_udm.target.resource.attribute.labels.value	Direkt aus file.parent.disposition zugeordnet
file.parent.file_name	read_only_udm.target.resource.attribute.labels.value	Direkt aus file.parent.file_name zugeordnet
file.parent.identity.md5	read_only_udm.target.resource.attribute.labels.value	Direkt aus file.parent.identity.md5 zugeordnet
file.parent.identity.sha1	read_only_udm.target.resource.attribute.labels.value	Direkt aus file.parent.identity.sha1 zugeordnet
file.parent.identity.sha256	read_only_udm.target.resource.attribute.labels.value	Direkt aus file.parent.identity.sha256 zugeordnet
file.parent.process_id	read_only_udm.security_result.about.process.parent_process.pid	Direkt aus file.parent.process_id zugeordnet
file.parent.process_id	read_only_udm.target.process.parent_process.pid	Direkt aus file.parent.process_id zugeordnet
Hostname	read_only_udm.principal.asset.hostname	Direkt aus computer.hostname zugeordnet
Hostname	read_only_udm.target.hostname	Direkt aus computer.hostname zugeordnet
Hostname	read_only_udm.target.asset.hostname	Direkt aus computer.hostname zugeordnet
ip	read_only_udm.principal.asset.ip	Direkt aus computer.network_addresses.ip zugeordnet
ip	read_only_udm.principal.ip	Direkt aus computer.network_addresses.ip zugeordnet
ip	read_only_udm.security_result.about.ip	Direkt aus computer.network_addresses.ip zugeordnet
mac	read_only_udm.principal.mac	Direkt aus computer.network_addresses.mac zugeordnet
mac	read_only_udm.security_result.about.mac	Direkt aus computer.network_addresses.mac zugeordnet
die Ausprägung	read_only_udm.security_result.severity	Zugeordnet aus severity basierend auf der folgenden Logik:  – „Mittel“ –> „MEDIUM“  – „Hoch“ oder „Kritisch“ –> „HIGH“  – „Niedrig“ –> „LOW“  – Andernfalls –> „UNKNOWN_SEVERITY“
timestamp	read_only_udm.metadata.event_timestamp.seconds	Direkt aus timestamp zugeordnet
Nutzer	read_only_udm.security_result.about.user.user_display_name	Direkt aus computer.user zugeordnet
Nutzer	read_only_udm.target.user.user_display_name	Direkt aus computer.user zugeordnet
vulnerabilities.cve	read_only_udm.extensions.vulns.vulnerabilities.cve_id	Direkt aus vulnerabilities.cve zugeordnet
vulnerabilities.name	read_only_udm.extensions.vulns.vulnerabilities.name	Direkt aus vulnerabilities.name zugeordnet
vulnerabilities.score	read_only_udm.extensions.vulns.vulnerabilities.cvss_base_score	Direkt aus vulnerabilities.score zugeordnet nach der Konvertierung in Gleitkommazahlen
vulnerabilities.url	read_only_udm.extensions.vulns.vulnerabilities.vendor_knowledge_base_article_id	Direkt aus vulnerabilities.url zugeordnet
vulnerabilities.version	read_only_udm.extensions.vulns.vulnerabilities.cvss_version	Direkt aus vulnerabilities.version zugeordnet
	is_alert	Auf „true“ gesetzt, wenn event_type eine der folgenden Optionen ist: „Threat Detected“ (Bedrohung erkannt), „Exploit Prevention“ (Exploit-Schutz), „Executed malware“ (Ausgeführte Malware), „Potential Dropper Infection“ (Mögliche Dropper-Infektion), „Multiple Infected Files“ (Mehrere infizierte Dateien), „Vulnerable Application Detected“ (Schwachstelle in Anwendung erkannt) oder wenn security_result.severity „HIGH“ (HOCH) ist.
	is_significant	Auf „true“ gesetzt, wenn event_type eine der folgenden Optionen ist: „Threat Detected“ (Bedrohung erkannt), „Exploit Prevention“ (Exploit-Schutz), „Executed malware“ (Ausgeführte Malware), „Potential Dropper Infection“ (Mögliche Dropper-Infektion), „Multiple Infected Files“ (Mehrere infizierte Dateien), „Vulnerable Application Detected“ (Schwachstelle in Anwendung erkannt) oder wenn security_result.severity „HIGH“ (HOCH) ist.
	read_only_udm.metadata.event_type	Wird anhand der Werte für event_type und security_result.severity bestimmt.  – Wenn event_type einer der folgenden Werte ist: „Executed malware“ (Ausgeführte Malware), „Threat Detected“ (Bedrohung erkannt), „Potential Dropper Infection“ (Mögliche Dropper-Infektion), „Cloud Recall Detection“ (Cloud Recall-Erkennung), „Malicious Activity Detection“ (Erkennung schädlicher Aktivitäten), „Exploit Prevention“ (Exploit-Schutz), „Multiple Infected Files“ (Mehrere infizierte Dateien), „Cloud IOC“ (Cloud-IOC), „System Process Protection“ (Schutz von Systemprozessen), „Vulnerable Application Detected“ (Schwachstelle in Anwendung erkannt), „Threat Quarantined“ (Bedrohung unter Quarantäne gestellt), „Execution Blocked“ (Ausführung blockiert), „Cloud Recall Quarantine Successful“ (Cloud Recall-Quarantäne erfolgreich), „Cloud Recall Restore from Quarantine Failed“ (Cloud Recall-Wiederherstellung aus Quarantäne fehlgeschlagen), „Cloud Recall Quarantine Attempt Failed“ (Cloud Recall-Quarantäneversuch fehlgeschlagen), „Quarantine Failure“ (Quarantäne fehlgeschlagen), wird der Ereignistyp auf „SCAN_FILE“ festgelegt.  – Wenn security_result.severity auf „HIGH“ gesetzt ist, wird der Ereignistyp auf „SCAN_FILE“ festgelegt.  – Wenn sowohl has_principal als auch has_target „true“ sind, wird der Ereignistyp auf „SCAN_UNCATEGORIZED“ gesetzt.  – Andernfalls wird der Ereignistyp auf „GENERIC_EVENT“ festgelegt.
	read_only_udm.metadata.log_type	Auf „CISCO_AMP“ festgelegt
	read_only_udm.metadata.vendor_name	Auf „CISCO_AMP“ festgelegt
	read_only_udm.security_result.about.file.full_path	Direkt aus file.file_path zugeordnet
	read_only_udm.security_result.about.hostname	Direkt aus computer.hostname zugeordnet
	read_only_udm.security_result.about.user.user_display_name	Direkt aus computer.user zugeordnet
	read_only_udm.security_result.detection_fields.key	Legen Sie für detection_id „Detection ID“ (Erkennungs-ID), für error.error_code „Error Code“ (Fehlercode), für error.description „Error Description“ (Fehlerbeschreibung), für file.parent.disposition „Parent Disposition“ (Übergeordnete Disposition), für file.parent.file_name „Parent File Name“ (Übergeordneter Dateiname), für file.parent.identity.md5 „Parent MD5“ (Übergeordneter MD5-Hash), für file.parent.identity.sha1 „Parent SHA1“ (Übergeordneter SHA1-Hash) und für file.parent.identity.sha256 „Parent SHA256“ (Übergeordneter SHA256-Hash) fest.
	read_only_udm.security_result.summary	Auf event_type festgelegt, wenn event_type einer der folgenden Werte ist: „Bedrohung erkannt“, „Exploit-Schutz“, „Ausgeführte Malware“, „Mögliche Dropper-Infektion“, „Mehrere infizierte Dateien“, „Schwachstelle in Anwendung erkannt“ oder wenn security_result.severity „HOCH“ ist.
	read_only_udm.target.asset.ip	Direkt aus computer.network_addresses.ip zugeordnet
	read_only_udm.target.resource.attribute.labels.key	Auf „Parent Disposition“ für file.parent.disposition, „Parent File Name“ für file.parent.file_name, „Parent MD5“ für file.parent.identity.md5, „Parent SHA1“ für file.parent.identity.sha1 und „Parent SHA256“ für file.parent.identity.sha256 festlegen
	timestamp.seconds	Direkt aus date zugeordnet, nachdem die Daten in einen Zeitstempel konvertiert wurden

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