Collecter les journaux Cisco AMP for Endpoints

Compatible avec :

Ce document explique comment ingérer les journaux Cisco AMP for Endpoints dans Google Security Operations à l'aide de Google Cloud Storage. L'analyseur transforme les journaux bruts au format JSON en un format structuré conforme à l'UDM Chronicle. Il extrait les champs des objets JSON imbriqués, les mappe au schéma UDM, identifie les catégories d'événements, attribue des niveaux de gravité et génère finalement une sortie d'événement unifiée, en signalant les alertes de sécurité lorsque des conditions spécifiques sont remplies.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

  • Une instance Google SecOps
  • Projet GCP avec l'API Cloud Storage activée
  • Autorisations pour créer et gérer des buckets GCS
  • Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des tâches Cloud Scheduler
  • Accès privilégié à la console Cisco AMP for Endpoints

Collecter les identifiants de l'API Cisco AMP for Endpoints

  1. Connectez-vous à la console Cisco AMP for Endpoints.
  2. Accédez à Comptes> Identifiants de l'API.
  3. Cliquez sur Nouvel identifiant API pour créer une clé API et un ID client.
  4. Fournissez les informations de configuration suivantes :
    • Nom de l'application : saisissez un nom (par exemple, Chronicle SecOps Integration).
    • Portée : sélectionnez Lecture seule pour l'interrogation d'événements de base.
  5. Cliquez sur Créer.
  6. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
    • ID client 3API
    • Clé API
    • URL de base de l'API : selon votre région :
      • États-Unis : https://api.amp.cisco.com
      • UE : https://api.eu.amp.cisco.com
      • APJC : https://api.apjc.amp.cisco.com

Vérifier les autorisations

Pour vérifier que le compte dispose des autorisations requises :

  1. Connectez-vous à la console Cisco AMP for Endpoints.
  2. Accédez à Comptes> Identifiants de l'API.
  3. Si vous pouvez accéder à la page Identifiants d'API et que les identifiants que vous venez de créer y figurent, vous disposez des autorisations requises.
  4. Si cette option ne s'affiche pas, contactez votre administrateur pour qu'il vous accorde les autorisations d'accès à l'API.

Tester l'accès à l'API

  • Testez vos identifiants avant de procéder à l'intégration :

    # Replace with your actual credentials
AMP_CLIENT_ID="your-client-id"
AMP_API_KEY="your-api-key"
API_BASE="https://api.amp.cisco.com"

# Test API access
curl -v -u "${AMP_CLIENT_ID}:${AMP_API_KEY}" "${API_BASE}/v1/events?limit=1"

