Falco-IDS-Logs erfassen

Parserversion: 1.0

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Falco so konfigurieren, dass Laufzeitsicherheitswarnungen über Webhooks über Falcosidekick an Google Security Operations gesendet werden.

Falco ist ein Open-Source-Laufzeitsicherheitstool, das unerwartetes Anwendungsverhalten erkennt und bei Bedrohungen zur Laufzeit Warnungen ausgibt. Es verwendet die Überwachung von Systemaufrufen, um anomale Aktivitäten in Containern, Kubernetes und Linux-Hosts anhand von anpassbaren Sicherheitsregeln zu erkennen.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Falco auf Kubernetes (über Helm) oder Linux-Hosts installiert
  • Zugriff zum Ändern von Falco-Konfigurationsdateien oder Helm-Werten
  • Privilegierter Zugriff zum Bereitstellen von Falcosidekick (falls noch nicht bereitgestellt)

Webhook-Feed in Google SecOps erstellen

Feed erstellen

  1. Rufen Sie die Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf der nächsten Seite auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Falco Runtime Security.
  5. Wählen Sie Webhook als Quelltyp aus.
  6. Wählen Sie Falco IDS als Protokolltyp aus.
  7. Klicken Sie auf Weiter.
  8. Geben Sie Werte für die folgenden Eingabeparameter an:
    • Trennzeichen für Aufteilung (optional): Leer lassen (Falcosidekick sendet ein Ereignis pro Anfrage)
    • Asset-Namespace: Der Asset-Namespace
    • Labels für Datenaufnahme: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.
  9. Klicken Sie auf Weiter.
  10. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Secret-Schlüssel generieren und speichern

Nachdem Sie den Feed erstellt haben, müssen Sie einen Secret-Schlüssel für die Authentifizierung generieren:

  1. Klicken Sie auf der Feed-Detailseite auf Geheimen Schlüssel generieren.
  2. In einem Dialogfeld wird der geheime Schlüssel angezeigt.
  3. Kopieren und speichern Sie den geheimen Schlüssel an einem sicheren Ort.

Feed-Endpunkt-URL abrufen

  1. Gehen Sie zum Tab Details des Feeds.
  2. Kopieren Sie im Abschnitt Endpunktinformationen die Feed-Endpunkt-URL.
  3. Das URL-Format lautet:

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import
    

    Dabei ist {region} die Region Ihrer Google SecOps-Instanz (z. B. us, europe oder asia-southeast1) und {parent} der Ressourcenpfad im Format projects/<PROJECT_ID>/locations/<LOCATION>/instances/<INSTANCE_ID>/logTypes/<LOG_TYPE>.

  4. Speichern Sie diese URL für die nächsten Schritte.

  5. Klicken Sie auf Fertig.

Google Cloud API-Schlüssel erstellen

Google SecOps erfordert einen API-Schlüssel für die Authentifizierung. Erstellen Sie in der Google Cloud Console einen eingeschränkten API-Schlüssel.

API-Schlüssel erstellen

  1. Rufen Sie die Seite „Anmeldedaten“ derGoogle Cloud Console auf.
  2. Wählen Sie Ihr Projekt aus (das Projekt, das mit Ihrer Google SecOps-Instanz verknüpft ist).
  3. Klicken Sie auf Anmeldedaten erstellen > API-Schlüssel. Ein API-Schlüssel wird erstellt und in einem Dialogfeld angezeigt.
  4. Klicken Sie auf API-Schlüssel bearbeiten, um den Schlüssel einzuschränken.

API-Schlüssel einschränken

  1. Auf der Seite mit den Einstellungen für den API-Schlüssel:
    • Name: Geben Sie einen aussagekräftigen Namen ein (z. B. Chronicle Webhook API Key).
  2. Gehen Sie unter API-Einschränkungen so vor:
    1. Wählen Sie Schlüssel einschränken aus.
    2. Suchen Sie in der Liste APIs auswählen nach der Google SecOps API (oder Chronicle API) und wählen Sie sie aus.
  3. Klicken Sie auf Speichern.
  4. Kopieren Sie den Wert des API-Schlüssels aus dem Feld API-Schlüssel oben auf der Seite.
  5. Speichern Sie den API-Schlüssel an einem sicheren Ort.

