Falco-IDS-Logs erfassen
Parserversion: 1.0
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
- Rufen Sie die Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die Einstellungen > Feeds auf.
- Klicken Sie auf Neuen Feed hinzufügen.
- Klicken Sie auf der nächsten Seite auf Einzelnen Feed konfigurieren.
- Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B.
Falco Runtime Security. - Wählen Sie Webhook als Quelltyp aus.
- Wählen Sie Falco IDS als Protokolltyp aus.
- Klicken Sie auf Weiter.
- 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.
- Klicken Sie auf Weiter.
- 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:
- Klicken Sie auf der Feed-Detailseite auf Geheimen Schlüssel generieren.
- In einem Dialogfeld wird der geheime Schlüssel angezeigt.
- Kopieren und speichern Sie den geheimen Schlüssel an einem sicheren Ort.
Feed-Endpunkt-URL abrufen
- Gehen Sie zum Tab Details des Feeds.
- Kopieren Sie im Abschnitt Endpunktinformationen die Feed-Endpunkt-URL.
Das URL-Format lautet:
https://{region}-chronicle.googleapis.com/v1/{parent}/logs:importDabei ist
{region}die Region Ihrer Google SecOps-Instanz (z. B.us,europeoderasia-southeast1) und{parent}der Ressourcenpfad im Formatprojects/<PROJECT_ID>/locations/<LOCATION>/instances/<INSTANCE_ID>/logTypes/<LOG_TYPE>.Speichern Sie diese URL für die nächsten Schritte.
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
- Rufen Sie die Seite „Anmeldedaten“ derGoogle Cloud Console auf.
- Wählen Sie Ihr Projekt aus (das Projekt, das mit Ihrer Google SecOps-Instanz verknüpft ist).
- Klicken Sie auf Anmeldedaten erstellen > API-Schlüssel. Ein API-Schlüssel wird erstellt und in einem Dialogfeld angezeigt.
- Klicken Sie auf API-Schlüssel bearbeiten, um den Schlüssel einzuschränken.
API-Schlüssel einschränken
- 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).
- Name: Geben Sie einen aussagekräftigen Namen ein (z. B.
- Gehen Sie unter API-Einschränkungen so vor:
- Wählen Sie Schlüssel einschränken aus.
- Suchen Sie in der Liste APIs auswählen nach der Google SecOps API (oder Chronicle API) und wählen Sie sie aus.
- Klicken Sie auf Speichern.
- Kopieren Sie den Wert des API-Schlüssels aus dem Feld API-Schlüssel oben auf der Seite.
- 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.
Option A: Mit Falco über Helm bereitstellen (empfohlen)
Wenn Sie Falco zum ersten Mal installieren oder neu bereitstellen können, verwenden Sie diese Methode, um Falco und Falcosidekick zusammen bereitzustellen:
Fügen Sie das Falco-Helm-Repository hinzu:
helm repo add falcosecurity https://falcosecurity.github.io/charts helm repo updateErstellen Sie einen Namespace für Falco:
kubectl create namespace falcoErstellen 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...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=trueErsetzen 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
Bereitstellung prüfen:
kubectl get pods -n falcoDie 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
Fügen Sie das Falco-Helm-Repository hinzu (falls noch nicht geschehen):
helm repo add falcosecurity https://falcosecurity.github.io/charts helm repo updateErstellen Sie die Google SecOps-Webhook-URL mit Authentifizierung:
<ENDPOINT_URL>?key=<API_KEY>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
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
Rufen Sie den Namen des Falcosidekick-Dienstes ab:
kubectl get svc -n falco -l app.kubernetes.io/name=falcosidekickDer Dienstname lautet in der Regel
falcosidekick.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/"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
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.gzExtrahieren 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/falcosidekickKonfigurationsverzeichnis erstellen:
sudo mkdir -p /etc/falcosidekick
Falcosidekick konfigurieren
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: trueErsetzen 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
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.targetAktivieren und starten Sie Falcosidekick:
sudo systemctl daemon-reload sudo systemctl enable falcosidekick sudo systemctl start falcosidekickPrüfen Sie, ob Falcosidekick ausgeführt wird:
sudo systemctl status falcosidekick
Falco so konfigurieren, dass Benachrichtigungen an Falcosidekick gesendet werden
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/"Starten Sie Falco neu:
sudo systemctl restart falco
Einbindung verifizieren
Testbenachrichtigung auslösen
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/bashDadurch wird die Falco-Regel „Terminal shell in container“ ausgelöst.
Lösen Sie für Linux-Hosts eine Regel aus, indem Sie vertrauliche Dateien lesen:
cat /etc/shadowDadurch 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=50Suchen Sie nach Logeinträgen, die auf eine erfolgreiche Webhook-Zustellung hinweisen:
2025-01-15T10:30:00Z [INFO] : Webhook - Post OKFür Linux-Hosts:
sudo journalctl -u falcosidekick -n 50
Ereignisse in Google SecOps prüfen
- Rufen Sie Google SecOps > Suche auf.
Führen Sie eine Suchanfrage aus:
metadata.log_type = "FALCO_IDS"Prüfen Sie, ob Falco-Ereignisse in den Suchergebnissen angezeigt werden.
Prüfen Sie, ob die Ereignisse die erwarteten Felder enthalten, z. B.:
rule: Name der Falco-Regelpriority: Priorität der Benachrichtigung (Notfall, Benachrichtigung, Kritisch, Fehler, Warnung, Hinweis, Information, Debug)output: menschenlesbare Warnmeldungsource: Ereignisquelle (syscall, k8s_audit)hostname– Host, auf dem das Ereignis aufgetreten istcontainer_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.jsonKonfigurieren 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:
- Erstellen Sie ein Google Cloud -Dienstkonto mit der Rolle Storage-Objekt-Administrator für den Ziel-Bucket.
- Laden Sie die JSON-Schlüsseldatei des Dienstkontos herunter.
Codieren Sie den JSON-Schlüssel mit Base64:
cat service-account-key.json | base64 -w 0Konfigurieren 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
Prüfen Sie, ob Falco Ereignisse an Falcosidekick sendet:
kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50 | grep http_outputPrüfen Sie, ob die Falco-Konfiguration die HTTP-Ausgabe enthält:
kubectl get configmap -n falco falco -o yaml | grep -A 5 http_outputPrüfen Sie, ob Falcosidekick Port 2801 überwacht:
kubectl get svc -n falco falcosidekick
Webhook-Zustellungsfehler
Prüfen Sie die Falcosidekick-Logs auf HTTP-Fehler:
kubectl logs -n falco -l app.kubernetes.io/name=falcosidekick --tail=100 | grep -i errorHä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: falsefür Tests fest (nicht für die Produktion empfohlen).
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
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.
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.
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.
- Suchen Sie nach Logs zu Rohdaten:
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