Raccogliere i log di CrowdStrike Falcon Event Streams

Supportato in:

Questo documento spiega come importare i log di CrowdStrike Falcon Event Streams in Google Security Operations utilizzando Google Cloud Storage V2. CrowdStrike Falcon Event Streams fornisce un'API di streaming in tempo reale che distribuisce i dati sugli eventi di sicurezza dalla piattaforma Falcon, inclusi eventi di rilevamento, eventi di controllo, attività di autenticazione e aggiornamenti degli incidenti. L'API Event Streams utilizza una connessione HTTP persistente con l'endpoint /sensors/entities/datafeed/v2 per eseguire il push degli eventi quasi in tempo reale, supportando la ripresa basata sull'offset per una distribuzione affidabile.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Istanza Google SecOps.
  • Un progetto GCP con l'API Storage di Cloud Storage abilitata.
  • Autorizzazioni per creare e gestire bucket GCS.
  • Autorizzazioni per gestire le policy IAM nei bucket GCS.
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler.
  • Accesso privilegiato alla console CrowdStrike Falcon con autorizzazioni per creare client API.

Crea un bucket Google Cloud Storage

  1. Vai alla console Google Cloud.
  2. Seleziona il tuo progetto o creane uno nuovo.
  3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
  4. Fai clic su Crea bucket.

  5. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Assegna un nome al bucket Inserisci un nome univoco globale (ad esempio cs-stream-logs).
    Tipo di località Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
    Località Seleziona la posizione (ad esempio, us-central1).
    Classe di archiviazione Standard (consigliato per i log a cui si accede di frequente)
    Controllo dell'accesso Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Attiva il controllo delle versioni degli oggetti o la policy di conservazione

  6. Fai clic su Crea.

Configurare l'accesso all'API CrowdStrike Falcon