Créer un bucket Google Cloud Storage

  1. Accédez à la consoleGoogle Cloud .
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage> Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nommer votre bucket Saisissez un nom unique (par exemple, cisco-amp-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions des objets ou la règle de conservation

  6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service disposant des autorisations nécessaires pour écrire dans le bucket GCS et être appelée par Pub/Sub.

Créer un compte de service

  1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez cisco-amp-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Cisco AMP for Endpoints logs.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets de l'espace de stockage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. Cliquez sur OK.

Ces rôles sont requis pour :

  • Administrateur des objets Storage : écrire des journaux dans le bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction
  • Demandeur Cloud Functions : autorise l'appel de fonctions

Accorder des autorisations IAM sur un bucket GCS

Accordez au compte de service (cisco-amp-collector-sa) des autorisations d'écriture sur le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, cisco-amp-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
  6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub auquel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Create topic (Créer un sujet).
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez cisco-amp-events-trigger.
    • Conservez les valeurs par défaut des autres paramètres.
  4. Cliquez sur Créer.

Créer une fonction Cloud Run pour collecter les journaux

La fonction Cloud Run sera déclenchée par les messages Pub/Sub de Cloud Scheduler pour extraire les journaux de l'API Cisco AMP for Endpoints et les écrire dans GCS.

  1. Dans la console GCP, accédez à Cloud Run.
  2. Cliquez sur Créer un service.
  3. Sélectionnez Fonction (utilisez un éditeur intégré pour créer une fonction).

  4. Dans la section Configurer, fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom du service cisco-amp-events-collector
    Région Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
    Runtime (durée d'exécution) Sélectionnez Python 3.12 ou version ultérieure.

  5. Dans la section Déclencheur (facultatif) :

    1. Cliquez sur + Ajouter un déclencheur.
    2. Sélectionnez Cloud Pub/Sub.
    3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet Pub/Sub (cisco-amp-events-trigger).
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    • Sélectionnez Exiger l'authentification.
    • Sélectionnez Identity and Access Management (IAM).
  1. Faites défiler la page jusqu'à Conteneurs, mise en réseau, sécurité, puis développez cette section.
  2. Accédez à l'onglet Sécurité :
    • Compte de service : sélectionnez le compte de service (cisco-amp-collector-sa).

  3. Accédez à l'onglet Conteneurs :

    • Cliquez sur Variables et secrets.

    • Cliquez sur + Ajouter une variable pour chaque variable d'environnement :

      Nom de la variable Exemple de valeur Description
      GCS_BUCKET cisco-amp-logs Nom du bucket GCS
      GCS_PREFIX cisco-amp-events/ Préfixe des fichiers journaux
      STATE_KEY cisco-amp-events/state.json Chemin d'accès au fichier d'état
      API_BASE https://api.amp.cisco.com URL de base de l'API
      AMP_CLIENT_ID your-client-id ID client de l'API
      AMP_API_KEY your-api-key Clé API
      PAGE_SIZE 500 Enregistrements par page
      MAX_PAGES 10 Nombre maximal de pages à extraire

  4. Dans la section Variables et secrets, faites défiler la page jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 600 secondes (10 minutes).

  5. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.

  6. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

  7. Cliquez sur Créer.

  8. Attendez que le service soit créé (1 à 2 minutes).

  9. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

  1. Saisissez main dans le champ Point d'entrée.

  2. Dans l'éditeur de code intégré, créez deux fichiers :

    • Premier fichier : main.py:
    import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time
import base64

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=30.0),
    retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-amp-events/')
STATE_KEY = os.environ.get('STATE_KEY', 'cisco-amp-events/state.json')
API_BASE = os.environ.get('API_BASE')
AMP_CLIENT_ID = os.environ.get('AMP_CLIENT_ID')
AMP_API_KEY = os.environ.get('AMP_API_KEY')
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '500'))
MAX_PAGES = int(os.environ.get('MAX_PAGES', '10'))

def parse_datetime(value: str) -> datetime:
    """Parse ISO datetime string to datetime object."""
    if value.endswith("Z"):
        value = value[:-1] + "+00:00"
    return datetime.fromisoformat(value)

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch Cisco AMP events and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    if not all([GCS_BUCKET, API_BASE, AMP_CLIENT_ID, AMP_API_KEY]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load state
        state = load_state(bucket, STATE_KEY)

        # Determine time window
        now = datetime.now(timezone.utc)
        last_time = None

        if isinstance(state, dict) and state.get("last_event_time"):
            try:
                last_time = parse_datetime(state["last_event_time"])
                # Overlap by 2 minutes to catch any delayed events
                last_time = last_time - timedelta(minutes=2)
            except Exception as e:
                print(f"Warning: Could not parse last_event_time: {e}")

        if last_time is None:
            last_time = now - timedelta(days=1)

        print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")

        # Fetch logs
        records, newest_event_time = fetch_logs(
            api_base=API_BASE,
            client_id=AMP_CLIENT_ID,
            api_key=AMP_API_KEY,
            start_time=last_time,
            page_size=PAGE_SIZE,
            max_pages=MAX_PAGES,
        )

        if not records:
            print("No new log records found.")
            save_state(bucket, STATE_KEY, now.isoformat())
            return

        # Write to GCS as NDJSON
        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = f"{GCS_PREFIX}cisco_amp_events_{timestamp}.ndjson"
        blob = bucket.blob(object_key)

        ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in records]) + '\n'
        blob.upload_from_string(ndjson, content_type='application/x-ndjson')

        print(f"Wrote {len(records)} records to gs://{GCS_BUCKET}/{object_key}")

        # Update state with newest event time
        if newest_event_time:
            save_state(bucket, STATE_KEY, newest_event_time)
        else:
            save_state(bucket, STATE_KEY, now.isoformat())

        print(f"Successfully processed {len(records)} records")

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

def load_state(bucket, key):
    """Load state from GCS."""
    try:
        blob = bucket.blob(key)
        if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
    except Exception as e:
        print(f"Warning: Could not load state: {e}")

    return {}

