Cisco AMP for Endpoints-Logs erfassen

Unterstützt in:

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 Event Streams 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 Console die Seite 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. Gehen Sie zu IAM > Rollen > Rolle erstellen > AWS-Service > Lambda.

  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 für Ihre 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.

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 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“ gesetzt.
 – 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“ festgelegt.
 – 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 setzen, wenn event_type eine der folgenden Optionen ist: „Bedrohung erkannt“, „Exploit-Schutz“, „Ausgeführte Malware“, „Potenzielle 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