Falcosidekick bereitstellen

Falcosidekick ist der offizielle Proxy-Weiterleiter für Falco, der Benachrichtigungen an mehrere Ziele weiterleitet, darunter Webhooks, Cloud-Speicher und SIEM-Plattformen.

Wenn Sie Falco zum ersten Mal installieren oder neu bereitstellen können, verwenden Sie diese Methode, um Falco und Falcosidekick zusammen bereitzustellen:

  1. Fügen Sie das Falco-Helm-Repository hinzu:

    helm repo add falcosecurity https://falcosecurity.github.io/charts
    helm repo update
    
  2. Erstellen Sie einen Namespace für Falco:

    kubectl create namespace falco
    
  3. Erstellen Sie die Google SecOps-Webhook-URL mit Authentifizierung:

    <ENDPOINT_URL>?key=<API_KEY>
    

    Beispiel:

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=AIzaSyD...
    
  4. Installieren Sie Falco mit aktiviertem Falcosidekick:

    helm install falco falcosecurity/falco \
        --namespace falco \
        --set falcosidekick.enabled=true \
        --set falcosidekick.config.webhook.address="<ENDPOINT_URL>?key=<API_KEY>" \
        --set falcosidekick.config.webhook.customHeaders="X-Webhook-Access-Key:<SECRET_KEY>" \
        --set falcosidekick.config.webhook.minimumpriority="warning" \
        --set tty=true
    

    Ersetzen Sie:

    • <ENDPOINT_URL>: URL des Google SecOps-Feed-Endpunkts
    • <API_KEY>: Google Cloud API-Schlüssel
    • <SECRET_KEY>: Geheimer Google SecOps-Schlüssel aus der Feederstellung
  5. Bereitstellung prüfen:

    kubectl get pods -n falco
    

    Die erwartete Ausgabe zeigt, dass sowohl Falco- als auch Falcosidekick-Pods ausgeführt werden:

    NAME                            READY   STATUS    RESTARTS   AGE
    falco-xxxxx                     2/2     Running   0          2m
    falco-falcosidekick-xxxxx       1/1     Running   0          2m
    

Option B: Falcosidekick eigenständig bereitstellen

Wenn Falco bereits bereitgestellt ist, können Sie Falcosidekick separat bereitstellen und Falco so konfigurieren, dass Benachrichtigungen an Falcosidekick gesendet werden.

Falcosidekick bereitstellen

  1. Fügen Sie das Falco-Helm-Repository hinzu (falls noch nicht geschehen):

    helm repo add falcosecurity https://falcosecurity.github.io/charts
    helm repo update
    
  2. Erstellen Sie die Google SecOps-Webhook-URL mit Authentifizierung:

    <ENDPOINT_URL>?key=<API_KEY>
    
  3. Installieren Sie Falcosidekick:

    helm install falcosidekick falcosecurity/falcosidekick \
        --namespace falco \
        --set config.webhook.address="<ENDPOINT_URL>?key=<API_KEY>" \
        --set config.webhook.customHeaders="X-Webhook-Access-Key:<SECRET_KEY>" \
        --set config.webhook.minimumpriority="warning"
    

    Ersetzen Sie:

    • <ENDPOINT_URL>: URL des Google SecOps-Feed-Endpunkts
    • <API_KEY>: Google Cloud API-Schlüssel
    • <SECRET_KEY>: Geheimer Google SecOps-Schlüssel aus der Feederstellung
  4. Prüfen Sie, ob Falcosidekick ausgeführt wird:

    kubectl get pods -n falco -l app.kubernetes.io/name=falcosidekick
    