Crea client API

  1. Accedi alla console CrowdStrike Falcon.
  2. Nel menu di navigazione, vai a Assistenza e risorse > Risorse e strumenti > Client e chiavi API.
  3. Fai clic su Crea client API.
  4. Fornisci i seguenti dettagli di configurazione:
    • Nome cliente: inserisci un nome descrittivo (ad esempio, Google SecOps Event Streams Integration).
    • (Facoltativo) Descrizione: inserisci una descrizione (ad esempio, API client for streaming events to GCS).
  5. Nella sezione Ambiti API, seleziona la seguente autorizzazione:
    • Stream di eventi: seleziona Lettura (obbligatorio per utilizzare l'API di streaming).
  6. Fai clic su Crea.

Registra le credenziali API

Dopo aver creato il client API, ricevi le seguenti credenziali:

  • ID client: una stringa esadecimale minuscola di 32 caratteri.
  • Client secret: una stringa alfanumerica di 40 caratteri.
  • URL di base: il nome di dominio completo per l'API CrowdStrike (ad esempio api.crowdstrike.com o api.us-2.crowdstrike.com).

Importante: copia e salva immediatamente il client secret. Viene visualizzato una sola volta e non può essere recuperato in un secondo momento.

Endpoint regionali

CrowdStrike opera in più regioni con endpoint API diversi:

Regione URL di base
US-1 api.crowdstrike.com
US-2 api.us-2.crowdstrike.com
EU-1 api.eu-1.crowdstrike.com
US-GOV-1 api.laggar.gcw.crowdstrike.com

Importante: utilizza l'URL di base corrispondente alla regione di accesso della console CrowdStrike Falcon.

Verifica le autorizzazioni

Per verificare che il client API disponga delle autorizzazioni necessarie:

  1. Accedi alla console CrowdStrike Falcon.
  2. Vai a Assistenza e risorse > Risorse e strumenti > Client e chiavi API.
  3. Trova il client API che hai creato e verifica che l'ambito Stream di eventi mostri l'accesso Lettura.

Testare l'accesso API

  • Verifica le tue credenziali prima di procedere con l'integrazione:

    CLIENT_ID="<your-client-id>"
CLIENT_SECRET="<your-client-secret>"
BASE_URL="https://api.crowdstrike.com"

# Get OAuth2 token
TOKEN=$(curl -s -X POST "${BASE_URL}/oauth2/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}" | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")

# Test Event Streams API access (discover available data feeds)
curl -s -H "Authorization: Bearer ${TOKEN}" \
  "${BASE_URL}/sensors/entities/datafeed/v2?appId=secops-test&format=flatjson"

Una risposta corretta restituisce un oggetto JSON contenente resources con i campi dataFeedURL e sessionToken per ogni partizione di stream disponibile.

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni per scrivere nel bucket GCS e per essere richiamato da Pub/Sub.

Crea service account

  1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome del service account: inserisci cs-stream-collector-sa
    • Descrizione service account: inserisci Service account for Cloud Run function to collect CrowdStrike Event Streams logs
  4. Fai clic su Crea e continua.
  5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
    1. Fai clic su Seleziona un ruolo.
    2. Cerca e seleziona Storage Object Admin.
    3. Fai clic su + Aggiungi un altro ruolo.
    4. Cerca e seleziona Cloud Run Invoker.
    5. Fai clic su + Aggiungi un altro ruolo.
    6. Cerca e seleziona Invoker di Cloud Functions.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono necessari per:

  • Storage Object Admin: scrive i log nel bucket GCS e gestisce i file di stato
  • Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
  • Cloud Functions Invoker: consente la chiamata di funzioni

Concedi autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni di scrittura sul bucket GCS:

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket (ad esempio cs-stream-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: inserisci l'email del account di servizio (ad esempio, cs-stream-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Assegna i ruoli: seleziona Storage Object Admin.
  6. Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console GCP, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci cs-stream-trigger
    • Lascia le altre impostazioni predefinite
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per connettersi all'API CrowdStrike Event Streams, utilizzare gli eventi e scriverli in GCS.

  1. Nella console GCP, vai a Cloud Run.
  2. Fai clic su Crea servizio.
  3. Seleziona Funzione (usa un editor in linea per creare una funzione).

  4. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome servizio cs-stream-collector
    Regione Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)
    Tempo di esecuzione Seleziona Python 3.12 o versioni successive

  5. Nella sezione Trigger (facoltativo):

    1. Fai clic su + Aggiungi trigger.
    2. Seleziona Cloud Pub/Sub.
    3. In Seleziona un argomento Cloud Pub/Sub, scegli cs-stream-trigger.
    4. Fai clic su Salva.

  6. Nella sezione Autenticazione:

    1. Seleziona Richiedi autenticazione.
    2. Controlla Identity and Access Management (IAM).

  7. Scorri verso il basso ed espandi Container, networking, sicurezza.

  8. Vai alla scheda Sicurezza:

    • Service account (Service account): seleziona cs-stream-collector-sa

  9. Vai alla scheda Container:

    1. Fai clic su Variabili e secret.
    2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:
    Nome variabile Valore di esempio Descrizione
    GCS_BUCKET cs-stream-logs Nome del bucket GCS
    GCS_PREFIX crowdstrike/stream Prefisso per i file di log
    STATE_KEY crowdstrike/stream/state.json Percorso file di stato
    CS_BASE_URL https://api.crowdstrike.com URL di base dell'API CrowdStrike
    CS_CLIENT_ID your-client-id ID client API
    CS_CLIENT_SECRET your-client-secret Client secret API
    CS_APP_ID secops-stream-collector ID app univoco per Event Streams (massimo 32 caratteri alfanumerici)
    STREAM_TIMEOUT 300 Timeout di lettura dello stream in secondi
    MAX_RECORDS 10000 Numero massimo di record per esecuzione

  10. Nella sezione Variabili e secret, scorri verso il basso fino a Richieste:

    • Timeout richiesta: inserisci 600 secondi (10 minuti)

  11. Vai alla scheda Impostazioni:

    • Nella sezione Risorse:
      • Memoria: seleziona 512 MiB o superiore
      • CPU: seleziona 1

  12. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0
    • Numero massimo di istanze: inserisci 1 (deve essere eseguito un solo consumer di stream alla volta)

  13. Fai clic su Crea.

  14. Attendi la creazione del servizio (1-2 minuti).

  15. Dopo aver creato il servizio, si aprirà automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

  1. Inserisci main nel campo Entry point (Punto di ingresso).

  2. Nell'editor di codice incorporato, crea due file:

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone

# 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', 'crowdstrike/stream')
STATE_KEY = os.environ.get('STATE_KEY', 'crowdstrike/stream/state.json')
CS_BASE_URL = os.environ.get('CS_BASE_URL', 'https://api.crowdstrike.com')
CS_CLIENT_ID = os.environ.get('CS_CLIENT_ID')
CS_CLIENT_SECRET = os.environ.get('CS_CLIENT_SECRET')
CS_APP_ID = os.environ.get('CS_APP_ID', 'secops-stream-collector')
STREAM_TIMEOUT = int(os.environ.get('STREAM_TIMEOUT', '300'))
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))

