Collecter les journaux Falco IDS
Version de l'analyseur : 1.0
Ce document explique comment configurer Falco pour qu'il envoie des alertes de sécurité d'exécution à Google Security Operations à l'aide de webhooks via Falcosidekick.
Falco est un outil de sécurité d'exécution Open Source qui détecte les comportements inattendus des applications et alerte sur les menaces au moment de l'exécution. Il utilise la surveillance des appels système pour détecter les activités anormales dans les conteneurs, Kubernetes et les hôtes Linux en fonction de règles de sécurité personnalisables.
Avant de commencer
Assurez-vous de remplir les conditions préalables suivantes :
- Une instance Google SecOps
- Falco installé sur des hôtes Kubernetes (via Helm) ou Linux
- Accès permettant de modifier les fichiers de configuration Falco ou les valeurs Helm
- Accès privilégié pour déployer Falcosidekick (si ce n'est pas déjà fait)
Créer un flux de webhook dans Google SecOps
Créer le flux
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Cliquez sur Ajouter un flux d'actualités.
- Sur la page suivante, cliquez sur Configurer un seul flux.
- Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple,
Falco Runtime Security). - Sélectionnez Webhook comme type de source.
- Sélectionnez Falco IDS comme Type de journal.
- Cliquez sur Suivant.
- Spécifiez les valeurs des paramètres d'entrée suivants :
- Délimiteur de fractionnement (facultatif) : laissez ce champ vide (Falcosidekick envoie un événement par requête).
- Espace de noms de l'élément : espace de noms de l'élément
- Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.
- Cliquez sur Suivant.
- Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.
Générer et enregistrer une clé secrète
Après avoir créé le flux, vous devez générer une clé secrète pour l'authentification :
- Sur la page d'informations du flux, cliquez sur Générer une clé secrète.
- Une boîte de dialogue affiche la clé secrète.
- Copiez et enregistrez la clé secrète de manière sécurisée.
Obtenir l'URL du point de terminaison du flux
- Accédez à l'onglet Détails du flux.
- Dans la section Informations sur le point de terminaison, copiez l'URL du point de terminaison du flux.
Le format d'URL est le suivant :
https://{region}-chronicle.googleapis.com/v1/{parent}/logs:importOù
{region}est la région de votre instance Google SecOps (par exemple,us,europeouasia-southeast1) et{parent}est le chemin d'accès à la ressource au formatprojects/<PROJECT_ID>/locations/<LOCATION>/instances/<INSTANCE_ID>/logTypes/<LOG_TYPE>.Enregistrez cette URL pour les étapes suivantes.
Cliquez sur OK.
Créer une clé API Google Cloud
Google SecOps nécessite une clé API pour l'authentification. Créez une clé API restreinte dans la Google Cloud Console.
Créer la clé API
- Accédez à la page Identifiants de la console Google Cloud.
- Sélectionnez votre projet (celui associé à votre instance Google SecOps).
- Cliquez sur Créer des identifiants > Clé API. Une clé API est créée et s'affiche dans une boîte de dialogue.
- Cliquez sur Modifier la clé API pour restreindre la clé.
Restreindre la clé API
- Sur la page des paramètres de la clé API :
- Nom : saisissez un nom descriptif (par exemple,
Chronicle Webhook API Key).
- Nom : saisissez un nom descriptif (par exemple,
- Sous Restrictions relatives aux API :
- Sélectionnez Restreindre la clé.
- Dans la liste Sélectionner des API, recherchez et sélectionnez API Google SecOps (ou API Chronicle).
- Cliquez sur Enregistrer.
- Copiez la valeur de la clé API dans le champ Clé API en haut de la page.
- Enregistrez la clé API de manière sécurisée.
Déployer Falcosidekick
Falcosidekick est le redirecteur de proxy officiel de Falco qui achemine les alertes vers plusieurs destinations, y compris les webhooks, le stockage cloud et les plates-formes SIEM.
Option A : Déployer avec Falco à l'aide de Helm (recommandé)
Si vous installez Falco pour la première fois ou si vous pouvez le redéployer, utilisez cette méthode pour déployer Falco et Falcosidekick ensemble :
Ajoutez le dépôt Helm Falco :
helm repo add falcosecurity https://falcosecurity.github.io/charts helm repo updateCréez un espace de noms pour Falco :
kubectl create namespace falcoCréez l'URL de webhook Google SecOps avec authentification :
<ENDPOINT_URL>?key=<API_KEY>Exemple :
https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=AIzaSyD...Installez Falco avec Falcosidekick activé :
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=trueRemplacez :
<ENDPOINT_URL>: URL du point de terminaison du flux Google SecOps<API_KEY>: clé API Google Cloud<SECRET_KEY>: clé secrète Google SecOps issue de la création du flux
Vérifiez le déploiement :
kubectl get pods -n falcoLe résultat attendu montre que les pods Falco et Falcosidekick sont en cours d'exécution :
NAME READY STATUS RESTARTS AGE falco-xxxxx 2/2 Running 0 2m falco-falcosidekick-xxxxx 1/1 Running 0 2m
Option B : Déployer Falcosidekick de manière autonome
Si Falco est déjà déployé, vous pouvez déployer Falcosidekick séparément et configurer Falco pour qu'il lui envoie des alertes.
Déployer Falcosidekick
Ajoutez le dépôt Helm Falco (s'il n'est pas déjà ajouté) :
helm repo add falcosecurity https://falcosecurity.github.io/charts helm repo updateCréez l'URL de webhook Google SecOps avec authentification :
<ENDPOINT_URL>?key=<API_KEY>Installez 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"Remplacez :
<ENDPOINT_URL>: URL du point de terminaison du flux Google SecOps<API_KEY>: clé API Google Cloud<SECRET_KEY>: clé secrète Google SecOps issue de la création du flux
Vérifiez que Falcosidekick est en cours d'exécution :
kubectl get pods -n falco -l app.kubernetes.io/name=falcosidekick
Configurer Falco pour envoyer des alertes à Falcosidekick
Obtenez le nom du service Falcosidekick :
kubectl get svc -n falco -l app.kubernetes.io/name=falcosidekickLe nom du service est généralement
falcosidekick.Mettez à jour la configuration de Falco pour activer la sortie HTTP :
Si vous utilisez Helm, mettez à niveau la version de Falco :
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/"Si vous gérez manuellement la configuration de Falco, modifiez
/etc/falco/falco.yaml:json_output: true json_include_output_property: true http_output: enabled: true url: "http://falcosidekick:2801/"Redémarrez les pods Falco pour appliquer la configuration :
kubectl rollout restart daemonset/falco -n falco
Configurer Falcosidekick sur des hôtes Linux
Si vous exécutez Falco sur des hôtes Linux (et non Kubernetes), déployez Falcosidekick en tant que service systemd.
Installer le binaire Falcosidekick
Téléchargez la dernière version de Falcosidekick :
FALCOSIDEKICK_VERSION="2.29.0" wget https://github.com/falcosecurity/falcosidekick/releases/download/${FALCOSIDEKICK_VERSION}/falcosidekick_${FALCOSIDEKICK_VERSION}_linux_amd64.tar.gzExtrayez et installez le binaire :
sudo tar -C /usr/local/bin/ -xzf falcosidekick_${FALCOSIDEKICK_VERSION}_linux_amd64.tar.gz sudo chmod +x /usr/local/bin/falcosidekickCréez le répertoire de configuration :
sudo mkdir -p /etc/falcosidekick
Configurer Falcosidekick
Créez le fichier de configuration
/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: trueRemplacez :
<ENDPOINT_URL>: URL du point de terminaison du flux Google SecOps<API_KEY>: clé API Google Cloud<SECRET_KEY>: clé secrète Google SecOps issue de la création du flux
Créez un fichier de service systemd
/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.targetActivez et démarrez Falcosidekick :
sudo systemctl daemon-reload sudo systemctl enable falcosidekick sudo systemctl start falcosidekickVérifiez que Falcosidekick est en cours d'exécution :
sudo systemctl status falcosidekick
Configurer Falco pour envoyer des alertes à Falcosidekick
Modifiez le fichier de configuration Falco
/etc/falco/falco.yaml:json_output: true json_include_output_property: true http_output: enabled: true url: "http://localhost:2801/"Redémarrez Falco :
sudo systemctl restart falco
Vérifier l'intégration
Déclencher une alerte test
Déclenchez une règle Falco en exécutant un shell dans un conteneur (si vous utilisez Kubernetes) :
kubectl run test-pod --image=nginx --restart=Never kubectl exec -it test-pod -- /bin/bashCela déclenche la règle Falco "Terminal shell in container".
Pour les hôtes Linux, déclenchez une règle en lisant des fichiers sensibles :
cat /etc/shadowCela déclenche la règle Falco "Read sensitive file untrusted" (Lecture d'un fichier sensible non fiable).
Vérifier les journaux Falcosidekick
Pour les déploiements Kubernetes :
kubectl logs -n falco -l app.kubernetes.io/name=falcosidekick --tail=50Recherchez les entrées de journal indiquant que la distribution du webhook a réussi :
2025-01-15T10:30:00Z [INFO] : Webhook - Post OKPour les hôtes Linux :
sudo journalctl -u falcosidekick -n 50
Vérifier les événements dans Google SecOps
- Accédez à Google SecOps > Recherche.
Exécutez une requête de recherche :
metadata.log_type = "FALCO_IDS"Vérifiez que les événements Falco apparaissent dans les résultats de recherche.
Vérifiez que les événements contiennent les champs attendus, par exemple :
rule: nom de la règle Falcopriority: priorité de l'alerte (Urgence, Alerte, Critique, Erreur, Avertissement, Avis, Information, Débogage)output: message d'alerte lisible par l'humainsource: source de l'événement (syscall, k8s_audit)hostname: hôte où l'événement s'est produitcontainer_id: ID de conteneur (le cas échéant)
Filtrage par priorité
Falcosidekick permet de filtrer les événements par priorité afin de réduire le bruit et de se concentrer sur les alertes critiques. לֹ
Niveaux de priorité
Falco utilise les niveaux de priorité suivants (du plus élevé au plus faible) :
| Priorité | Description | Cas d'utilisation |
|---|---|---|
| Urgence | Le système est inutilisable | Incidents de sécurité critiques |
| Alerte | Action immédiate requise | Attaques actives, élévation des privilèges |
| Critique | Conditions critiques | Accès non autorisé, exécution de logiciels malveillants |
| Erreur | Conditions d'erreur | Non-respect des règles, activité suspecte |
| Avertissement | Conditions d'avertissement | Comportement anormal, menaces potentielles |
| Avis | Normal, mais significatif | Modifications de configuration, événements d'audit |
| Une fonctionnalité informationnelle | Messages d'information | Journalisation des activités générales |
| Debug | Messages de niveau débogage | Dépannage, développement |
Configurer la priorité minimale
Pour n'envoyer que les alertes à priorité élevée à Google SecOps, définissez le paramètre minimumpriority :
Pour les déploiements Helm :
helm upgrade falco falcosecurity/falco \ --namespace falco \ --reuse-values \ --set falcosidekick.config.webhook.minimumpriority="error"Pour les hôtes Linux, modifiez
/etc/falcosidekick/config.yaml:webhook: minimumpriority: "error"
Cette configuration n'envoie à Google SecOps que les événements de priorité error ou supérieure (Erreur, Critique, Alerte, Urgence).
Champs personnalisés
Falcosidekick permet d'ajouter des champs personnalisés à tous les événements pour améliorer le contexte et le filtrage dans Google SecOps.
Ajouter des champs personnalisés
Pour les déploiements Helm :
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"Pour les hôtes Linux, modifiez
/etc/falcosidekick/config.yaml:customfields: environment: "production" region: "us-east-1" datacenter: "dc1"
Ces champs personnalisés sont ajoutés à chaque événement Falco envoyé à Google SecOps, ce qui permet de filtrer et de corréler les événements dans plusieurs environnements.
Autres chemins d'ingestion
Bien que le webhook soit la méthode recommandée, Falcosidekick accepte d'autres chemins d'ingestion pour des cas d'utilisation spécifiques.
Ingestion AWS S3
Pour les environnements à volume élevé ou les exigences de conformité, vous pouvez configurer Falcosidekick pour qu'il écrive des événements dans AWS S3, puis les ingère depuis S3 vers Google SecOps.
Configurez Falcosidekick pour S3 :
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 écrit les événements dans S3 au format JSON avec la structure de chemin d'accès suivante :
s3://falco-events/runtime-security/YYYY-MM-DD/YYYY-MM-DDTHH:mm:ss.s+01:00.jsonConfigurez ensuite un flux Google SecOps avec Amazon S3 V2 comme type de source.
Ingestion GCP Cloud Storage
Pour les environnements GCP, configurez Falcosidekick pour qu'il écrive les événements dans Google Cloud Storage.
Configurez Falcosidekick pour GCS :
- Créez un compte de service GCP avec le rôle Administrateur des objets de l'espace de stockage sur le bucket cible.
- Téléchargez le fichier de clé JSON du compte de service.
Encodez la clé JSON en base64 :
cat service-account-key.json | base64 -w 0Configurez 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 écrit les événements dans GCS avec la structure de chemin d'accès suivante :
gs://falco-events/runtime-security/YYYY-MM-DD/YYYY-MM-DDTHH:mm:ss.s+01:00.json
Configurez ensuite un flux Google SecOps avec Google Cloud Storage V2 comme type de source.
Ingestion AWS Kinesis Firehose
Pour l'ingestion en flux continu en temps réel, configurez Falcosidekick pour qu'il envoie des événements à AWS Kinesis Firehose.
Configurez Falcosidekick pour Kinesis :
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"Configurez ensuite un flux Google SecOps avec Amazon Kinesis Firehose comme type de source.
Dépannage
Falcosidekick ne reçoit pas d'événements
Vérifiez que Falco envoie des événements à Falcosidekick :
kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50 | grep http_outputVérifiez que la configuration de Falco inclut la sortie HTTP :
kubectl get configmap -n falco falco -o yaml | grep -A 5 http_outputVérifiez que Falcosidekick écoute sur le port 2801 :
kubectl get svc -n falco falcosidekick
Échecs de diffusion du webhook
Vérifiez les journaux Falcosidekick pour détecter les erreurs HTTP :
kubectl logs -n falco -l app.kubernetes.io/name=falcosidekick --tail=100 | grep -i errorErreurs courantes :
- 401 Unauthorized : clé API ou clé secrète incorrecte
- 403 Forbidden : clé API non autorisée pour l'API Google SecOps
- Erreurs de certificat SSL : définissez
checkcert: falsepour les tests (non recommandé pour la production).
Tester le webhook manuellement :
curl -X POST \ -H "Content-Type: application/json" \ -H "X-Webhook-Access-Key: <SECRET_KEY>" \ -d '{"test": "event"}' \ "<ENDPOINT_URL>?key=<API_KEY>"
Les événements n'apparaissent pas dans Google SecOps
Vérifiez que le flux est actif :
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Vérifiez que l'état du flux est Actif.
- Vérifiez que l'heure de la dernière ingestion est récente.
Vérifiez s'il y a des erreurs d'ingestion :
- Accédez à la page d'informations du flux.
- Cliquez sur l'onglet Erreurs.
- Examinez les éventuelles erreurs d'analyse ou de validation.
Vérifiez le mappage du type de journal :
- Recherchez les journaux bruts :
metadata.log_type = "FALCO_IDS". - Si des événements s'affichent, mais que les champs ne sont pas analysés, vérifiez le mappage UDM.
- Recherchez les journaux bruts :
Table de mappage UDM
| Champ du journal | mappage UDM | Logique |
|---|---|---|
| output_fields.k8s.ns.name, output_fields.k8s.pod.name | additional.fields | Fusionné à partir des objets k8_ns_name et k8s_pod_name |
| stageTimestamp | metadata.collected_timestamp | Converti au format ISO 8601 |
| stage, description, output | metadata.description | Valeur de l'étape si elle n'est pas vide, sinon description, sinon sortie |
| verb, user.uid, uid, output | metadata.event_type | Définissez sur USER_RESOURCE_ACCESS si le verbe est GET, LIST ou WATCH ; USER_RESOURCE_CREATION si CREATE et (user.uid ou uid n'est pas vide) ; USER_RESOURCE_UPDATE_CONTENT si (PATCH ou UPDATE) et user.uid n'est pas vide ; USER_RESOURCE_DELETION si DELETE ; ou USER_RESOURCE_ACCESS si la sortie contient une erreur, sinon USER_UNCATEGORIZED ; sinon GENERIC_EVENT |
| kind | metadata.product_event_type | Valeur copiée directement |
| auditID | metadata.product_log_id | Valeur copiée directement |
| apiVersion, product_version | metadata.product_version | Valeur de apiVersion si elle n'est pas vide, sinon product_version (après suppression des guillemets) |
| portdetails.name | network.application_protocol | En majuscules, défini sur la valeur si dans HTTP, HTTPS ou DNS, sinon UNKNOWN_APPLICATION_PROTOCOL |
| verbe | network.http.method | Valeur convertie en majuscules et copiée directement |
| responseStatus.code | network.http.response_code | Converti en entier et copié directement |
| userAgent | network.http.user_agent | Valeur copiée directement |
| portdetails.protocol | network.ip_protocol | Valeur copiée directement |
| output_fields.cloud-project-id | observer.cloud.project.id | Valeur copiée directement |
| output_fields.pod-name, output_fields.falco.pod.name | observer.hostname | Valeur de output_fields.pod-name si elle n'est pas vide, sinon output_fields.falco.pod.name |
| output_fields.pod-ip, output_fields.falco.pod.ip | observer.ip | Valeur de output_fields.pod-ip si elle n'est pas vide, sinon output_fields.falco.pod.ip |
| output_fields.falco.host.name | principal.asset.hostname | Valeur copiée directement |
| sourceIPs, output_fields.falco.host.ip | principal.asset.ip | Fusionné à partir de chaque adresse IP dans sourceIPs si le champ n'est pas vide, sinon à partir de output_fields.falco.host.ip |
| output_fields.falco.host.name | principal.hostname | Valeur copiée directement |
| sourceIPs, output_fields.falco.host.ip | principal.ip | Fusionné à partir de chaque adresse IP dans sourceIPs si le champ n'est pas vide, sinon à partir de output_fields.falco.host.ip |
| output_fields.falco.contact | principal.user.email_addresses | Valeur copiée directement |
| user.groups | principal.user.group_identifiers | Fusionné à partir du tableau user.groups |
| user.username, output_fields.user.name | principal.user.user_display_name | Valeur de user.username si elle n'est pas vide, sinon output_fields.user.name |
| user.uid, uid | principal.user.userid | Valeur de user.uid si elle n'est pas vide, sinon uid (après suppression des guillemets) |
| annotations.authorization.k8s.io/decision | security_result.action | Définissez sur ALLOW si l'accès est autorisé. |
| annotations.authorization.k8s.io/reason | security_result.description | Valeur copiée directement, guillemets supprimés |
| règle | security_result.rule_name | Valeur copiée directement |
| priorité | security_result.severity_details | Valeur copiée directement |
| containerid.containerID, output_fields.container.id | target.asset.asset_id | Valeur de containerid.containerID si elle n'est pas vide, sinon "container_id:" + output_fields.container.id |
| target.asset.deployment_status | Définissez sur ACTIVE si l'instance est en cours d'exécution ou en attente, sur DECOMISSIONED si elle est arrêtée, ou sur DEPLOYMENT_STATUS_UNSPECIFIED. | |
| address.nodeName, output_fields.host-name, tar_host | target.asset.hostname | Valeur de address.nodeName si elle n'est pas vide, sinon output_fields.host-name, sinon tar_host de grok sur la sortie |
| address.ip, podip.ip, requestObject.status.podIP, requestObject.status.hostIP, output_fields.host-ip, tar_ip | target.asset.ip | Fusionné à partir de address.ip dans responseObject.subsets.addresses, ou podip.ip dans requestObject.status.podIPs, ou requestObject.status.podIP, ou requestObject.status.hostIP, ou output_fields.host-ip, ou tar_ip de grok sur la sortie |
| output_fields.email | target.email | Valeur copiée directement si elle correspond à l'expression régulière d'adresse e-mail |
| containerStatuse.imageID, containerStatuse.image, output_fields.container.image.repository | target.file.full_path | Valeur de containerStatuse.imageID si elle n'est pas vide et que file.full_path est vide, sinon containerStatuse.image si elle n'est pas vide et que file.full_path est vide, sinon output_fields.container.image.repository |
| address.nodeName, output_fields.host-name, tar_host | target.hostname | Valeur de address.nodeName si elle n'est pas vide, sinon output_fields.host-name, sinon tar_host de grok sur la sortie |
| address.ip, podip.ip, requestObject.status.podIP, requestObject.status.hostIP, output_fields.host-ip, tar_ip | target.ip | Fusionné à partir de address.ip dans responseObject.subsets.addresses, ou podip.ip dans requestObject.status.podIPs, ou requestObject.status.podIP, ou requestObject.status.hostIP, ou output_fields.host-ip, ou tar_ip de grok sur la sortie |
| targetnamespace | target.namespace | Valeur copiée directement |
| portdetails.port | target.port | Converti en entier et copié directement pour le premier port |
| output_fields.cloud-provider | target.resource.attribute.cloud.environment | Définissez cette option sur GOOGLE_CLOUD_PLATFORM si vous utilisez GCP, ou sur MICROSOFT_AZURE si vous utilisez 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 | Fusionné à partir de divers objets d'étiquette |
| address.targetRef.uid | target.resource.id | Valeur de address.targetRef.uid si elle n'est pas vide et que resource_id est vide |
| address.targetRef.name, objectRef.name, output_fields.bl-ssr | target.resource.name | Valeur de address.targetRef.name si elle n'est pas vide et que resource_name est vide, sinon objectRef.name si elle n'est pas vide et que resource_name est vide, sinon output_fields.bl-ssr si elle n'est pas vide et que resource_name est vide |
| output_fields.falco.ssrid | target.resource.product_object_id | Valeur copiée directement |
| address.targetRef.kind, objectRef.resource | target.resource.resource_subtype | Valeur de address.targetRef.kind si elle n'est pas vide et que target_resource_subtype est vide, sinon objectRef.resource si elle n'est pas vide et que target_resource_subtype est vide |
| resource_type | target.resource.resource_type | Définie sur CLUSTER si elle est vide, sinon copiée directement |
| requestURI | target.url | Valeur copiée directement |
| responseObject.spec.group | target.user.group_identifiers | Fusionné à partir du tableau responseObject.spec.group |
| responseObject.spec.user | target.user.user_display_name | Valeur copiée directement |
| responseObject.metadata.uid, responseObject.spec.uid, objectRef.uid, requestObject.metadata.uid, output_fields.user.loginuid | target.user.userid | Valeur de responseObject.metadata.uid si elle n'est pas vide, sinon responseObject.spec.uid, sinon objectRef.uid, sinon requestObject.metadata.uid, sinon output_fields.user.loginuid (convertie en chaîne) |
| metadata.product_name | Définissez cette option sur "FALCO_IDS". | |
| metadata.vendor_name | Définissez cette option sur "FALCO_IDS". | |
priority |
security_result.priority |
Mappé à partir du journal des modifications |
time |
date |
Mappé à partir du journal des modifications |
output_fields.tags |
target.labels |
Mappé à partir du journal des modifications |
Journal des modifications
Afficher le journal des modifications de cet analyseur
Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.