Falco so konfigurieren, dass Benachrichtigungen an Falcosidekick gesendet werden

  1. Rufen Sie den Namen des Falcosidekick-Dienstes ab:

    kubectl get svc -n falco -l app.kubernetes.io/name=falcosidekick
    

    Der Dienstname lautet in der Regel falcosidekick.

  2. Aktualisieren Sie die Falco-Konfiguration, um die HTTP-Ausgabe zu aktivieren:

    Wenn Sie Helm verwenden, aktualisieren Sie den Falco-Release:

    helm upgrade falco falcosecurity/falco \
        --namespace falco \
        --reuse-values \
        --set falco.json_output=true \
        --set falco.json_include_output_property=true \
        --set falco.http_output.enabled=true \
        --set falco.http_output.url="http://falcosidekick:2801/"
    

    Wenn Sie die Falco-Konfiguration manuell verwalten, bearbeiten Sie /etc/falco/falco.yaml:

    json_output: true
    json_include_output_property: true
    
    http_output:
    enabled: true
    url: "http://falcosidekick:2801/"
    
  3. Starten Sie die Falco-Pods neu, um die Konfiguration anzuwenden:

    kubectl rollout restart daemonset/falco -n falco
    

Falcosidekick auf Linux-Hosts konfigurieren

Wenn Sie Falco auf Linux-Hosts (nicht Kubernetes) ausführen, stellen Sie Falcosidekick als systemd-Dienst bereit.

Falcosidekick-Binärdatei installieren

  1. Laden Sie die neueste Falcosidekick-Version herunter:

    FALCOSIDEKICK_VERSION="2.29.0"
    wget https://github.com/falcosecurity/falcosidekick/releases/download/${FALCOSIDEKICK_VERSION}/falcosidekick_${FALCOSIDEKICK_VERSION}_linux_amd64.tar.gz
    
  2. Extrahieren und installieren Sie die Binärdatei:

    sudo tar -C /usr/local/bin/ -xzf falcosidekick_${FALCOSIDEKICK_VERSION}_linux_amd64.tar.gz
    sudo chmod +x /usr/local/bin/falcosidekick
    
  3. Konfigurationsverzeichnis erstellen:

    sudo mkdir -p /etc/falcosidekick
    

Falcosidekick konfigurieren

  1. Erstellen Sie die Konfigurationsdatei /etc/falcosidekick/config.yaml:

    listenaddress: "0.0.0.0"
    listenport: 2801
    debug: false
    
    webhook:
      address: "<ENDPOINT_URL>?key=<API_KEY>"
      method: "POST"
      customHeaders: "X-Webhook-Access-Key:<SECRET_KEY>"
      minimumpriority: "warning"
      checkcert: true
    

    Ersetzen Sie:

    • <ENDPOINT_URL>: URL des Google SecOps-Feed-Endpunkts
    • <API_KEY>: Google Cloud API-Schlüssel
    • <SECRET_KEY>: Geheimer Google SecOps-Schlüssel aus der Feederstellung
  2. Erstellen Sie eine systemd-Dienstdatei /etc/systemd/system/falcosidekick.service:

    [Unit]
    Description=Falcosidekick
    After=network.target
    
    [Service]
    Type=simple
    User=root
    ExecStart=/usr/local/bin/falcosidekick --config-file=/etc/falcosidekick/config.yaml
    Restart=on-failure
    RestartSec=5s
    
    [Install]
    WantedBy=multi-user.target
    
  3. Aktivieren und starten Sie Falcosidekick:

    sudo systemctl daemon-reload
    sudo systemctl enable falcosidekick
    sudo systemctl start falcosidekick
    
  4. Prüfen Sie, ob Falcosidekick ausgeführt wird:

    sudo systemctl status falcosidekick
    

