Collecter les journaux Cisco Catalyst SD-WAN Manager

Version de l'analyseur : 7.0

Compatible avec :

Ce document explique comment ingérer les journaux Cisco Catalyst SD-WAN Manager (anciennement vManage) dans Google Security Operations à l'aide de Google Cloud Storage. Cisco Catalyst SD-WAN Manager est un système de gestion de réseau centralisé qui offre visibilité et contrôle sur le tissu SD-WAN. Il permet aux administrateurs de surveiller les performances du réseau, de configurer des règles et de gérer la sécurité sur les réseaux d'entreprise distribués.

Avant de commencer

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

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations permettant de créer et de 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 jobs Cloud Scheduler
  • Accès privilégié à la console de gestion Cisco Catalyst SD-WAN Manager
  • Compte utilisateur Cisco Catalyst SD-WAN Manager disposant des autorisations d'accès à l'API

Créer un bucket Google Cloud Storage

  1. Accédez à la console Google 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
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, cisco-sdwan-logs-bucket).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion, 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 : Activez la gestion des versions des objets ou la règle de conservation.

  6. Cliquez sur Créer.

Collecter les identifiants de l'API Cisco Catalyst SD-WAN Manager

Créer un compte utilisateur API

  1. Connectez-vous à la console Cisco Catalyst SD-WAN Manager.
  2. Dans le menu, accédez à Administration > Gérer les utilisateurs.
  3. Cliquez sur Ajouter un utilisateur.
  4. Fournissez les informations de configuration suivantes :
    • Nom d'utilisateur : saisissez un nom d'utilisateur pour l'accès à l'API (par exemple, chronicle-api).
    • Mot de passe : saisissez un mot de passe sécurisé.
    • Confirmer le mot de passe : saisissez à nouveau le mot de passe.
    • Groupe d'utilisateurs : sélectionnez un groupe d'utilisateurs disposant des autorisations appropriées (voir la section suivante).
  5. Cliquez sur Ajouter.

  6. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :

    • Nom d'utilisateur : nom d'utilisateur Catalyst SD-WAN Manager.
    • Mot de passe : mot de passe de votre Catalyst SD-WAN Manager.
    • URL de base de Catalyst SD-WAN Manager : URL de base de votre serveur Catalyst SD-WAN Manager (par exemple, https://sdwan-manager.example.com:8443).

Configurer les autorisations utilisateur

Le compte utilisateur de l'API nécessite des autorisations spécifiques pour accéder aux journaux d'audit, aux alarmes et aux événements.

  1. Dans la console Cisco Catalyst SD-WAN Manager, accédez à Administration > Gérer les utilisateurs > Groupes d'utilisateurs dans le menu.
  2. Sélectionnez le groupe d'utilisateurs attribué à l'utilisateur de l'API (ou cliquez sur Ajouter un groupe d'utilisateurs pour créer un groupe).
  3. Cliquez sur Modifier.
  4. Dans la section Fonctionnalité, assurez-vous que les autorisations suivantes sont activées :
    • Journal d'audit : sélectionnez l'autorisation Lecture.
    • Alarmes : sélectionnez l'autorisation Lecture.
    • Événements : sélectionnez l'autorisation Lecture.
  5. Cliquez sur Mettre à jour.

Vérifier l'accès à l'API

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

  1. Ouvrez un terminal ou une invite de commande.

  2. Exécutez la commande suivante pour tester l'authentification :

    # Replace with your actual credentials
SDWAN_HOST="https://sdwan-manager.example.com:8443"
SDWAN_USERNAME="chronicle-api"
SDWAN_PASSWORD="your-password"

# Test authentication using session-based login (returns JSESSIONID cookie)
curl -c cookies.txt -X POST \
  "${SDWAN_HOST}/j_security_check" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "j_username=${SDWAN_USERNAME}&j_password=${SDWAN_PASSWORD}"

# Get CSRF token (X-XSRF-TOKEN)
curl -b cookies.txt \
  "${SDWAN_HOST}/dataservice/client/token"

Si l'authentification réussit, la deuxième commande renvoie une chaîne de jeton CSRF.

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-sdwan-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Cisco Catalyst SD-WAN Manager 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 Storage.
    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 un 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 le bucket GCS

