Collecter les journaux Falco IDS

Version de l'analyseur : 1.0

Compatible avec :

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

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Sur la page suivante, cliquez sur Configurer un seul flux.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Falco Runtime Security).
  5. Sélectionnez Webhook comme type de source.
  6. Sélectionnez Falco IDS comme Type de journal.
  7. Cliquez sur Suivant.
  8. 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.
  9. Cliquez sur Suivant.
  10. 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 :

  1. Sur la page d'informations du flux, cliquez sur Générer une clé secrète.
  2. Une boîte de dialogue affiche la clé secrète.
  3. Copiez et enregistrez la clé secrète de manière sécurisée.

Obtenir l'URL du point de terminaison du flux

  1. Accédez à l'onglet Détails du flux.
  2. Dans la section Informations sur le point de terminaison, copiez l'URL du point de terminaison du flux.
  3. Le format d'URL est le suivant :

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

    Où {region} est la région de votre instance Google SecOps (par exemple, us, europe ou asia-southeast1) et {parent} est le chemin d'accès à la ressource au format projects/<PROJECT_ID>/locations/<LOCATION>/instances/<INSTANCE_ID>/logTypes/<LOG_TYPE>.

  4. Enregistrez cette URL pour les étapes suivantes.

  5. 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

  1. Accédez à la page Identifiants de la console Google Cloud.
  2. Sélectionnez votre projet (celui associé à votre instance Google SecOps).
  3. Cliquez sur Créer des identifiants > Clé API. Une clé API est créée et s'affiche dans une boîte de dialogue.
  4. Cliquez sur Modifier la clé API pour restreindre la clé.

Restreindre la clé API

  1. Sur la page des paramètres de la clé API :
    • Nom : saisissez un nom descriptif (par exemple, Chronicle Webhook API Key).
  2. Sous Restrictions relatives aux API :
    1. Sélectionnez Restreindre la clé.
    2. Dans la liste Sélectionner des API, recherchez et sélectionnez API Google SecOps (ou API Chronicle).
  3. Cliquez sur Enregistrer.
  4. Copiez la valeur de la clé API dans le champ Clé API en haut de la page.
  5. 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.

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 :

  1. Ajoutez le dépôt Helm Falco :

    helm repo add falcosecurity https://falcosecurity.github.io/charts
    helm repo update
    
  2. Créez un espace de noms pour Falco :

    kubectl create namespace falco
    
  3. Cré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...
    
  4. 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=true
    

    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
  5. Vérifiez le déploiement :

    kubectl get pods -n falco
    

    Le 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

  1. 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 update
    
  2. Créez l'URL de webhook Google SecOps avec authentification :

    <ENDPOINT_URL>?key=<API_KEY>
    
  3. 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
  4. 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

  1. Obtenez le nom du service Falcosidekick :

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

    Le nom du service est généralement falcosidekick.

  2. 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/"
    
  3. 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

  1. 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.gz
    
  2. Extrayez et installez le binaire :

    sudo tar -C /usr/local/bin/ -xzf falcosidekick_${FALCOSIDEKICK_VERSION}_linux_amd64.tar.gz
    sudo chmod +x /usr/local/bin/falcosidekick
    
  3. Créez le répertoire de configuration :

    sudo mkdir -p /etc/falcosidekick
    

Configurer Falcosidekick

  1. 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: true
    

    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
  2. 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.target
    
  3. Activez et démarrez Falcosidekick :

    sudo systemctl daemon-reload
    sudo systemctl enable falcosidekick
    sudo systemctl start falcosidekick
    
  4. Vérifiez que Falcosidekick est en cours d'exécution :

    sudo systemctl status falcosidekick
    

Configurer Falco pour envoyer des alertes à Falcosidekick

  1. 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/"
    
  2. Redémarrez Falco :

    sudo systemctl restart falco
    

Vérifier l'intégration

Déclencher une alerte test

  1. 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/bash
    

    Cela déclenche la règle Falco "Terminal shell in container".

  2. Pour les hôtes Linux, déclenchez une règle en lisant des fichiers sensibles :

    cat /etc/shadow
    

    Cela 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=50
    

    Recherchez les entrées de journal indiquant que la distribution du webhook a réussi :

    2025-01-15T10:30:00Z [INFO] : Webhook - Post OK
    
  • Pour les hôtes Linux :

    sudo journalctl -u falcosidekick -n 50
    

Vérifier les événements dans Google SecOps

  1. Accédez à Google SecOps > Recherche.
  2. Exécutez une requête de recherche :

    metadata.log_type = "FALCO_IDS"
    
  3. Vérifiez que les événements Falco apparaissent dans les résultats de recherche.

  4. Vérifiez que les événements contiennent les champs attendus, par exemple :

    • rule : nom de la règle Falco
    • priority : priorité de l'alerte (Urgence, Alerte, Critique, Erreur, Avertissement, Avis, Information, Débogage)
    • output : message d'alerte lisible par l'humain
    • source : source de l'événement (syscall, k8s_audit)
    • hostname : hôte où l'événement s'est produit
    • container_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.json
    

    Configurez 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 :

    1. Créez un compte de service GCP avec le rôle Administrateur des objets de l'espace de stockage sur le bucket cible.
    2. Téléchargez le fichier de clé JSON du compte de service.
    3. Encodez la clé JSON en base64 :

      cat service-account-key.json | base64 -w 0
      
    4. Configurez 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

  1. Vérifiez que Falco envoie des événements à Falcosidekick :

    kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50 | grep http_output
    
  2. Vérifiez que la configuration de Falco inclut la sortie HTTP :

    kubectl get configmap -n falco falco -o yaml | grep -A 5 http_output
    
  3. Vérifiez que Falcosidekick écoute sur le port 2801 :

    kubectl get svc -n falco falcosidekick
    

Échecs de diffusion du webhook

  1. 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 error
    
  2. Erreurs 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: false pour les tests (non recommandé pour la production).
  3. 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

  1. 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.
  2. 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.
  3. 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.

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.