Falco so konfigurieren, dass Benachrichtigungen an Falcosidekick gesendet werden

  1. Bearbeiten Sie die Falco-Konfigurationsdatei /etc/falco/falco.yaml:

    json_output: true
    json_include_output_property: true
    
    http_output:
      enabled: true
      url: "http://localhost:2801/"
    
  2. Starten Sie Falco neu:

    sudo systemctl restart falco
    

Einbindung verifizieren

Testbenachrichtigung auslösen

  1. Lösen Sie eine Falco-Regel aus, indem Sie eine Shell in einem Container ausführen (wenn Sie Kubernetes verwenden):

    kubectl run test-pod --image=nginx --restart=Never
    kubectl exec -it test-pod -- /bin/bash
    

    Dadurch wird die Falco-Regel „Terminal shell in container“ ausgelöst.

  2. Lösen Sie für Linux-Hosts eine Regel aus, indem Sie vertrauliche Dateien lesen:

    cat /etc/shadow
    

    Dadurch wird die Falco-Regel „Read sensitive file untrusted“ ausgelöst.

Falcosidekick-Logs prüfen

  • Für Kubernetes-Deployments:

    kubectl logs -n falco -l app.kubernetes.io/name=falcosidekick --tail=50
    

    Suchen Sie nach Logeinträgen, die auf eine erfolgreiche Webhook-Zustellung hinweisen:

    2025-01-15T10:30:00Z [INFO] : Webhook - Post OK
    
  • Für Linux-Hosts:

    sudo journalctl -u falcosidekick -n 50
    

Ereignisse in Google SecOps prüfen

  1. Rufen Sie Google SecOps > Suche auf.
  2. Führen Sie eine Suchanfrage aus:

    metadata.log_type = "FALCO_IDS"
    
  3. Prüfen Sie, ob Falco-Ereignisse in den Suchergebnissen angezeigt werden.

  4. Prüfen Sie, ob die Ereignisse die erwarteten Felder enthalten, z. B.:

    • rule: Name der Falco-Regel
    • priority: Priorität der Benachrichtigung (Notfall, Benachrichtigung, Kritisch, Fehler, Warnung, Hinweis, Information, Debug)
    • output: menschenlesbare Warnmeldung
    • source: Ereignisquelle (syscall, k8s_audit)
    • hostname – Host, auf dem das Ereignis aufgetreten ist
    • container_id – Container-ID (falls zutreffend)

Filter für Priorität

Falcosidekick unterstützt das Filtern von Ereignissen nach Priorität, um die Anzahl der Warnungen zu reduzieren und sich auf kritische Warnungen zu konzentrieren. לֹ

Prioritätsstufen

Falco verwendet die folgenden Prioritätsstufen (von der höchsten zur niedrigsten):

Priorität Beschreibung Anwendungsfall
Notfall System ist nicht verwendbar Kritische Sicherheitsvorfälle
Benachrichtigung Es müssen sofort Maßnahmen ergriffen werden. Aktive Angriffe, Rechteausweitung
Kritisch Kritische Bedingungen Unbefugter Zugriff, Ausführung von Malware
Fehler Fehlerbedingungen Richtlinienverstöße, verdächtige Aktivitäten
Warnung Warnbedingungen Anomales Verhalten, potenzielle Bedrohungen
Hinweis Normal, aber signifikant Konfigurationsänderungen, Audit-Ereignisse
Informationsbezogen Informationsnachrichten Protokollierung allgemeiner Aktivitäten
Debuggen Nachrichten auf Debug-Ebene Fehlerbehebung, Entwicklung

Mindestpriorität konfigurieren

Wenn Sie nur Benachrichtigungen mit hoher Priorität an Google SecOps senden möchten, legen Sie den Parameter minimumpriority fest:

  • Für Helm-Bereitstellungen:

    helm upgrade falco falcosecurity/falco \
        --namespace falco \
        --reuse-values \
        --set falcosidekick.config.webhook.minimumpriority="error"
    
  • Für Linux-Hosts bearbeiten Sie /etc/falcosidekick/config.yaml:

    webhook:
      minimumpriority: "error"
    