Accordez au compte de service des autorisations d'écriture dans le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom du 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-sdwan-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 Créer un sujet.
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez cisco-sdwan-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 des messages Pub/Sub provenant de Cloud Scheduler pour extraire les journaux de l'API Cisco Catalyst SD-WAN Manager 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-sdwan-log-collector
    Région Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
    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 (cisco-sdwan-trigger).
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

  8. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service (cisco-sdwan-collector-sa).

  9. Accédez à l'onglet Conteneurs :

    1. Cliquez sur Variables et secrets.
    2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
    Nom de la variable Exemple de valeur
    GCS_BUCKET cisco-sdwan-logs-bucket
    GCS_PREFIX cisco-sdwan
    STATE_KEY cisco-sdwan/state.json
    SDWAN_HOST https://sdwan-manager.example.com:8443
    SDWAN_USERNAME chronicle-api
    SDWAN_PASSWORD your-sdwan-password
    LOOKBACK_HOURS 1

  10. Dans l'onglet Variables et secrets, faites défiler la page jusqu'à Requêtes :

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

  11. Accédez à l'onglet Paramètres dans Conteneurs :

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

  12. 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).

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (une à deux minutes).

  15. 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 :

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
import urllib.parse
from datetime import datetime, timezone, timedelta
import time

# Disable SSL warnings for self-signed certificates (testing only)
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=10.0, read=60.0),
    cert_reqs='CERT_NONE',
    retries=urllib3.Retry(total=3, backoff_factor=1)
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
SDWAN_HOST = os.environ.get('SDWAN_HOST', '').rstrip('/')
SDWAN_USERNAME = os.environ.get('SDWAN_USERNAME', '')
SDWAN_PASSWORD = os.environ.get('SDWAN_PASSWORD', '')
GCS_BUCKET = os.environ.get('GCS_BUCKET', '')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-sdwan')
STATE_KEY = os.environ.get('STATE_KEY', 'cisco-sdwan/state.json')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))

class CatalystSDWANAPI:
    """Client for Cisco Catalyst SD-WAN Manager API (formerly vManage)."""

    def __init__(self, host, username, password):
        self.host = host
        self.username = username
        self.password = password
        self.jsessionid = None
        self.xsrf_token = None

    def authenticate(self):
        """Authenticate using session-based login (j_security_check)."""
        try:
            login_url = f"{self.host}/j_security_check"
            login_data = urllib.parse.urlencode({
                'j_username': self.username,
                'j_password': self.password
            }).encode('utf-8')

            response = http.request(
                'POST',
                login_url,
                body=login_data,
                headers={'Content-Type': 'application/x-www-form-urlencoded'},
            )

            if b'<html>' in response.data or response.status != 200:
                print(f"Authentication failed: HTTP {response.status}")
                return False

            # Extract JSESSIONID from Set-Cookie header
            cookie_header = response.headers.get('Set-Cookie', '')
            for part in cookie_header.split(','):
                if 'JSESSIONID=' in part:
                    self.jsessionid = part.split('JSESSIONID=')[1].split(';')[0]
                    break

            if not self.jsessionid:
                print("Failed to extract JSESSIONID from response")
                return False

            # Get XSRF token
            token_url = f"{self.host}/dataservice/client/token"
            headers = {
                'Content-Type': 'application/json',
                'Cookie': f"JSESSIONID={self.jsessionid}"
            }
            response = http.request('GET', token_url, headers=headers)

            if response.status == 200:
                self.xsrf_token = response.data.decode('utf-8').strip()
                print("Successfully authenticated with Catalyst SD-WAN Manager")
                return True
            else:
                print(f"Failed to get XSRF token: HTTP {response.status}")
                return False

        except Exception as e:
            print(f"Authentication error: {e}")
            return False

    def _get_headers(self):
        """Build headers for authenticated API requests."""
        return {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'Cookie': f"JSESSIONID={self.jsessionid}",
            'X-XSRF-TOKEN': self.xsrf_token
        }

    def _build_query(self, last_epoch_ms=None):
        """Build a query payload with entry_time filter."""
        query = {
            "query": {
                "condition": "AND",
                "rules": []
            },
            "size": 10000
        }
        if last_epoch_ms:
            query["query"]["rules"].append({
                "value": [str(last_epoch_ms)],
                "field": "entry_time",
                "type": "date",
                "operator": "greater"
            })
        else:
            query["query"]["rules"].append({
                "value": [str(LOOKBACK_HOURS)],
                "field": "entry_time",
                "type": "date",
                "operator": "last_n_hours"
            })
        return query

    def fetch_data(self, endpoint, last_epoch_ms=None):
        """Fetch data from a /dataservice endpoint using POST with query body."""
        url = f"{self.host}/dataservice/{endpoint}"
        headers = self._get_headers()
        query = self._build_query(last_epoch_ms)

        try:
            response = http.request(
                'POST',
                url,
                body=json.dumps(query),
                headers=headers,
            )

            if response.status == 200:
                return json.loads(response.data.decode('utf-8'))
            else:
                print(f"Failed to get {endpoint}: HTTP {response.status}")
                return None

        except Exception as e:
            print(f"Error fetching {endpoint}: {e}")
            return None