def get_oauth_token(base_url: str, client_id: str, client_secret: str) -> str:
    """Get CrowdStrike OAuth2 access token."""
    token_url = f"{base_url}/oauth2/token"
    body = f"client_id={client_id}&client_secret={client_secret}"
    response = http.request(
        'POST', token_url,
        body=body.encode('utf-8'),
        headers={'Content-Type': 'application/x-www-form-urlencoded'}
    )
    if response.status != 200:
        raise Exception(f"OAuth token request failed: {response.status}")
    data = json.loads(response.data.decode('utf-8'))
    return data['access_token']

def refresh_stream_session(base_url: str, token: str, app_id: str, partition: int = 0):
    """Refresh an active stream session to keep it alive."""
    refresh_url = (
        f"{base_url}/sensors/entities/datafeed-actions/v1/{partition}"
        f"?appId={app_id}&action_name=refresh_active_stream_session"
    )
    response = http.request(
        'POST', refresh_url,
        headers={
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json',
        }
    )
    if response.status == 200:
        print("Stream session refreshed successfully")
    else:
        print(f"Warning: Stream session refresh returned {response.status}")

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch CrowdStrike
    Event Streams data and write to GCS.
    """

    if not all([GCS_BUCKET, CS_BASE_URL, CS_CLIENT_ID, CS_CLIENT_SECRET]):
        print('Error: Missing required environment variables')
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load state
        state = load_state(bucket, STATE_KEY)

        # Get OAuth token
        token = get_oauth_token(CS_BASE_URL, CS_CLIENT_ID, CS_CLIENT_SECRET)
        headers = {
            'Authorization': f'Bearer {token}',
            'Accept': 'application/json',
        }

        # Discover available data feeds
        discover_url = (
            f"{CS_BASE_URL}/sensors/entities/datafeed/v2"
            f"?appId={CS_APP_ID}&format=flatjson"
        )
        response = http.request('GET', discover_url, headers=headers)

        if response.status != 200:
            print(f"Failed to discover data feed: {response.status}")
            print(f"Response: {response.data.decode('utf-8')}")
            return

        feed_data = json.loads(response.data.decode('utf-8'))
        resources = feed_data.get('resources', [])

        if not resources:
            print("No data feed resources available")
            return

        feed_url = resources[0].get('dataFeedURL', '')
        session_token = resources[0].get(
            'sessionToken', {}
        ).get('token', '')

        if not feed_url or not session_token:
            print("Missing feed URL or session token")
            return

        # Build stream URL with offset if available
        stream_url = feed_url
        offset = state.get('offset')
        if offset:
            stream_url = f"{feed_url}&offset={offset}"

        # Connect to Event Stream
        stream_headers = {
            'Authorization': f'Token {session_token}',
            'Accept': 'application/json',
            'Connection': 'keep-alive',
        }

        stream_http = urllib3.PoolManager(
            timeout=urllib3.Timeout(
                connect=10.0, read=float(STREAM_TIMEOUT)
            ),
            retries=False,
        )

        print(f"Connecting to Event Stream...")
        resp = stream_http.request(
            'GET', stream_url,
            headers=stream_headers,
            preload_content=False
        )

        if resp.status != 200:
            print(f"Stream connection failed: {resp.status}")
            return

        records = []
        latest_offset = offset
        now = datetime.now(timezone.utc)

        for line in resp.stream(4096):
            decoded = line.decode('utf-8').strip()
            if not decoded:
                continue

            try:
                event = json.loads(decoded)
                records.append(event)

                event_offset = event.get(
                    'metadata', {}
                ).get('offset')
                if event_offset is not None:
                    latest_offset = event_offset

                if len(records) >= MAX_RECORDS:
                    print(
                        f"Reached max records limit ({MAX_RECORDS})"
                    )
                    break
            except json.JSONDecodeError:
                continue

        resp.release_conn()

        if not records:
            print("No new events found in stream.")
            # Refresh stream session to keep it alive
            refresh_stream_session(
                CS_BASE_URL, token, CS_APP_ID
            )
            return

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

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

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

        # Save state with latest offset
        new_state = {
            'offset': latest_offset,
            'last_run': now.isoformat()
        }
        save_state(bucket, STATE_KEY, new_state)

        # Refresh stream session to keep it alive
        refresh_stream_session(
            CS_BASE_URL, token, CS_APP_ID
        )

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

    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, state: dict):
    """Save state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print(f"Saved state: {state}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

    requirements.txt:

    ```none
functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0
```

  3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

  4. Attendi il completamento del deployment (2-3 minuti).

Crea job Cloud Scheduler

Cloud Scheduler pubblicherà messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console GCP, vai a Cloud Scheduler.
  2. Fai clic su Crea job.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome cs-stream-collector-scheduled
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza */15 * * * * (ogni 15 minuti)
    Fuso orario Seleziona il fuso orario (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona cs-stream-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il job.
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi qualche secondo.
  4. Vai a Cloud Run > Servizi.
  5. Fai clic su cs-stream-collector.
  6. Fai clic sulla scheda Log.

  7. Verifica che la funzione sia stata eseguita correttamente. Cerca:

    Connecting to Event Stream...
Wrote X records to gs://cs-stream-logs/crowdstrike/stream/logs_YYYYMMDD_HHMMSS.ndjson
Stream session refreshed successfully
Successfully processed X events

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic su cs-stream-logs.

  10. Vai alla cartella crowdstrike/stream/.

  11. Verifica che sia stato creato un nuovo file .ndjson con il timestamp corrente.

Se visualizzi errori nei log:

  • HTTP 401: controlla le credenziali API nelle variabili di ambiente
  • HTTP 403: verifica che il client API abbia l'ambito Event streams: Read
  • HTTP 429: limitazione di frequenza: modifica la frequenza dello scheduler o aumenta STREAM_TIMEOUT
  • Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate
  • Nessuna risorsa di feed di dati disponibile: verifica che CS_APP_ID sia univoco e non superi i 32 caratteri alfanumerici

Recuperare il account di servizio Google SecOps

Google SecOps utilizza un account di servizio univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo account di servizio l'accesso al tuo bucket.

Recupera l'email del account di servizio

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, CrowdStrike Event Streams logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona CrowdStrike Falcon Streaming come Tipo di log.
  7. Fai clic su Ottieni service account.

  8. Verrà visualizzata un'email del account di servizio univoca, ad esempio:

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

  9. Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

  10. Fai clic su Avanti.

  11. Specifica i valori per i seguenti parametri di input:

    • URL bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

      gs://cs-stream-logs/crowdstrike/stream/

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
      • Elimina i file trasferiti: elimina i file dopo il trasferimento riuscito.

      • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni (il valore predefinito è 180 giorni)

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed

  12. Fai clic su Avanti.

  13. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel bucket GCS.

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic su cs-stream-logs.
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: incolla l'email del account di servizio Google SecOps
    • Assegna i ruoli: seleziona Visualizzatore oggetti Storage.

  6. Fai clic su Salva.

Hai bisogno di ulteriore assistenza?

Per ulteriori informazioni sui feed di Google Security Operations, consulta la documentazione sui feed di Google Security Operations. Per informazioni sui requisiti per ogni tipo di feed, consulta Configurazione dei feed per tipo.

Per riferimento, consulta la documentazione del parser di CrowdStrike Falcon Event Streams.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
event_data.AssociatedFile about.file.full_path Mappato direttamente
event_data.IOCValue about.file.sha256 Mappato direttamente
ActivityId_label additional.fields Unita
ActivityOperatingSystem_label additional.fields Unita
ModelAnomalyIndicators_label additional.fields Unita
SourceEndpointIpReputation_label additional.fields Unita
SourceIpIspClassification_label additional.fields Unita
SourceIpIspDomain_label additional.fields Unita
additional_deviceCustomDate1 additional.fields Unita
additional_domainname additional.fields Unita
commands_label additional.fields Unita
data_domains_label additional.fields Unita
dns_request_domain_name_label additional.fields Unita
dns_request_type_label additional.fields Unita
dnsrequest_interface_index_label additional.fields Unita
dnsrequest_load_time_label additional.fields Unita
eventType additional.fields Valori mappati (8 in totale, ad es. "EppDetectionSummaryEvent","IdpDetectionSummaryEvent" → `file...
event_data_ContextTimeStamp_id_label additional.fields Unita
event_data_MobileDetectionId_id_label additional.fields Unita
field1 additional.fields Unita
fileaccessed_full_path_label additional.fields Unita
fileaccessed_timestamp_label additional.fields Unita
filewritten_full_path_label additional.fields Unita
filewritten_timestamp_label additional.fields Unita
reputation_label_list_values additional.fields Unita
sourceipasncode_label additional.fields Unita
sourceipasnorg_label additional.fields Unita
eventType extensions.auth.mechanism Mappato: "saml2Assert", "twoFactorAuthenticate" → mechanism
mechanism extensions.auth.mechanism Unita
eventType extensions.auth.type Mappato: "assert", "userAuthenticate" → AUTHTYPE_UNSPECIFIED
description metadata.description Mappato direttamente
event_data.Description metadata.description Mappato direttamente
incidentDescription metadata.description Mappato direttamente
msg metadata.description Mappato direttamente
name metadata.description Mappato direttamente
serviceName metadata.description Mappato direttamente
devTime metadata.event_timestamp Analizzato come yyyy-MM-dd HH:mm:ss
deviceCustomDate1 metadata.event_timestamp Analizzato come MMM dd yyyy HH:mm:ss
event_data.UTCTimestamp metadata.event_timestamp Analizzato come UNIX_MS
meta.eventCreationTime metadata.event_timestamp Analizzato come UNIX_MS
meta.event_dataCreationTime metadata.event_timestamp Analizzato come UNIX_MS
timestamp metadata.event_timestamp Analizzato come UNIX_MS
eventType metadata.event_type Valori mappati (6 in totale, ad es. "saml2Assert", "twoFactorAuthenticate" → USER_LOGIN, ` "r...
has_principal metadata.event_type Mappato: true → STATUS_UPDATE, true → SCAN_FILE
has_user metadata.event_type Mappato: false → GENERIC_EVENT
cid metadata.product_deployment_id Mappato direttamente
eventType metadata.product_event_type Mappato direttamente
event_data_simpleName metadata.product_event_type Mappato direttamente
event_data.AgentId metadata.product_log_id Mappato direttamente
id metadata.product_log_id Mappato direttamente
product metadata.product_name Mappato direttamente
meta.version metadata.product_version Mappato direttamente
version metadata.product_version Mappato direttamente
cs6 metadata.url_back_to_product Mappato direttamente
url metadata.url_back_to_product Mappato direttamente
vendor metadata.vendor_name Mappato direttamente
connectionDirection network.direction Mappato: 0 → OUTBOUND, 1 → INBOUND
event_data.Attributes.request_method network.http.method Mappato direttamente
event_data.FalconHostLink network.http.referral_url Mappato direttamente
request network.http.referral_url Mappato direttamente
event_data.Attributes.status_code network.http.response_code Mappato direttamente
event_data.Attributes.user_agent network.http.user_agent Mappato direttamente
protocol network.ip_protocol Mappato: 6 → TCP, 17 → UDP, 58 → ICMP
event_data.Attributes.trace_id network.session_id Mappato direttamente
event_data.SessionId network.session_id Mappato direttamente
value_issuer network.tls.server.certificate.issuer Mappato direttamente
domain principal.administrative_domain Mappato direttamente
event_data.DataDomains principal.administrative_domain Mappato direttamente
event_data.SourceAccountDomain principal.administrative_domain Mappato direttamente
event_data_ActivityBrowser principal.application Mappato direttamente
aid principal.asset.asset_id Mappato direttamente
event_data.AgentIdString principal.asset.asset_id Mappato direttamente
event_data_SensorId principal.asset.asset_id Mappato direttamente
ComputerName principal.asset.hostname Mappato direttamente
endpointName principal.asset.hostname Mappato direttamente
event_data.EndpointName principal.asset.hostname Mappato direttamente
event_data.Hostname principal.asset.hostname Mappato direttamente
event_data.HostnameField principal.asset.hostname Mappato direttamente
event_data.SourceEndpointHostName principal.asset.hostname Mappato direttamente
event_data_ComputerName principal.asset.hostname Mappato direttamente
hostName principal.asset.hostname Mappato direttamente
ClientIP principal.asset.ip Unita
LocalAddressIP4 principal.asset.ip Unita
aip principal.asset.ip Unita
event_data.EndpointIp principal.asset.ip Unita
event_data.LocalIP principal.asset.ip Unita
event_data.LocalIPv6 principal.asset.ip Unita
event_data.SourceEndpointIpAddress principal.asset.ip Unita
event_data.UserIp principal.asset.ip Unita
ip principal.asset.ip Unita
localAddress principal.asset.ip Unita
remoteAddress principal.asset.ip Unita
src principal.asset.ip Unita
event_data.MACAddress principal.asset.mac Unita
event_data_SensorId principal.asset_id Mappato direttamente
ComputerName principal.hostname Mappato direttamente
endpointName principal.hostname Mappato direttamente
event_data.EndpointName principal.hostname Mappato direttamente
event_data.Hostname principal.hostname Mappato direttamente
event_data.HostnameField principal.hostname Mappato direttamente
event_data.SourceEndpointHostName principal.hostname Mappato direttamente
event_data_ComputerName principal.hostname Mappato direttamente
hostName principal.hostname Mappato direttamente
ClientIP principal.ip Unita
LocalAddressIP4 principal.ip Unita
aip principal.ip Unita
event_data.EndpointIp principal.ip Unita
event_data.LocalIP principal.ip Unita
event_data.LocalIPv6 principal.ip Unita
event_data.SourceEndpointIpAddress principal.ip Unita
event_data.UserIp principal.ip Unita
ip principal.ip Unita
localAddress principal.ip Unita
remoteAddress principal.ip Unita
src principal.ip Unita
event_data_LocationCountryCode principal.location.country_or_region Mappato direttamente
event_data.MACAddress principal.mac Unita
srcMAC principal.mac Unita
event_data_platformName principal.platform Mappato: (?i)Linux → LINUX, (?i)Windows → WINDOWS, (?i)mac/ios → MAC
localPort principal.port Mappato direttamente
exeWrittenFilePath principal.process.file.full_path Mappato direttamente
event_data.ParentCommandLine principal.process.parent_process.command_line Mappato direttamente
event_data.ParentImageFilePath principal.process.parent_process.file.full_path Mappato direttamente
eventType principal.process.parent_process.file.names Mappato: "EppDetectionSummaryEvent","IdpDetectionSummaryEvent" → `event_data.ParentImageFil...
event_data.ParentImageFileName principal.process.parent_process.file.names Unita
event_data.ParentProcessId principal.process.parent_process.pid Mappato direttamente
event_data.ProcessId principal.process.pid Mappato direttamente
event_data.Attributes.assign_to_user_id principal.user.email_addresses Unita
event_data.SourceAccountUpn principal.user.email_addresses Unita
userName principal.user.email_addresses Mappato: ^.+@.+$ → userName
user_email principal.user.email_addresses Unita
eventType principal.user.group_identifiers Mappato: "EppDetectionSummaryEvent","IdpDetectionSummaryEvent" → event_data.LogonDomain
event_data.LogonDomain principal.user.group_identifiers Unita
event_data.Attributes.assign_to_name principal.user.user_display_name Mappato direttamente
event_data.UserName principal.user.user_display_name Mappato direttamente
event_data.SourceAccountName principal.user.userid Mappato direttamente
event_data.UserId principal.user.userid Mappato direttamente
userName principal.user.userid Mappato direttamente
usrName principal.user.userid Mappato direttamente
event_data.SourceAccountObjectSid principal.user.windows_sid Mappato direttamente
_security_result security_result Unita
applicationName target.application Mappato direttamente
event_data.Source target.application Mappato direttamente
event_data_SsoApplicationIdentifier target.application Mappato direttamente
serviceName target.application Mappato direttamente
event_data.CompositeId target.asset.asset_id Mappato direttamente
dhost target.asset.hostname Mappato direttamente
event_data.TargetEndpointHostName target.asset.hostname Mappato direttamente
IP target.asset.ip Unita
dst target.asset.ip Unita
event_data.IOCValue target.asset.ip Unita
event_data.TargetEndpointIpAddress target.asset.ip Unita
TargetFileName target.file.full_path Mappato direttamente
event_data.FilePath target.file.full_path Mappato direttamente
event_data.MD5String target.file.md5 Mappato direttamente
eventType target.file.names Mappato: "EppDetectionSummaryEvent","IdpDetectionSummaryEvent" → fileaccessed.FileName, `...
event_data.FileName target.file.names Unita
exeWrittenFileName target.file.names Unita
fileName target.file.names Unita
fileaccessed.FileName target.file.names Unita
filewritten.FileName target.file.names Unita
event_data.SHA1String target.file.sha1 Mappato direttamente
event_data.SHA256String target.file.sha256 Mappato direttamente
sha256 target.file.sha256 Mappato direttamente
Size target.file.size Mappato direttamente
dhost target.hostname Mappato direttamente
event_data.TargetEndpointHostName target.hostname Mappato direttamente
IP target.ip Unita
dst target.ip Unita
event_data.IOCValue target.ip Unita
event_data.TargetEndpointIpAddress target.ip Unita
dpt target.port Rinominate/mappate
remotePort target.port Rinominate/mappate
cmdLine target.process.command_line Mappato direttamente
commandLine target.process.command_line Mappato direttamente
event_data.CommandLine target.process.command_line Mappato direttamente
filePath target.process.file.full_path Mappato direttamente
md5 target.process.file.md5 Mappato direttamente
event_data_itempostedtimestamp_label target.resource.attribute.labels Unita
event_data_itemtype_label target.resource.attribute.labels Unita
resource target.resource.name Mappato direttamente
event_data_itemid target.resource.product_object_id Mappato direttamente
eventType target.resource.type Mappato: "remove_group", "update_group" → GROUP, delete_group → GROUP
event_data.Attributes.request_path target.url Mappato direttamente
eventType target.user.email_addresses Mappato: "saml2Assert", "twoFactorAuthenticate", "assert", "userAuthenticate" → user_email
user_email target.user.email_addresses Unita
usrName target.user.userid Mappato direttamente
event_data.TargetEndpointAccountObjectSid target.user.windows_sid Mappato direttamente
N/D extensions.auth.type Costante: AUTHTYPE_UNSPECIFIED
N/D metadata.event_type Costante: GENERIC_EVENT
N/D metadata.product_name Costante: FalconHost
N/D metadata.vendor_name Costante: CrowdStrike
N/D network.direction Costante: OUTBOUND
N/D network.ip_protocol Costante: TCP
N/D principal.platform Costante: LINUX
N/D target.resource.type Costante: GROUP

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.