Bei dieser Konfiguration werden nur Ereignisse mit der Priorität error oder höher (Error, Critical, Alert, Emergency) an Google SecOps gesendet.

Benutzerdefinierte Felder

Mit Falcosidekick können Sie allen Ereignissen benutzerdefinierte Felder hinzufügen, um den Kontext und die Filterung in Google SecOps zu verbessern.

Benutzerdefinierte Felder hinzufügen

  • Für Helm-Bereitstellungen:

    helm upgrade falco falcosecurity/falco \
        --namespace falco \
        --reuse-values \
        --set falcosidekick.config.customfields.environment="production" \
        --set falcosidekick.config.customfields.region="us-east-1" \
        --set falcosidekick.config.customfields.cluster="prod-cluster-01"
    
  • Für Linux-Hosts bearbeiten Sie /etc/falcosidekick/config.yaml:

    customfields:
      environment: "production"
      region: "us-east-1"
      datacenter: "dc1"
    

Diese benutzerdefinierten Felder werden jedem Falco-Ereignis hinzugefügt, das an Google SecOps gesendet wird. So können Sie Ereignisse in mehreren Umgebungen filtern und korrelieren.

Alternative Aufnahmepfade

Webhook ist die empfohlene Methode, aber Falcosidekick unterstützt auch alternative Aufnahmepfade für bestimmte Anwendungsfälle.

AWS S3-Aufnahme

In Umgebungen mit hohem Volumen oder bei Compliance-Anforderungen können Sie Falcosidekick so konfigurieren, dass Ereignisse in AWS S3 geschrieben und dann von S3 in Google SecOps aufgenommen werden.

  • Falcosidekick für S3 konfigurieren:

    helm upgrade falco falcosecurity/falco \
        --namespace falco \
        --reuse-values \
        --set falcosidekick.config.aws.accesskeyid="<AWS_ACCESS_KEY>" \
        --set falcosidekick.config.aws.secretaccesskey="<AWS_SECRET_KEY>" \
        --set falcosidekick.config.aws.region="us-east-1" \
        --set falcosidekick.config.aws.s3.bucket="falco-events" \
        --set falcosidekick.config.aws.s3.prefix="runtime-security/"
    

    Falcosidekick schreibt Ereignisse im JSON-Format mit der folgenden Pfadstruktur in S3:

    s3://falco-events/runtime-security/YYYY-MM-DD/YYYY-MM-DDTHH:mm:ss.s+01:00.json
    

    Konfigurieren Sie dann einen Google SecOps-Feed mit Amazon S3 V2 als Quelltyp.

Cloud Storage-Aufnahme

Konfigurieren Sie für Google Cloud -Umgebungen Falcosidekick so, dass Ereignisse in Cloud Storage geschrieben werden.

  • Falcosidekick für GCS konfigurieren:

    1. Erstellen Sie ein Google Cloud -Dienstkonto mit der Rolle Storage-Objekt-Administrator für den Ziel-Bucket.
    2. Laden Sie die JSON-Schlüsseldatei des Dienstkontos herunter.
    3. Codieren Sie den JSON-Schlüssel mit Base64:

      cat service-account-key.json | base64 -w 0
      
    4. Konfigurieren Sie Falcosidekick:

      helm upgrade falco falcosecurity/falco \
          --namespace falco \
          --reuse-values \
          --set falcosidekick.config.gcp.credentials="<BASE64_ENCODED_KEY>" \
          --set falcosidekick.config.gcp.storage.bucket="falco-events" \
          --set falcosidekick.config.gcp.storage.prefix="runtime-security/"
      

      Falcosidekick schreibt Ereignisse mit der folgenden Pfadstruktur in Cloud Storage:

      gs://falco-events/runtime-security/YYYY-MM-DD/YYYY-MM-DDTHH:mm:ss.s+01:00.json
      

    Konfigurieren Sie dann einen Google SecOps-Feed mit Google Cloud Storage V2 als Quelltyp.