def save_state(bucket, key, last_event_time_iso: str):
    """Save the last event timestamp to GCS state file."""
    try:
        state = {'last_event_time': last_event_time_iso}
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print(f"Saved state: last_event_time={last_event_time_iso}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def fetch_logs(api_base: str, client_id: str, api_key: str, start_time: datetime, page_size: int, max_pages: int):
    """
    Fetch logs from Cisco AMP for Endpoints API with pagination and rate limiting.

    Args:
        api_base: API base URL
        client_id: API client ID
        api_key: API key
        start_time: Start time for log query
        page_size: Number of records per page
        max_pages: Maximum total pages to fetch

    Returns:
        Tuple of (records list, newest_event_time ISO string)
    """
    # Clean up base URL
    base_url = api_base.rstrip('/')

    endpoint = f"{base_url}/v1/events"

    # Create Basic Auth header
    auth_string = f"{client_id}:{api_key}"
    auth_bytes = auth_string.encode('utf-8')
    auth_b64 = base64.b64encode(auth_bytes).decode('utf-8')

    headers = {
        'Authorization': f'Basic {auth_b64}',
        'Accept': 'application/json',
        'User-Agent': 'GoogleSecOps-CiscoAMPCollector/1.0'
    }

    records = []
    newest_time = None
    page_num = 0
    backoff = 1.0

    # Build initial URL with start_date parameter
    start_date_str = start_time.isoformat() + 'Z' if not start_time.isoformat().endswith('Z') else start_time.isoformat()
    next_url = f"{endpoint}?limit={page_size}&start_date={start_date_str}"

    while next_url and page_num < max_pages:
        page_num += 1

        try:
            response = http.request('GET', next_url, headers=headers)

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
                print(f"Rate limited (429). Retrying after {retry_after}s...")
                time.sleep(retry_after)
                backoff = min(backoff * 2, 30.0)
                continue

            backoff = 1.0

            if response.status != 200:
                print(f"HTTP Error: {response.status}")
                response_text = response.data.decode('utf-8')
                print(f"Response body: {response_text[:256]}")
                return [], None

            data = json.loads(response.data.decode('utf-8'))

            # Extract events from response
            page_results = data.get('data', [])

            if not page_results:
                print(f"No more results (empty page)")
                break

            print(f"Page {page_num}: Retrieved {len(page_results)} events")
            records.extend(page_results)

            # Track newest event time
            for event in page_results:
                try:
                    event_time = event.get('date')
                    if event_time:
                        if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time):
                            newest_time = event_time
                except Exception as e:
                    print(f"Warning: Could not parse event time: {e}")

            # Check for next page URL in metadata
            next_url = data.get('metadata', {}).get('links', {}).get('next')

            if not next_url:
                print("No more pages (no next URL)")
                break

        except Exception as e:
            print(f"Error fetching logs: {e}")
            return [], None

    print(f"Retrieved {len(records)} total records from {page_num} pages")
    return records, newest_time
    • Deuxième fichier : requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

  4. Attendez la fin du déploiement (deux à trois minutes).

Créer une tâche Cloud Scheduler

Cloud Scheduler publie des messages sur le sujet Pub/Sub à intervalles réguliers, ce qui déclenche la fonction Cloud Run.

  1. Dans la console GCP, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom cisco-amp-events-collector-hourly
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Topic Sélectionnez le sujet Pub/Sub (cisco-amp-events-trigger).
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de planification

  • Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :

    Fréquence Expression Cron Cas d'utilisation
    Toutes les 5 minutes */5 * * * * Volume élevé, faible latence
    Toutes les 15 minutes */15 * * * * Volume moyen
    Toutes les heures 0 * * * * Standard (recommandé)
    Toutes les 6 heures 0 */6 * * * Traitement par lot à faible volume
    Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de votre fonction (cisco-amp-events-collector).
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Recherchez les éléments suivants :

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Wrote X records to gs://cisco-amp-logs/cisco-amp-events/cisco_amp_events_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

  10. Accédez au dossier de préfixe (cisco-amp-events/).

  11. Vérifiez qu'un fichier .ndjson a été créé avec le code temporel actuel.

Si vous constatez des erreurs dans les journaux :

  • HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement
  • HTTP 403 : vérifiez que le compte dispose des autorisations requises.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un intervalle de temps.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cisco AMP for Endpoints logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Cisco AMP comme Type de journal.

  7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique pour le compte de service s'affiche, par exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin du rôle Lecteur des objets Storage sur votre bucket GCS.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuez des rôles : sélectionnez Lecteur des objets de l'espace de stockage.
  6. Cliquez sur Enregistrer.

