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 ist auf Kubernetes (über Helm) oder Linux-Hosts installiert.
  • Kann Falco-Konfigurationsdateien oder Helm-Werte ändern
  • Berechtigter Zugriff zum Bereitstellen von Falcosidekick (falls noch nicht bereitgestellt)

Webhook-Feed in Google SecOps erstellen

Feed erstellen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf der nächsten Seite auf Einen 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 Logtyp aus.
  7. Klicken Sie auf Weiter.
  8. Geben Sie Werte für die folgenden Eingabeparameter an:
    • Trennzeichen für Aufteilung (optional): Feld 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 Nachrichten-Feed-Konfiguration 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. Ein Dialogfeld mit dem geheimen Schlüssel wird 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

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

API-Schlüssel erstellen

  1. Rufen Sie in der Google Cloud Console die Seite „Anmeldedaten“ 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 API-Schlüssel-Einstellungen:
    • 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 Google SecOps API (oder Chronicle API) und wählen Sie die API 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 sicher.

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 es neu bereitstellen können, verwenden Sie diese Methode, um sowohl Falco als auch Falcosidekick 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 es noch nicht hinzugefügt wurde:

    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 Falcosidekick-Dienstnamen 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, führen Sie ein Upgrade des Falco-Release durch:

    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. Falco neu starten:

    sudo systemctl restart falco

Einbindung prüfen

Testwarnung 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“ (Sensible Datei von nicht vertrauenswürdiger Quelle lesen) 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 – Falco-Regelname
    • priority: Priorität der Benachrichtigung (Notfall, Benachrichtigung, Kritisch, Fehler, Warnung, Hinweis, Information, Fehlerbehebung)
    • output: menschenlesbare Benachrichtigung
    • source – Ereignisquelle (syscall, k8s_audit)
    • hostname: Host, auf dem das Ereignis aufgetreten ist
    • container_id – Container-ID (falls zutreffend)

Prioritätsfilterung

Falcosidekick unterstützt das Filtern von Ereignissen nach Priorität, um die Anzahl der Benachrichtigungen 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 sind sofortige Maßnahmen erforderlich. 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 Allgemeine Aktivitätsprotokollierung
Debuggen Meldungen 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

Webhooks sind 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 in S3 mit der Pfadstruktur:

    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.

GCP Cloud Storage-Aufnahme

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

  • Falcosidekick für GCS konfigurieren:

    1. Erstellen Sie ein GCP-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 GCS:

      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 den 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 Unauthorized (Nicht autorisiert): Falscher API-Schlüssel oder geheimer Schlüssel
    • 403 Forbidden: API-Schlüssel nicht für 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 SIEM-Einstellungen > Feeds auf.
    • Der Feedstatus muss Aktiv sein.
    • Prüfen Sie, ob die Letzte Aufnahmezeit aktuell ist.

  2. Prüfen Sie, ob Aufnahme-Fehler 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 werden, 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 Zusammengeführt aus den Objekten „k8_ns_name“ und „k8s_pod_name“
stageTimestamp metadata.collected_timestamp Konvertiert im ISO8601-Format
stage, description, output metadata.description Wert aus der Phase, falls 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, wenn 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 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“, falls 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, falls 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“, wenn 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“, falls nicht leer, andernfalls „uid“ (nach dem Entfernen von 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 Auf „ACTIVE“ gesetzt, wenn die Ausführung oder der Wartezustand läuft, auf „DECOMISSIONED“, wenn die Ausführung beendet wurde, andernfalls „DEPLOYMENT_STATUS_UNSPECIFIED“
address.nodeName, output_fields.host-name, tar_host target.asset.hostname Wert aus address.nodeName, wenn nicht leer, sonst output_fields.host-name, sonst 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“, falls nicht leer und „file.full_path“ leer ist, andernfalls „containerStatuse.image“, falls nicht leer und „file.full_path“ leer ist, andernfalls „output_fields.container.image.repository“
address.nodeName, output_fields.host-name, tar_host target.hostname Wert aus „address.nodeName“, falls nicht leer, andernfalls „output_fields.host-name“, andernfalls „tar_host“ aus „grok on output“
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 Auf GOOGLE_CLOUD_PLATFORM für GCP und MICROSOFT_AZURE für Azure festlegen
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