AWS Kinesis Firehose-Aufnahme

Konfigurieren Sie Falcosidekick für die Echtzeit-Streamingaufnahme so, dass Ereignisse an AWS Kinesis Firehose gesendet werden.

  • Falcosidekick für Kinesis konfigurieren:

    helm upgrade falco falcosecurity/falco \
        --namespace falco \
        --reuse-values \
        --set falcosidekick.config.aws.accesskeyid="<AWS_ACCESS_KEY>" \
        --set falcosidekick.config.aws.secretaccesskey="<AWS_SECRET_KEY>" \
        --set falcosidekick.config.aws.region="us-east-1" \
        --set falcosidekick.config.aws.kinesis.streamname="falco-events-stream"
    

    Konfigurieren Sie dann einen Google SecOps-Feed mit Amazon Kinesis Firehose als Quelltyp.

Fehlerbehebung

Falcosidekick empfängt keine Ereignisse

  1. Prüfen Sie, ob Falco Ereignisse an Falcosidekick sendet:

    kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50 | grep http_output
    
  2. Prüfen Sie, ob die Falco-Konfiguration die HTTP-Ausgabe enthält:

    kubectl get configmap -n falco falco -o yaml | grep -A 5 http_output
    
  3. Prüfen Sie, ob Falcosidekick Port 2801 überwacht:

    kubectl get svc -n falco falcosidekick
    

Webhook-Zustellungsfehler

  1. Prüfen Sie die Falcosidekick-Logs auf HTTP-Fehler:

    kubectl logs -n falco -l app.kubernetes.io/name=falcosidekick --tail=100 | grep -i error
    
  2. Häufige Fehler:

    • 401 Nicht autorisiert: Falscher API-Schlüssel oder geheimer Schlüssel
    • 403 Forbidden: API-Schlüssel nicht für die Google SecOps API autorisiert
    • SSL-Zertifikatsfehler: Legen Sie checkcert: false für Tests fest (nicht für die Produktion empfohlen).
  3. Webhook manuell testen:

    curl -X POST \
        -H "Content-Type: application/json" \
        -H "X-Webhook-Access-Key: <SECRET_KEY>" \
        -d '{"test": "event"}' \
        "<ENDPOINT_URL>?key=<API_KEY>"
    

Ereignisse werden nicht in Google SecOps angezeigt

  1. Prüfen Sie, ob der Feed aktiv ist:

    • Rufen Sie die Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die Einstellungen > Feeds auf.
    • Prüfen Sie, ob der Feedstatus Aktiv ist.
    • Prüfen Sie, ob die letzte Aufnahmezeit aktuell ist.
  2. Prüfen Sie, ob Aufnahmefehler vorliegen:

    • Rufen Sie die Seite mit den Feeddetails auf.
    • Klicken Sie auf den Tab Fehler.
    • Prüfen Sie, ob Parsing- oder Validierungsfehler vorliegen.
  3. Prüfen Sie die Zuordnung des Logtyps:

    • Suchen Sie nach Logs zu Rohdaten: metadata.log_type = "FALCO_IDS".
    • Wenn Ereignisse angezeigt, aber Felder nicht geparst werden, prüfen Sie die UDM-Zuordnung.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