Configurer un flux dans Google SecOps pour ingérer les journaux Cisco AMP for Endpoints

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cisco AMP for Endpoints logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Cisco AMP comme Type de journal.
  7. Cliquez sur Suivant.

  8. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket Storage : saisissez l'URI du bucket GCS avec le préfixe du chemin d'accès :

      gs://cisco-amp-logs/cisco-amp-events/
      • Remplacez :
        • cisco-amp-logs : nom de votre bucket GCS.
        • cisco-amp-events/ : préfixe/chemin d'accès au dossier dans lequel les journaux sont stockés.

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.

      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.

    • 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.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
actif read_only_udm.principal.asset.active Directement mappé à partir de computer.active
connector_guid read_only_udm.principal.asset.uuid Mappé directement à partir de computer.connector_guid
date read_only_udm.metadata.event_timestamp.seconds Mappé directement à partir de la date après conversion en code temporel
détection read_only_udm.security_result.threat_name Mappé directement à partir de la détection
detection_id read_only_udm.security_result.detection_fields.value Mappé directement à partir de detection_id
disposition read_only_udm.security_result.description Directement mappé à partir de file.disposition
error.error_code read_only_udm.security_result.detection_fields.value Mappé directement à partir de error.error_code
error.description read_only_udm.security_result.detection_fields.value Mappé directement à partir de error.description
event_type read_only_udm.metadata.product_event_type Mappé directement à partir de event_type
event_type_id read_only_udm.metadata.product_log_id Mappé directement à partir de event_type_id
external_ip read_only_udm.principal.asset.external_ip Mappé directement à partir de computer.external_ip
file.file_name read_only_udm.target.file.names Directement mappé à partir de file.file_name
file.file_path read_only_udm.target.file.full_path Directement mappé à partir de file.file_path
file.identity.md5 read_only_udm.security_result.about.file.md5 Mappé directement à partir de file.identity.md5
file.identity.md5 read_only_udm.target.file.md5 Mappé directement à partir de file.identity.md5
file.identity.sha1 read_only_udm.security_result.about.file.sha1 Mappé directement à partir de file.identity.sha1
file.identity.sha1 read_only_udm.target.file.sha1 Mappé directement à partir de file.identity.sha1
file.identity.sha256 read_only_udm.security_result.about.file.sha256 Mappé directement à partir de file.identity.sha256
file.identity.sha256 read_only_udm.target.file.sha256 Mappé directement à partir de file.identity.sha256
file.parent.disposition read_only_udm.target.resource.attribute.labels.value Mappé directement à partir de file.parent.disposition
file.parent.file_name read_only_udm.target.resource.attribute.labels.value Directement mappé à partir de file.parent.file_name
file.parent.identity.md5 read_only_udm.target.resource.attribute.labels.value Directement mappé à partir de file.parent.identity.md5
file.parent.identity.sha1 read_only_udm.target.resource.attribute.labels.value Mappé directement à partir de file.parent.identity.sha1
file.parent.identity.sha256 read_only_udm.target.resource.attribute.labels.value Directement mappé à partir de file.parent.identity.sha256
file.parent.process_id read_only_udm.security_result.about.process.parent_process.pid Mappé directement à partir de file.parent.process_id
file.parent.process_id read_only_udm.target.process.parent_process.pid Mappé directement à partir de file.parent.process_id
nom d'hôte read_only_udm.principal.asset.hostname Directement mappé à partir de computer.hostname
nom d'hôte read_only_udm.target.hostname Directement mappé à partir de computer.hostname
nom d'hôte read_only_udm.target.asset.hostname Directement mappé à partir de computer.hostname
ip read_only_udm.principal.asset.ip Mappé directement à partir de computer.network_addresses.ip
ip read_only_udm.principal.ip Mappé directement à partir de computer.network_addresses.ip
ip read_only_udm.security_result.about.ip Mappé directement à partir de computer.network_addresses.ip
mac read_only_udm.principal.mac Mappé directement à partir de computer.network_addresses.mac
mac read_only_udm.security_result.about.mac Mappé directement à partir de computer.network_addresses.mac
de gravité, read_only_udm.security_result.severity Mappé à partir de la gravité selon la logique suivante : - "Moyenne" -> "MEDIUM" - "Élevée" ou "Critique" -> "HIGH" - "Faible" -> "LOW" - Autre -> "UNKNOWN_SEVERITY"
timestamp read_only_udm.metadata.event_timestamp.seconds Mappées directement à partir du code temporel
utilisateur read_only_udm.security_result.about.user.user_display_name Mappé directement à partir de computer.user
utilisateur read_only_udm.target.user.user_display_name Mappé directement à partir de computer.user
vulnerabilities.cve read_only_udm.extensions.vulns.vulnerabilities.cve_id Mappé directement à partir de vulnerabilities.cve
vulnerabilities.name read_only_udm.extensions.vulns.vulnerabilities.name Mappé directement à partir de vulnerabilities.name
vulnerabilities.score read_only_udm.extensions.vulns.vulnerabilities.cvss_base_score Directement mappé à partir de vulnerabilities.score après conversion en float
vulnerabilities.url read_only_udm.extensions.vulns.vulnerabilities.vendor_knowledge_base_article_id Mappé directement à partir de vulnerabilities.url
vulnerabilities.version read_only_udm.extensions.vulns.vulnerabilities.cvss_version Mappé directement à partir de vulnerabilities.version
is_alert Définissez sur "true" si event_type est l'un des suivants : "Threat Detected" (Menace détectée), "Exploit Prevention" (Prévention des exploits), "Executed malware" (Logiciel malveillant exécuté), "Potential Dropper Infection" (Infection potentielle par un programme d'installation de logiciels malveillants), "Multiple Infected Files" (Plusieurs fichiers infectés), "Vulnerable Application Detected" (Application vulnérable détectée) ou si security_result.severity est défini sur "HIGH" (ÉLEVÉE).
is_significant Définissez sur "true" si event_type est l'un des suivants : "Threat Detected" (Menace détectée), "Exploit Prevention" (Prévention des exploits), "Executed malware" (Logiciel malveillant exécuté), "Potential Dropper Infection" (Infection potentielle par un programme d'installation de logiciels malveillants), "Multiple Infected Files" (Plusieurs fichiers infectés), "Vulnerable Application Detected" (Application vulnérable détectée) ou si security_result.severity est défini sur "HIGH" (ÉLEVÉE).
read_only_udm.metadata.event_type Déterminé en fonction des valeurs event_type et security_result.severity. - Si event_type est l'un des suivants : "Executed malware", "Threat Detected", "Potential Dropper Infection", "Cloud Recall Detection", "Malicious Activity Detection", "Exploit Prevention", "Multiple Infected Files", "Cloud IOC", "System Process Protection", "Vulnerable Application Detected", "Threat Quarantined", "Execution Blocked", "Cloud Recall Quarantine Successful", "Cloud Recall Restore from Quarantine Failed", "Cloud Recall Quarantine Attempt Failed", "Quarantine Failure", alors le type d'événement est défini sur "SCAN_FILE". - Si security_result.severity est défini sur "HIGH", le type d'événement est défini sur "SCAN_FILE". - Si has_principal et has_target sont définis sur "true", le type d'événement est défini sur "SCAN_UNCATEGORIZED".  Sinon, le type d'événement est défini sur "GENERIC_EVENT".
read_only_udm.metadata.log_type Définie sur "CISCO_AMP"
read_only_udm.metadata.vendor_name Définie sur "CISCO_AMP"
read_only_udm.security_result.about.file.full_path Directement mappé à partir de file.file_path
read_only_udm.security_result.about.hostname Directement mappé à partir de computer.hostname
read_only_udm.security_result.about.user.user_display_name Mappé directement à partir de computer.user
read_only_udm.security_result.detection_fields.key Définissez sur "ID de détection" pour detection_id, "Code d'erreur" pour error.error_code, "Description de l'erreur" pour error.description, "Disposition du parent" pour file.parent.disposition, "Nom du fichier parent" pour file.parent.file_name, "MD5 du parent" pour file.parent.identity.md5, "SHA1 du parent" pour file.parent.identity.sha1 et "SHA256 du parent" pour file.parent.identity.sha256.
read_only_udm.security_result.summary Défini sur event_type si event_type est l'un des suivants : "Threat Detected" (Menace détectée), "Exploit Prevention" (Prévention des exploits), "Executed malware" (Logiciel malveillant exécuté), "Potential Dropper Infection" (Infection potentielle par un programme d'installation de logiciels malveillants), "Multiple Infected Files" (Plusieurs fichiers infectés), "Vulnerable Application Detected" (Application vulnérable détectée) ou si security_result.severity est "HIGH" (ÉLEVÉE).
read_only_udm.target.asset.ip Mappé directement à partir de computer.network_addresses.ip
read_only_udm.target.resource.attribute.labels.key Définissez sur "Disposition du parent" pour file.parent.disposition, "Nom du fichier parent" pour file.parent.file_name, "MD5 du parent" pour file.parent.identity.md5, "SHA1 du parent" pour file.parent.identity.sha1 et "SHA256 du parent" pour file.parent.identity.sha256.
timestamp.seconds Mappé directement à partir de la date après conversion en code temporel

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