def load_state(bucket):
    """Load the last run timestamp (epoch ms) from GCS state file."""
    try:
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = json.loads(blob.download_as_text())
            return state_data.get('last_run_time')
    except Exception as e:
        print(f"Warning: Could not load state: {e}")
    return None

def save_state(bucket, epoch_ms):
    """Save the current run timestamp (epoch ms) to GCS state file."""
    try:
        state_data = {
            'last_run_time': epoch_ms,
            'updated_at': datetime.now(timezone.utc).isoformat()
        }
        blob = bucket.blob(STATE_KEY)
        blob.upload_from_string(
            json.dumps(state_data),
            content_type='application/json'
        )
        print(f"Saved state: last_run_time={epoch_ms}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def upload_to_gcs(bucket, records, log_type):
    """Upload log records to GCS as NDJSON."""
    if not records:
        print(f"No {log_type} records to upload")
        return 0

    dt = datetime.now(timezone.utc)
    object_key = (
        f"{GCS_PREFIX}/{log_type}/"
        f"{dt.strftime('%Y/%m/%d')}/"
        f"{log_type}_{dt.strftime('%Y%m%d_%H%M%S')}.ndjson"
    )

    ndjson = '\n'.join(
        json.dumps(record, ensure_ascii=False) for record in records
    ) + '\n'

    blob = bucket.blob(object_key)
    blob.upload_from_string(ndjson, content_type='application/x-ndjson')
    print(f"Uploaded {len(records)} {log_type} records to gs://{GCS_BUCKET}/{object_key}")
    return len(records)

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub.
    Fetches audit logs, alarms, and events from Cisco Catalyst SD-WAN Manager
    API and writes them to GCS as NDJSON files.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    print(f"Starting Cisco Catalyst SD-WAN Manager log collection at {datetime.now(timezone.utc).isoformat()}")

    if not all([SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD, GCS_BUCKET]):
        print("Error: Missing required environment variables")
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load last run timestamp
        last_run_time = load_state(bucket)
        if last_run_time:
            print(f"Resuming from last_run_time={last_run_time}")
        else:
            print(f"No previous state found, collecting last {LOOKBACK_HOURS} hour(s) of logs")

        # Authenticate
        api = CatalystSDWANAPI(SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD)
        if not api.authenticate():
            print("Failed to authenticate with Catalyst SD-WAN Manager")
            return

        # Current timestamp for state tracking (epoch milliseconds)
        current_time = int(datetime.now(timezone.utc).timestamp() * 1000)

        # Collect audit logs, alarms, and events
        endpoints = [
            ('audit_logs', 'auditlog'),
            ('alarms', 'alarms'),
            ('events', 'events'),
        ]

        total_records = 0
        for log_type, endpoint in endpoints:
            try:
                print(f"Collecting {log_type} from /dataservice/{endpoint}...")
                response_data = api.fetch_data(endpoint, last_run_time)
                if response_data and 'data' in response_data:
                    count = upload_to_gcs(bucket, response_data['data'], log_type)
                    total_records += count
                else:
                    print(f"No {log_type} data returned")
            except Exception as e:
                print(f"Error processing {log_type}: {e}")
                continue

        # Update state
        save_state(bucket, current_time)

        print(f"Collection completed. Total records processed: {total_records}")

    except Exception as e:
        print(f"Function execution error: {e}")
        raise

    • 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 publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera 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-sdwan-log-collector-hourly
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures, à l'heure pile)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Sujet Sélectionnez le thème (cisco-sdwan-trigger).
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de programmation

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 quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de la fonction (cisco-sdwan-log-collector).
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Par exemple :

    Starting Cisco Catalyst SD-WAN Manager log collection at ...
Successfully authenticated with Catalyst SD-WAN Manager
Collecting audit_logs from /dataservice/auditlog...
Uploaded N audit_logs records to gs://...
Collection completed. Total records processed: N

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom du bucket.

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

  11. Vérifiez que de nouveaux fichiers .ndjson ont été créés avec l'horodatage actuel.

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement
  • HTTP 403 : vérifiez que le compte utilisateur dispose des autorisations de lecture requises pour les journaux d'audit, les alarmes et les événements.
  • Échec de l'authentification : vérifiez que l'URL de base de Catalyst SD-WAN Manager inclut le bon port (8443 par défaut).
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.

Configurer un flux dans Google SecOps pour ingérer les journaux Cisco Catalyst SD-WAN Manager

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur 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 Catalyst SD-WAN Manager logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Cisco SD-WAN comme Type de journal.

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

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

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

  9. Cliquez sur Suivant.

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

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

      gs://cisco-sdwan-logs-bucket/cisco-sdwan/
      • Remplacez :
        • cisco-sdwan-logs-bucket : nom de votre bucket GCS.
        • cisco-sdwan/ : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).

    • 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 une fois le transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides une fois le transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

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

  11. Cliquez sur Suivant.

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

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 du 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.
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
Tunnel_id_label additional.fields Fusionné
additional_tag additional.fields Fusionné
count_label additional.fields Fusionné
dst_vrf_label additional.fields Fusionné
logfeature_label additional.fields Fusionné
logmodule_label additional.fields Fusionné
meta_sequenceId_label additional.fields Fusionné
msg_label additional.fields Fusionné
qfp_label additional.fields Fusionné
result_label additional.fields Fusionné
rsa_sha256_label additional.fields Fusionné
rsa_type_label additional.fields Fusionné
sequence_label additional.fields Fusionné
src_vrf_label additional.fields Fusionné
tenant_vpn_id_label additional.fields Fusionné
thread_label additional.fields Fusionné
tos_label additional.fields Fusionné
unknown_tenant_label additional.fields Fusionné
vlan_id_label additional.fields Fusionné
vpn_id_label additional.fields Fusionné
description_1 extensions.auth.type Mappé : (?i)closed → AUTHTYPE_UNSPECIFIED
msg1 extensions.auth.type Mappé : authenticated → AUTHTYPE_UNSPECIFIED
msgs extensions.auth.type Mappé : (?i)success → AUTHTYPE_UNSPECIFIED
prod_type extensions.auth.type Mappé : (?i)LOGOUT → AUTHTYPE_UNSPECIFIED
host_name intermediary.asset.hostname Mappé directement
host_name intermediary.hostname Mappé directement
inter_host intermediary.hostname Mappé directement
logmsg metadata.description Mappé directement
message_value metadata.description Mappé directement
msgs metadata.description Mappé directement
date_time metadata.event_timestamp Analysé en tant que ISO8601
time metadata.event_timestamp Analysé en tant que ISO8601
time_t metadata.event_timestamp Analysé en tant que ISO8601
timestamp metadata.event_timestamp Analysé en tant que ISO8601
description_1 metadata.event_type Mappé : (?i)closed → USER_LOGOUT
has_principal metadata.event_type Mappé : true → NETWORK_CONNECTION, true → STATUS_UPDATE
has_principal_user metadata.event_type Mappé : true → USER_UNCATEGORIZED
msg1 metadata.event_type Mappé : authenticated → USER_LOGIN
msgs metadata.event_type Mappé : (?i)success → USER_LOGIN
prod_type metadata.event_type Mappé : (?i)LOGOUT → USER_LOGOUT
prod_type metadata.product_event_type Mappé directement
log_id metadata.product_log_id Mappé directement
logid metadata.product_log_id Mappé directement
application_protocol network.application_protocol Mappé : (?i)SSH → SSH
message network.application_protocol Mappé : (?i)SSH → SSH, (?i)netconf → NETCONF, (?i)dhcp → DHCP
type1 network.dhcp.type Mappé : DHCPDISCOVER → DISCOVER
message network.ip_protocol Mappé : (?i)tcp → TCP
network_protocol network.ip_protocol Mappé directement
bytes network.sent_bytes Mappé directement
session_id network.session_id Mappé directement
network_host network.tls.cipher Mappé directement
hostname principal.asset.hostname Mappé directement
host principal.asset.ip Fusionné
initiator_ip principal.asset.ip Fusionné
ip principal.asset.ip Fusionné
ipaddress principal.asset.ip Fusionné
logusersrcip principal.asset.ip Fusionné
peer_ip principal.asset.ip Fusionné
principal_ip principal.asset.ip Fusionné
principal_ip1 principal.asset.ip Fusionné
proxy_host principal.asset.ip Fusionné
src_ip principal.asset.ip Fusionné
system_ip principal.asset.ip Fusionné
addr principal.hostname Mappé directement
hostname principal.hostname Mappé directement
host principal.ip Fusionné
initiator_ip principal.ip Fusionné
ip principal.ip Fusionné
ipaddress principal.ip Fusionné
logusersrcip principal.ip Fusionné
peer_ip principal.ip Fusionné
principal_ip principal.ip Fusionné
principal_ip1 principal.ip Fusionné
proxy_host principal.ip Fusionné
src_ip principal.ip Fusionné
system_ip principal.ip Fusionné
initiator_port principal.port Mappé directement
port principal.port Mappé directement
ports principal.port Mappé directement
principal_port principal.port Mappé directement
principal_port1 principal.port Mappé directement
src_port principal.port Mappé directement
process_path principal.process.file.full_path Mappé directement
parent_pid principal.process.parent_process.pid Mappé directement
pid principal.process.pid Mappé directement
process_label principal.resource.attribute.labels Fusionné
process_name_label principal.resource.attribute.labels Fusionné
loguser principal.user.userid Mappé directement
user1 principal.user.userid Mappé directement
user_id principal.user.userid Mappé directement
username principal.user.userid Mappé directement
action security_result.action Fusionné
message security_result.action Mappé : (?i)(succeeded/accounting start/open/occurred/update/successfully/success) → `acti...
classification security_result.category_details Fusionné
msg1 security_result.description Mappé directement
Malware_label security_result.detection_fields Fusionné
direction_label security_result.detection_fields Fusionné
egress_interface_label security_result.detection_fields Fusionné
ingress_interface_label security_result.detection_fields Fusionné
log_prefix_label security_result.detection_fields Fusionné
log_reason_label security_result.detection_fields Fusionné
packet_label security_result.detection_fields Fusionné
policy_label security_result.detection_fields Fusionné
port_label security_result.detection_fields Fusionné
protocol_label security_result.detection_fields Fusionné
proxy_port_label security_result.detection_fields Fusionné
sent_bytes_1_label security_result.detection_fields Fusionné
sent_bytes_2_label security_result.detection_fields Fusionné
tty_label security_result.detection_fields Fusionné
type_label security_result.detection_fields Fusionné
udp_packets_label security_result.detection_fields Fusionné
priority security_result.severity Mappé : 1 → LOW
description_1 security_result.summary Mappé directement
dst_ip target.asset.ip Fusionné
ipadres target.asset.ip Fusionné
logdeviceid target.asset.ip Fusionné
responder_ip target.asset.ip Fusionné
target_ip target.asset.ip Fusionné
target_ip1 target.asset.ip Fusionné
filename target.file.names Fusionné
dst_ip target.ip Fusionné
ipadres target.ip Fusionné
logdeviceid target.ip Fusionné
responder_ip target.ip Fusionné
target_ip target.ip Fusionné
target_ip1 target.ip Fusionné
dst_port target.port Mappé directement
prts target.port Mappé directement
responder_port target.port Mappé directement
target_port target.port Mappé directement
target_port1 target.port Mappé directement
filetype target.process.file.mime_type Mappé directement
parent_identifier_label target.resource.attribute.labels Fusionné
specific_identifer_label target.resource.attribute.labels Fusionné
target_name target.resource.name Mappé directement
instance_id target.resource.product_object_id Mappé directement
target_username target.user.userid Mappé directement
user target.user.userid Mappé directement
N/A extensions.auth.type Constante : AUTHTYPE_UNSPECIFIED
N/A metadata.event_type Constante : USER_LOGIN
N/A network.application_protocol Constante : SSH
N/A network.dhcp.type Constante : DISCOVER
N/A network.ip_protocol Constante : TCP
N/A security_result.severity Constante : LOW
rsa_type event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
sha_256 event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
NETCONF event.idm.read_only_udm.network.application_protocol Mappé à partir du journal des modifications
TCP event.idm.read_only_udm.network.ip_protocol Mappé à partir du journal des modifications
DHCP event.idm.read_only_udm.network.application_protocol Mappé à partir du journal des modifications
username1 target.user.userid Mappé à partir du journal des modifications
security_result.action ALLOW Mappé à partir du journal des modifications
ip_1 principal.ip Mappé à partir du journal des modifications
ip_2 target.ip Mappé à partir du journal des modifications
port_1 principal.port Mappé à partir du journal des modifications
port_2 target.port Mappé à partir du journal des modifications
message_1 metadata.description Mappé à partir du journal des modifications
malware security_result.detection_fields Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications pour ce parseur

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