output_fields.k8s.ns.name, output_fields.k8s.pod.name additional.fields Aus den Objekten „k8_ns_name“ und „k8s_pod_name“ zusammengeführt
stageTimestamp metadata.collected_timestamp Konvertiert im ISO8601-Format
stage, description, output metadata.description Wert aus der Phase, wenn nicht leer, andernfalls Beschreibung, andernfalls Ausgabe
verb, user.uid, uid, output metadata.event_type Auf USER_RESOURCE_ACCESS gesetzt, wenn Verb in GET LIST WATCH; USER_RESOURCE_CREATION, wenn CREATE und (user.uid oder uid nicht leer); USER_RESOURCE_UPDATE_CONTENT, wenn (PATCH oder UPDATE) und user.uid nicht leer; USER_RESOURCE_DELETION, wenn DELETE; oder USER_RESOURCE_ACCESS, wenn die Ausgabe Error enthält, andernfalls USER_UNCATEGORIZED; andernfalls GENERIC_EVENT
Typ metadata.product_event_type Wert direkt kopiert
auditID metadata.product_log_id Wert direkt kopiert
apiVersion, product_version metadata.product_version Wert aus apiVersion, falls nicht leer, andernfalls product_version (nach Entfernen der Anführungszeichen)
portdetails.name network.application_protocol In Großbuchstaben, auf Wert gesetzt, wenn in HTTP, HTTPS, DNS, andernfalls UNKNOWN_APPLICATION_PROTOCOL
Verb network.http.method Wert in Großbuchstaben umgewandelt und direkt kopiert
responseStatus.code network.http.response_code In Ganzzahl konvertiert und direkt kopiert
userAgent network.http.user_agent Wert direkt kopiert
portdetails.protocol network.ip_protocol Wert direkt kopiert
output_fields.cloud-project-id observer.cloud.project.id Wert direkt kopiert
output_fields.pod-name, output_fields.falco.pod.name observer.hostname Wert aus „output_fields.pod-name“, wenn nicht leer, andernfalls „output_fields.falco.pod.name“
output_fields.pod-ip, output_fields.falco.pod.ip observer.ip Wert aus output_fields.pod-ip, wenn nicht leer, andernfalls output_fields.falco.pod.ip
output_fields.falco.host.name principal.asset.hostname Wert direkt kopiert
sourceIPs, output_fields.falco.host.ip principal.asset.ip Zusammengeführt aus jeder IP-Adresse in „sourceIPs“, falls nicht leer, andernfalls aus „output_fields.falco.host.ip“
output_fields.falco.host.name principal.hostname Wert direkt kopiert
sourceIPs, output_fields.falco.host.ip principal.ip Zusammengeführt aus jeder IP-Adresse in „sourceIPs“, falls nicht leer, andernfalls aus „output_fields.falco.host.ip“
output_fields.falco.contact principal.user.email_addresses Wert direkt kopiert
user.groups principal.user.group_identifiers Zusammengeführt aus Array user.groups
user.username, output_fields.user.name principal.user.user_display_name Wert aus user.username, wenn nicht leer, andernfalls output_fields.user.name
user.uid, uid principal.user.userid Wert aus user.uid, wenn nicht leer, andernfalls uid (nach Entfernen der Anführungszeichen)
annotations.authorization.k8s.io/decision security_result.action Auf ALLOW setzen, wenn zulässig
annotations.authorization.k8s.io/reason security_result.description Wert direkt kopiert, Anführungszeichen entfernt
Regel security_result.rule_name Wert direkt kopiert
Priorität security_result.severity_details Wert direkt kopiert
containerid.containerID, output_fields.container.id target.asset.asset_id Wert aus containerid.containerID, wenn nicht leer, andernfalls „container_id:“ + output_fields.container.id
target.asset.deployment_status Wird auf ACTIVE gesetzt, wenn die Instanz ausgeführt wird oder wartet, auf DECOMISSIONED, wenn sie beendet wurde, andernfalls auf DEPLOYMENT_STATUS_UNSPECIFIED.
address.nodeName, output_fields.host-name, tar_host target.asset.hostname Wert aus address.nodeName, wenn nicht leer, andernfalls output_fields.host-name, andernfalls tar_host aus grok in der Ausgabe
address.ip, podip.ip, requestObject.status.podIP, requestObject.status.hostIP, output_fields.host-ip, tar_ip target.asset.ip Zusammengeführt aus address.ip in responseObject.subsets.addresses oder podip.ip in requestObject.status.podIPs oder requestObject.status.podIP oder requestObject.status.hostIP oder output_fields.host-ip oder tar_ip aus grok in der Ausgabe
output_fields.email target.email Wert wird direkt kopiert, wenn er mit dem regulären Ausdruck für E-Mail-Adressen übereinstimmt
containerStatuse.imageID, containerStatuse.image, output_fields.container.image.repository target.file.full_path Wert aus containerStatuse.imageID, wenn nicht leer und file.full_path leer, andernfalls containerStatuse.image, wenn nicht leer und file.full_path leer, andernfalls output_fields.container.image.repository
address.nodeName, output_fields.host-name, tar_host target.hostname Wert aus address.nodeName, wenn nicht leer, andernfalls output_fields.host-name, andernfalls tar_host aus grok in der Ausgabe
address.ip, podip.ip, requestObject.status.podIP, requestObject.status.hostIP, output_fields.host-ip, tar_ip target.ip Zusammengeführt aus address.ip in responseObject.subsets.addresses oder podip.ip in requestObject.status.podIPs oder requestObject.status.podIP oder requestObject.status.hostIP oder output_fields.host-ip oder tar_ip aus grok in der Ausgabe
targetnamespace target.namespace Wert direkt kopiert
portdetails.port target.port In Ganzzahl konvertiert und direkt für den ersten Port kopiert
output_fields.cloud-provider target.resource.attribute.cloud.environment Legen Sie GOOGLE_CLOUD_PLATFORM fest, wenn GCP, oder MICROSOFT_AZURE, wenn Azure
requestObject.status.containerStatuses.0.state.waiting.reason, output_fields.evt.arg.fd, output_fields.evt.arg.filename, output_fields.evt.arg.mode, output_fields.fd.name, output_fields.ol-env, output_fields.tags, output_fields.proc.cmdline, output_fields.ebpf_enabled target.resource.attribute.labels Aus verschiedenen Labelobjekten zusammengeführt
address.targetRef.uid target.resource.id Wert aus address.targetRef.uid, wenn nicht leer und resource_id leer ist
address.targetRef.name, objectRef.name, output_fields.bl-ssr target.resource.name Wert aus address.targetRef.name, wenn nicht leer und resource_name leer, andernfalls objectRef.name, wenn nicht leer und resource_name leer, andernfalls output_fields.bl-ssr, wenn nicht leer und resource_name leer
output_fields.falco.ssrid target.resource.product_object_id Wert direkt kopiert
address.targetRef.kind, objectRef.resource target.resource.resource_subtype Wert aus address.targetRef.kind, wenn nicht leer und target_resource_subtype leer, andernfalls objectRef.resource, wenn nicht leer und target_resource_subtype leer
Ressourcentyp target.resource.resource_type Wird auf CLUSTER gesetzt, wenn leer, andernfalls direkt kopiert
requestURI target.url Wert direkt kopiert
responseObject.spec.group target.user.group_identifiers Zusammengeführt aus Array responseObject.spec.group
responseObject.spec.user target.user.user_display_name Wert direkt kopiert
responseObject.metadata.uid, responseObject.spec.uid, objectRef.uid, requestObject.metadata.uid, output_fields.user.loginuid target.user.userid Wert aus responseObject.metadata.uid, wenn nicht leer, sonst responseObject.spec.uid, sonst objectRef.uid, sonst requestObject.metadata.uid, sonst output_fields.user.loginuid (in String konvertiert)
metadata.product_name Legen Sie „FALCO_IDS“ fest.
metadata.vendor_name Legen Sie „FALCO_IDS“ fest.
priority security_result.priority Aus Änderungsprotokoll zugeordnet
time date Aus Änderungsprotokoll zugeordnet
output_fields.tags target.labels Aus Änderungsprotokoll zugeordnet

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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