Collecter les journaux système Linux auditd et AIX

Compatible avec :

Ce document explique comment collecter les journaux d'audit Linux à partir des systèmes auditd et AIX, et les transformer en UDM. L'analyseur gère les messages de journaux au format JSON et en texte brut. Il extrait les champs à l'aide des techniques d'analyse grok, XML et JSON, et les mappe aux champs UDM appropriés en fonction du type d'événement. L'analyseur gère également les formats de journaux d'audit spécifiques des systèmes AIX et enrichit l'UDM avec des champs supplémentaires tels que security_result et des informations intermédiaires.

Il existe deux méthodes principales pour collecter les journaux auditd : à partir du fichier journal local ou à l'aide de syslog. Quelle que soit la méthode, certaines configurations générales sont requises dans auditd.

Avant de commencer

  • Assurez-vous de disposer d'une instance Google Security Operations.
  • Assurez-vous de disposer d'un accès racine à l'hôte Auditd.
  • Assurez-vous de disposer d'un hôte Windows 2012 SP2 ou version ultérieure, ou d'un hôte Linux avec systemd pour l'agent Bindplane.
  • Si vous exécutez le programme derrière un proxy, assurez-vous que les ports du pare-feu sont ouverts.
  • Pour la collecte basée sur syslog, assurez-vous que rsyslog est installé sur l'hôte Auditd.

Obtenir le fichier d'authentification pour l'ingestion Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres SIEM > Agents de collecte.
  3. Téléchargez le fichier d'authentification d'ingestion.

Obtenir votre numéro client Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres SIEM > Profil.
  3. Copiez et enregistrez le numéro client de la section Informations sur l'organisation.

Installer l'agent Bindplane

L'agent Bindplane collecte les journaux de différentes sources et les envoie à Google SecOps. Vous pouvez installer les agents sur site ou dans le cloud. L'agent Bindplane peut également être appelé collecteur Bindplane, agent de collecte, collecteur ou agent. Pour en savoir plus et découvrir d'autres options d'installation, consultez Utiliser Bindplane avec Google SecOps.

  • Pour installer sous Windows, exécutez le script suivant :
    msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet
  • Pour installer sous Linux, exécutez le script suivant :
    sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh

Configuration générale d'AuditD

Pour vous assurer que les journaux auditd contiennent les informations sources nécessaires, telles que le nom d'hôte, procédez comme suit :

  1. Installez les packages requis. Installez le daemon audit et les plug-ins audispd (requis pour le transfert syslog sur de nombreuses distributions).

    • RHEL/CentOS : bash sudo yum install audit audispd-plugins
    • Ubuntu/Debian : bash sudo apt-get install auditd audispd-plugins

  2. Configurez AuditD pour inclure le nom d'hôte. Modifiez le fichier de configuration du démon Audit à l'emplacement /etc/audit/auditd.conf et mettez à jour l'option name_format :

      # Add or update the following line:
  name_format = hostname

  3. Configurez les règles d'audit. Définissez vos règles d'audit dans /etc/audit/rules.d/audit.rules afin qu'elles persistent après un redémarrage. Par exemple, pour auditer les exécutions de processus pour les architectures 32 bits et 64 bits, ajoutez :

    -a always,exit -F arch=b64 -S execve -k execve
-a always,exit -F arch=b32 -S execve -k execve

    Vous pouvez remplacer ces règles par les vôtres.

  4. Redémarrez AuditD. Redémarrez le service pour appliquer les modifications :

    sudo systemctl restart auditd

Méthode de collecte 1 : Ingestion basée sur des fichiers

Cette méthode consiste à utiliser un agent Bindplane local pour lire le fichier journal d'audit brut directement à partir de /var/log/audit/audit.log sur le disque.

Pour configurer l'agent Bindplane pour l'ingestion de fichiers :

  1. Modifiez le fichier config.yaml sur la machine sur laquelle Bindplane est installé pour surveiller le fichier journal AuditD :

    receivers:
  filelog/auditd:
    include: [ "/var/log/audit/audit.log" ]
    start_at: end
    read_batch_size: 65536
    poll_interval: 1s
exporters:
  chronicle/auditd_file:
    compression: gzip
    # Adjust the creds location below according to the placement of the credentials file you downloaded.
    creds: '{ json file for creds }'
    # Replace CUSTOMER_ID with your actual ID that you copied.
    customer_id: CUSTOMER_ID
    endpoint: malachiteingestion-pa.googleapis.com
    # You can apply ingestion labels below as preferred.
    ingestion_labels:
      log_type: AUDITD
      namespace: auditd
      raw_log_field: body
service:
  pipelines:
    logs/auditd_file_to_chronicle:
      receivers:
        - filelog/auditd
      exporters:
        - chronicle/auditd_file

  2. Redémarrez l'agent Bindplane :
    sudo systemctl restart bindplane

Méthode de collecte 2 : Ingestion basée sur Syslog

Cette méthode utilise le répartiteur Audit (audispd) pour envoyer les journaux au démon rsyslog local, qui transmet ensuite les événements. Un agent Bindplane est configuré pour recevoir ces messages Syslog.

Étape 1 : Configurez le plug-in syslog AuditD

Vous devez activer le plug-in syslog pour acheminer les journaux d'audit vers une fonctionnalité syslog. En fonction de votre distribution Linux et de la version d'Audit, modifiez /etc/audisp/plugins.d/syslog.conf (anciens systèmes) ou /etc/audit/plugins.d/syslog.conf (Audit 3.0 et versions ultérieures) :

active = yes
direction = out
path = builtin_syslog
type = builtin
args = LOG_LOCAL6
format = string

Étape 2 : Configurez le transfert rsyslog

Créez un fichier de configuration rsyslog dédié à l'adresse /etc/rsyslog.d/50-auditd.conf (ou mettez à jour un fichier existant comme 50-default.conf) pour rediriger la fonctionnalité LOCAL6.

Option A : Transférer vers un agent Bindplane distant

Si votre agent Bindplane est hébergé à distance, spécifiez son adresse IP (REMOTE_BINDPLANE_IP) et son port d'écoute (par exemple, le port 11655) :

local6.* @@REMOTE_BINDPLANE_IP:11655

Option B : Transférer vers un écouteur local

Si vous exécutez un agent de collecte local qui écoute le trafic syslog sur un port spécifique du même hôte, spécifiez LOCAL_LISTENER_PORT :

local6.* @@127.0.0.1:LOCAL_LISTENER_PORT

Étape 3 : Configurez l'agent Bindplane pour l'ingestion syslog

Modifiez le fichier config.yaml sur la machine sur laquelle Bindplane est installé pour écouter les messages syslog. Cette configuration suppose que vous utilisez le protocole TCP sur le port 11655, comme dans les exemples de l'étape 2.

receivers:
    tcplog:
    listen_address: "0.0.0.0:11655"

exporters:
    chronicle/auditd_syslog:
    compression: gzip
    # Adjust the creds location below according to the placement of the credentials file you downloaded.
    creds: '{ json file for creds }'
    # Replace CUSTOMER_ID below with your actual ID that you copied.
    customer_id: CUSTOMER_ID
    endpoint: malachiteingestion-pa.googleapis.com
    # You can apply ingestion labels below as preferred.
    ingestion_labels:
        log_type: SYSLOG
        namespace: auditd
        raw_log_field: body
service:
    pipelines:
    logs/auditd_syslog_to_chronicle:
        receivers:
        - tcplog
        exporters:
        - chronicle/auditd_syslog

Étape 4 : Redémarrez les services nécessaires

Redémarrez les services suivants pour que le routage syslog et la configuration Bindplane prennent effet :

sudo systemctl restart auditd
sudo systemctl restart rsyslog
sudo systemctl restart bindplane

Vous pouvez utiliser un outil tel que tail pour surveiller le syslog et vérifier que les journaux Auditd sont envoyés :

tail -f /var/log/syslog | grep auditd 
# Follow syslog and filter for auditd messages (the path may vary depending on your system).

Exemples de journaux du système d'audit Linux (AuditD) compatibles

  • SYSLOG + KV (Linux AuditD)

    events_for_log_entry:  {
events:  {
  timestamp:  {
    seconds:  1718778607
    nanos:  898000000
  }
  idm:  {
    read_only_udm:  {
      metadata:  {
        product_log_id:  "5512409"
        event_timestamp:  {
          seconds:  1718778607
          nanos:  898000000
        }
        event_type:  USER_LOGIN
        vendor_name:  "Linux"
        product_name:  "AuditD"
        product_event_type:  "USER_AUTH"
      }
      principal:  {
        hostname:  "sec-dev-01.internal"
        user:  {
          userid:  "0"
          user_display_name:  "secuser"
        }
        process:  {
          pid:  "3306219"
        }
        asset:  {
          hostname:  "sec-dev-01.internal"
          ip:  "192.168.1.5"
        }
        ip:  "192.168.1.5"
        application:  "ssh"
        platform:  LINUX
      }
      target:  {
        user:  {
          userid:  "0"
          user_display_name:  "secuser"
        }
        process:  {
          file:  {
            full_path:  "/usr/sbin/secure_shell"
          }
        }
      }
      intermediary:  {
        hostname:  "sec-dev-01.internal"
      }
      about:  {
        user:  {
          userid:  "sysadmin"
          user_display_name:  "unset"
        }
      }
      security_result:  {
        detection_fields:  {
          key:  "AUID0"
          value:  "unset"
        }
        detection_fields:  {
          key:  "UID0"
          value:  "sysadmin"
        }
        detection_fields:  {
          key:  "acct0"
          value:  "secuser"
        }
        detection_fields:  {
          key:  "addr0"
          value:  "192.168.1.5"
        }
        detection_fields:  {
          key:  "auid0"
          value:  "sysadmin"
        }
        detection_fields:  {
          key:  "exe0"
          value:  "/usr/sbin/secure_shell"
        }
        detection_fields:  {
          key:  "grantors0"
          value:  "pam_unix"
        }
        detection_fields:  {
          key:  "hostname0"
          value:  "192.168.1.5"
        }
        detection_fields:  {
          key:  "msg0"
          value:  "op=PAM:authentication"
        }
        detection_fields:  {
          key:  "pid0"
          value:  "3306219"
        }
        detection_fields:  {
          key:  "res0"
          value:  "success"
        }
        detection_fields:  {
          key:  "ses0"
          value:  "4294967295"
        }
        detection_fields:  {
          key:  "terminal0"
          value:  "ssh"
        }
        detection_fields:  {
          key:  "uid0"
          value:  "0"
        }
        detection_fields:  {
          key:  "AUID_kv0"
          value:  "AUID0:unset"
        }
        detection_fields:  {
          key:  "UID_kv0"
          value:  "UID0:sysadmin"
        }
        detection_fields:  {
          key:  "acct_kv0"
          value:  "acct0:secuser"
        }
        detection_fields:  {
          key:  "addr_kv0"
          value:  "addr0:192.168.1.5"
        }
        detection_fields:  {
          key:  "auid_kv0"
          value:  "auid0:sysadmin"
        }
        detection_fields:  {
          key:  "exe_kv0"
          value:  "exe0:/usr/sbin/secure_shell"
        }
        detection_fields:  {
          key:  "grantors_kv0"
          value:  "grantors0:pam_unix"
        }
        detection_fields:  {
          key:  "hostname_kv0"
          value:  "hostname0:192.168.1.5"
        }
        detection_fields:  {
          key:  "msg_kv0"
          value:  "msg0:op=PAM:authentication"
        }
        detection_fields:  {
          key:  "pid_kv0"
          value:  "pid0:3306219"
        }
        detection_fields:  {
          key:  "res_kv0"
          value:  "res0:success"
        }
        detection_fields:  {
          key:  "ses_kv0"
          value:  "ses0:4294967295"
        }
        detection_fields:  {
          key:  "terminal_kv0"
          value:  "terminal0:ssh"
        }
        detection_fields:  {
          key:  "uid_kv0"
          value:  "uid0:0"
        }
        summary:  "authentication secuser"
        action:  ALLOW
        action_details:  "success"
      }
      network:  {
        session_id:  "4294967295"
        application_protocol:  SSH
      }
      extensions:  {
        auth:  {}
      }
    }
  }
}
}

  • SYSLOG (générique)

    events_for_log_entry:  {
events:  {
  timestamp:  {
    seconds:  1754848621
  }
  idm:  {
    read_only_udm:  {
      metadata:  {
        event_timestamp:  {
          seconds:  1754848621
        }
        event_type:  PROCESS_LAUNCH
        vendor_name:  "Linux"
        product_name:  "AuditD"
        product_event_type:  "CROND"
        description:  "(monitorsvc) CMD (/opt/monitor/bin/scheduler -j /opt/monitor/cache/jobs/check.jx)"
      }
      principal:  {
        hostname:  "log-host-05"
        user:  {
          userid:  "monitorsvc"
        }
        process:  {
          pid:  "124662"
        }
        asset:  {
          hostname:  "log-host-05"
        }
        platform:  LINUX
      }
      target:  {
        process:  {
          command_line:  "/opt/monitor/bin/scheduler -j /opt/monitor/cache/jobs/check.jx"
        }
      }
      intermediary:  {
        hostname:  "log-host-05"
      }
    }
  }
}
}

  • JSON (journalisation Cloud Storage ou Auditbeat)

    events_for_log_entry:  {
events:  {
  timestamp:  {
    seconds:  1611615589
    nanos:  212000000
  }
  idm:  {
    read_only_udm:  {
      metadata:  {
        product_log_id:  "32946"
        event_timestamp:  {
          seconds:  1611615589
          nanos:  212000000
        }
        collected_timestamp:  {
          seconds:  1609752843
          nanos:  349722230
        }
        event_type:  SERVICE_START
        vendor_name:  "Linux"
        product_name:  "AuditD"
        product_event_type:  "SERVICE_START"
      }
      additional:  {
        fields:  {
          key:  "insertId"
          value:  {
            string_value:  "tf9cuofcnbn6i"
          }
        }
        fields:  {
          key:  "logName"
          value:  {
            string_value:  "projects/prj-secops-dev/logs/auditd"
          }
        }
      }
      principal:  {
        hostname:  "gce-test-web"
        user:  {
          userid:  "0"
        }
        process:  {
          pid:  "1"
        }
        asset:  {
          hostname:  "gce-test-web"
        }
        application:  "sysmgr"
        platform:  LINUX
      }
      target:  {
        process:  {
          file:  {
            full_path:  "/usr/bin/sysmgr"
          }
        }
        cloud:  {
          project:  {
            name:  "prj-secops-dev"
          }
        }
        resource:  {
          resource_subtype:  "gce_instance"
          product_object_id:  "1000000000000000001"
          attribute:  {
            cloud:  {
              availability_zone:  "us-east4-a"
            }
          }
        }
      }
      about:  {
        user:  {
          userid:  "9001"
          user_display_name:  "unset"
        }
      }
      security_result:  {
        detection_fields:  {
          key:  "AUID0"
          value:  "unset"
        }
        detection_fields:  {
          key:  "UID0"
          value:  "secsvc"
        }
        detection_fields:  {
          key:  "auid0"
          value:  "9001"
        }
        detection_fields:  {
          key:  "comm0"
          value:  "sysmgr"
        }
        detection_fields:  {
          key:  "exe0"
          value:  "/usr/bin/sysmgr"
        }
        detection_fields:  {
          key:  "msg0"
          value:  "unit=gce-cert-renew"
        }
        detection_fields:  {
          key:  "pid0"
          value:  "1"
        }
        detection_fields:  {
          key:  "res0"
          value:  "success"
        }
        detection_fields:  {
          key:  "ses0"
          value:  "4294967295"
        }
        detection_fields:  {
          key:  "subj0"
          value:  "system_u:system_r:init_t:s0"
        }
        detection_fields:  {
          key:  "uid0"
          value:  "0"
        }
        detection_fields:  {
          key:  "AUID_kv0"
          value:  "AUID0:unset"
        }
        detection_fields:  {
          key:  "UID_kv0"
          value:  "UID0:secsvc"
        }
        detection_fields:  {
          key:  "auid_kv0"
          value:  "auid0:9001"
        }
        detection_fields:  {
          key:  "comm_kv0"
          value:  "comm0:sysmgr"
        }
        detection_fields:  {
          key:  "exe_kv0"
          value:  "exe0:/usr/bin/sysmgr"
        }
        detection_fields:  {
          key:  "msg_kv0"
          value:  "msg0:unit=gce-cert-renew"
        }
        detection_fields:  {
          key:  "pid_kv0"
          value:  "pid0:1"
        }
        detection_fields:  {
          key:  "res_kv0"
          value:  "res0:success"
        }
        detection_fields:  {
          key:  "ses_kv0"
          value:  "ses0:4294967295"
        }
        detection_fields:  {
          key:  "subj_kv0"
          value:  "subj0:system_u:system_r:init_t:s0"
        }
        detection_fields:  {
          key:  "uid_kv0"
          value:  "uid0:0"
        }
        summary:  "unit=gce-cert-renew success"
        action:  ALLOW
        action_details:  "success"
      }
      network:  {
        session_id:  "4294967295"
      }
    }
  }
}
}

  • JSON (événement Windows)

    JSON (Windows Event)
events_for_log_entry:  {
events:  {
  timestamp:  {
    seconds:  1711012395
    nanos:  723000000
  }
  idm:  {
    read_only_udm:  {
      metadata:  {
        event_timestamp:  {
          seconds:  1711012395
          nanos:  723000000
        }
        event_type:  USER_LOGIN
        vendor_name:  "Microsoft"
        product_name:  "Microsoft-Windows-Security-Auditing"
        product_event_type:  "4624"
        description:  "An account was successfully logged on"
      }
      additional:  {
        fields:  {
          key:  "Message"
          value:  {
            string_value:  "An account was successfully logged on."
                           "Subject:Security ID:S-1-0-0"
                           "Account Name:-... (omitted for brevity) ..."
                           "New Logon:Security ID:S-1-5-21-1234567890-123456789-1234567890-2001"
                           "Account Name:svc_log_collector"
                           "Account Domain:SEC_LAB... (omitted for brevity) ..."
                           "Network Information:"
                           "Workstation Name:DEV-WS-42"
                           "Source Network Address:172.16.1.100"
                           "Source Port:53856..."
          }
        }
        fields:  {
          key:  "Workstation Name"
          value:  {
            string_value:  "DEV-WS-42"
          }
        }
      }
      principal:  {
        hostname:  "DEV-WS-42"
        process:  {}
        asset:  {
          hostname:  "DEV-WS-42"
          ip:  "172.16.1.100"
        }
        ip:  "172.16.1.100"
        port:  53856
        labels:  {
          key:  "Workstation Name"
          value:  "DEV-WS-42"
        }
      }
      target:  {
        user:  {
          userid:  "svc_log_collector"
          windows_sid:  "S-1-5-21-1234567890-123456789-1234567890-2001"
        }
        administrative_domain:  "SEC_LAB"
      }
      intermediary:  {
        hostname:  "win-server-01"
      }
      security_result:  {
        rule_name:  "EventID: 4624"
        action:  ALLOW
      }
      extensions:  {
        auth:  {
          mechanism:  MECHANISM_UNSPECIFIED
        }
      }
    }
  }
}
}

  • SYSLOG + XML (Solaris AuditD)

    {
  "events_for_log_entry": {
    "events": {
      "timestamp": {
        "seconds": 1735824379
      },
      "idm": {
        "read_only_udm": {
          "metadata": {
            "product_log_id": "1638473100678580410",
            "event_timestamp": {
              "seconds": 1735824379
            },
            "event_type": "PROCESS_LAUNCH",
            "vendor_name": "Linux",
            "product_name": "AuditD",
            "product_version": "2",
            "product_event_type": "AUE_EXECVE",
            "description": "<record version=\"2\" event=\"23\" host=\"192.0.2.1\" iso8601=\"1638473100678580410\">\n"
                           "  <ntrs hostname=\"sanitized-host-01\" eventstring=\"AUE_EXECVE\" timestamp=\"1638473100.678580410\" ppid=\"2853\"></ntrs>\n"
                           "  <path>/usr/bin/find</path>\n"
                           "  <attribute mode=\"100555\" uid=\"0\" gid=\"2\" fsid=\"256\" nodeid=\"722\" device=\"18446744073709551615\"/>\n"
                           "  <exec_args>\n"
                           "    <arg>find</arg>\n"
                           "    <arg>/var/log/secure</arg>\n"
                           "    <arg>-type</arg>\n"
                           "    <arg>f</arg>\n"
                           "    <arg>-xdev</arg>\n"
                           "    <arg>-prune</arg>\n"
                           "    <arg>-name</arg>\n"
                           "    <arg>secure_data_file.txt</arg>\n"
                           "    <arg>-mtime</arg>\n"
                           "    <arg>+3</arg>\n"
                           "    <arg>-exec</arg>\n"
                           "    <arg>rm</arg>\n"
                           "    <arg>-f</arg>\n"
                           "    <arg>{}</arg>\n"
                           "    <arg>;</arg>\n"
                           "  </exec_args>\n"
                           "  <path>/lib/ld.so.1</path>\n"
                           "  <attribute mode=\"100755\" uid=\"0\" gid=\"2\" fsid=\"256\" nodeid=\"449952\" device=\"18446744073709551615\"/>\n"
                           "  <subject audit-uid=\"99999\" uid=\"0\" gid=\"0\" ruid=\"0\" rgid=\"0\" pid=\"2871\" sid=\"1898719819\" tid=\"9307 196630 192.0.2.10\"/>\n"
                           "  <return errval=\"0\" retval=\"0\"/>\n"
                           "  <sequence seq-num=\"6849431\"/>\n"
                           "</record>"
          },
          "principal": {
            "hostname": "sanitized-host-01",
            "user": {
              "userid": "99999"
            },
            "asset": {
              "hostname": "sanitized-host-01",
              "ip": "192.0.2.1"
            },
            "ip": "192.0.2.1",
            "platform": "LINUX"
          },
          "target": {
            "process": {
              "parent_process": {
                "pid": "2853"
              },
              "command_line": "find /var/log/secure -type f -xdev -prune -name secure_data_file.txt -mtime +3 -exec rm -f {} ;"
            }
          },
          "intermediary": {
            "hostname": "internal-proxy.local"
          },
          "security_result": {
            "detection_fields": [
              { "key": "event", "value": "event: 23" },
              { "key": "uid", "value": "uid: 0" },
              { "key": "gid", "value": "gid: 0" },
              { "key": "ruid", "value": "ruid: 0" },
              { "key": "rgid", "value": "rgid: 0" },
              { "key": "pid", "value": "pid: 2871" },
              { "key": "sid", "value": "sid: 1898719819" },
              { "key": "tid", "value": "tid: 9307 196630 192.0.2.10" },
              { "key": "seq_num", "value": "seq_num: 6849431" },
              { "key": "errval", "value": "errval: 0" },
              { "key": "retval", "value": "retval: 0" },
              { "key": "path", "value": "path: /usr/bin/find" },
              { "key": "device", "value": "device: 18446744073709551615" },
              { "key": "mode", "value": "mode: 100555" },
              { "key": "fsid", "value": "fsid: 256" },
              { "key": "nodeid", "value": "nodeid: 722" }
            ]
          }
        }
      }
    }
  }
}

Table de mappage UDM

Champ du journal Mappage UDM Remarque
acct target.user.user_display_name La valeur de acct du journal brut est mappée sur le champ target.user.user_display_name de l'UDM. Il s'agit du compte associé à l'événement.
addr principal.ip La valeur de addr du journal brut est mappée sur le champ principal.ip de l'UDM. Il s'agit de l'adresse IP du compte principal impliqué dans l'événement.
additional.fields additional.fields Les champs supplémentaires issus des paires clé-valeur ou des libellés analysés sont ajoutés au tableau additional.fields dans l'UDM.
agent.googleapis.com/log_file_path (Non mappé) Ce libellé est présent dans certains journaux bruts, mais n'est pas associé à l'objet IDM dans l'UDM.
algo (Non utilisé dans cet exemple) Bien que présent dans l'analyseur et certains journaux bruts, ce champ n'est pas utilisé dans l'exemple fourni et n'apparaît pas dans l'UDM final.
application principal.application Dérivé du champ terminal dans le journal brut ou d'autres champs tels que exe, selon le type de journal. Représente l'application concernée.
arch security_result.about.platform_version L'architecture du champ arch du journal brut est mappée sur security_result.about.platform_version.
auid about.user.userid, security_result.detection_fields.auid L'ID utilisateur de l'audit (auid) est mappé à about.user.userid et ajouté en tant que champ de détection dans security_result.
cmd target.process.command_line La commande du champ cmd du journal brut est mappée sur target.process.command_line.
collection_time (Non mappé) Ce champ correspond à l'heure de collecte des journaux et n'est pas mappé à l'objet IDM dans l'UDM.
comm principal.application Le nom de la commande (comm) est mappé sur principal.application.
COMMAND target.process.command_line
compute.googleapis.com/resource_name principal.hostname Le nom de ressource de ce libellé est mappé sur principal.hostname.
create_time (Non mappé) Ce champ n'est pas mappé à l'objet IDM dans l'UDM.
cwd security_result.detection_fields.cwd Le répertoire de travail actuel (cwd) est ajouté en tant que champ de détection dans security_result.
data (Traitée) Le champ data contient le message de journal principal et est traité par l'analyseur pour extraire différents champs. Il n'est pas directement mappé à un seul champ UDM.
exe target.process.file.full_path Le chemin d'accès exécutable (exe) est mappé sur target.process.file.full_path.
extensions.auth.type extensions.auth.type Le type d'authentification est défini par la logique de l'analyseur en fonction du type d'événement. Souvent défini sur MACHINE ou AUTHTYPE_UNSPECIFIED.
fp network.tls.client.certificate.sha256 L'empreinte (fp) est analysée pour extraire le hachage SHA256 et est mappée sur network.tls.client.certificate.sha256.
_Item_Id metadata.product_log_id
insertId (Non mappé) Ce champ n'est pas mappé à l'objet IDM dans l'UDM.
jsonPayload.message (Traitée) Ce champ contient le message de journal principal au format JSON et est traité par l'analyseur.
key security_result.about.registry.registry_key Le champ clé est mappé sur security_result.about.registry.registry_key.
labels (Traitée) Les libellés du journal brut sont traités et mappés à différents champs UDM ou ajoutés à additional.fields.
logName (Non mappé) Ce champ n'est pas mappé à l'objet IDM dans l'UDM.
metadata.product_event_type SECCOMP La courbe d'échange de clés est extraite du journal brut et mappée à ce champ.
msg security_result.summary Le message (msg) est souvent utilisé pour remplir le champ security_result.summary.
network.application_protocol network.application_protocol Défini par la logique de l'analyseur en fonction du type d'événement (par exemple, SSH ou HTTP).
network.direction network.direction Défini par la logique du parseur en fonction du type d'événement (par exemple, INBOUND, OUTBOUND).
network.ip_protocol network.ip_protocol Défini par la logique du parseur, généralement sur TCP pour les événements SSH.
network.session_id network.session_id Mappé à partir du champ ses ou dérivé d'autres champs.
network.tls.cipher network.tls.cipher Les informations sur le chiffrement sont extraites du journal brut et mappées à ce champ.
network.tls.curve network.tls.curve La courbe d'échange de clés est extraite du journal brut et mappée à ce champ.
pid principal.process.pid, target.process.pid L'ID de processus (pid) est mappé sur principal.process.pid ou target.process.pid selon le contexte.
ppid principal.process.parent_process.pid, target.process.parent_process.pid L'ID du processus parent (ppid) est mappé sur principal.process.parent_process.pid ou target.process.parent_process.pid selon le contexte.
principal.asset.hostname principal.asset.hostname Copié depuis principal.hostname.
principal.asset.ip principal.asset.ip Copié depuis principal.ip.
principal.platform principal.platform Défini par la logique de l'analyseur en fonction du système d'exploitation (par exemple, LINUX).
principal.port principal.port Numéro de port associé au principal.
principal.user.group_identifiers principal.user.group_identifiers ID de groupe associés à l'utilisateur principal.
process.name target.process.file.full_path
receiveTimestamp (Non mappé) Ce champ correspond au code temporel de réception du journal et n'est pas mappé à l'objet IDM dans l'UDM.
res security_result.action_details Le résultat (res) est mappé sur security_result.action_details.
_Resource_Id target.resource.product_object_id
resource.labels (Non mappé) Ces libellés sont présents dans certains journaux bruts, mais ne sont pas mappés à l'objet IDM dans l'UDM.
resource.type (Non mappé) Ce champ est présent dans certains journaux bruts, mais n'est pas mappé à l'objet IDM dans l'UDM.
security_result.action security_result.action Défini par la logique de l'analyseur en fonction du champ res (par exemple, "ALLOW" ou "BLOCK").
security_result.detection_fields security_result.detection_fields Divers champs du journal brut sont ajoutés à ce tableau sous forme de paires clé-valeur pour le contexte.
security_result.rule_id security_result.rule_id Défini par la logique du parseur, souvent sur type_name pour les événements syscall.
security_result.severity security_result.severity Défini par la logique du parseur en fonction du niveau de gravité dans le journal brut.
security_result.summary security_result.summary Résumé de l'événement, souvent dérivé du champ msg ou d'autres champs pertinents.
ses network.session_id L'ID de session (ses) est mappé sur network.session_id.
source (Non mappé) Ce champ contient des métadonnées sur la source du journal et n'est pas mappé à l'objet IDM dans l'UDM.
subj (Traitée) Le champ "Objet" (subj) est traité pour extraire les informations sur le contexte utilisateur et de sécurité.
syscall security_result.about.labels.Syscall Le numéro de syscall est ajouté en tant que libellé dans security_result.about.
target.administrative_domain target.administrative_domain Domaine de l'utilisateur cible.
target.group.group_display_name target.group.group_display_name Nom du groupe cible.
target.ip target.ip Adresse IP de la cible.
target.port target.port Numéro de port associé à la cible.
target.process.command_line target.process.command_line Ligne de commande du processus cible.
target.resource.type target.resource.type Type de la ressource cible, défini par la logique du parser (par exemple, CREDENTIAL ou SETTING).
target.user.attribute.permissions target.user.attribute.permissions Autorisations associées à l'utilisateur cible.
target.user.group_identifiers target.user.group_identifiers ID de groupe associés à l'utilisateur cible.
target.user.userid target.user.userid ID utilisateur de la cible.
TenantId metadata.product_deployment_id
textPayload (Traitée) Charge utile textuelle du journal, traitée par l'analyseur pour extraire différents champs.
timestamp metadata.event_timestamp Horodatage de l'événement.
tty security_result.about.labels.tty Le TTY est ajouté en tant que libellé dans security_result.about.
type metadata.product_event_type Le type d'événement (type) est mappé sur metadata.product_event_type.
uid target.user.userid L'ID utilisateur (uid) est mappé sur target.user.userid.

Référence du delta de mappage UDM

Le 23 septembre 2025, Google SecOps a publié une nouvelle version de l'analyseur Okta, qui inclut des modifications importantes concernant le mappage des champs de journaux Okta vers les champs UDM et le mappage des types d'événements.

Delta de mappage entre les champs de journaux

Le tableau suivant répertorie le delta de mappage pour les champs de journaux Okta vers UDM exposés avant le 23 septembre 2025 et après (listés respectivement dans les colonnes Ancien mappage et Mappage actuel).

Champ du journal Ancienne correspondance Mappage actuel Exemple de journal de référence
1.1.1.1 (adresse IP) src.ip principal.ip "<163>Apr 10 09:00:05 hostname.com sshd[3318513]: Accepted password for abc from 1.1.1.1 port 33988 ssh2"
1.1.1.1 (adresse IP) principal.ip target.ip "<29>Oct 5 08:37:16 abc ProxySG: E0000 Access Log HTTP (main): Connecting to server 1.1.1.1 on port 4433.(0) NORMAL_EVENT alog_stream_http.cpp 261"
abc (utilisateur) principal.user.userid target.user.userid "<85>Feb 27 08:26:55 offozcav login: FAILED LOGIN 1 FROM ::ffff:1.1.1.1 FOR abc, Authentication failure\r\n\r\n"
abc.abc (utilisateur) principal.user.userid target.user.userid "<86>Feb 27 08:29:19 offozcav login: LOGIN ON pts/43 BY abc.abc FROM\r\n\r\n::ffff:1.1.1.1"
COMMAND principal.process.command_line target.process.command_line "<85>Sep 24 14:33:59 abc sudo: abc : \r\nTTY=unknown ; PWD=/abc ; USER=abc ; COMMAND=/sbin/iptables -t nat -nL \r\n--line-number"
exe target.process.file.full_path principal.process.file.full_path
_ItemId additional.fields metadata.product_log_id
metadata.product_event_type PATH SECCOMP
process.name principal.process.file.full_path target.process.file.full_path
_ResourceId additional.fields target.resource.product_object_id
TenantId additional.fields metadata.product_deployment_id
uid principal.user.userid target.user.userid
USER principal.user.user_display_name target.user.userid "<85>Sep 24 14:33:59 abc sudo: abc : \r\nTTY=unknown ; PWD=/abc ; USER=abc ; COMMAND=/sbin/iptables -t nat -nL \r\n--line-number"
user principal.user.userid target.user.userid "29>Jan 16 11:28:00 san-auth-1-irl2 tac_plus[17329]: login failure: user 1.1.1.1 (1.1.1.1) vty0"
user principal.user.userid target.user.userid "<87>15 juil. 10:27:01 xpgjrconfdb01 crond[1045]: pam_unix(crond:account): mot de passe expiré pour l'utilisateur root (mot de passe ancien)"

Delta de mappage des types d'événements

Plusieurs événements qui étaient auparavant classés comme événements génériques sont désormais correctement classés avec des types d'événements pertinents.

Le tableau suivant liste le delta pour la gestion des types d'événements Okta avant le 23 septembre 2025 et après (listés respectivement dans les colonnes Ancien event_type et event_type actuel).

eventType from log Ancien event_type Current event_type
aix_event_type=CRON_Start USER_LOGIN PROCESS_LAUNCH
CRYPTO_KEY_USER NETWORK_CONNECTION USER_LOGIN
FILE_Mknod USER_LOGIN FILE_CREATION
FILE_Rename USER_LOGIN FILE_MODIFICATION
FILE_Stat USER_LOGIN FILE_OPEN
FILE_Unlink USER_LOGIN FILE_DELETION
FS_Chabc USER_LOGIN PROCESS_UNCATEGORIZED
FS_Mkdir USER_LOGIN FILE_CREATION
FS_Rmdir USER_LOGIN FILE_DELETION
PROC_Execute USER_LOGIN PROCESS_LAUNCH
type=ANOM_ABEND STATUS_UPDATE PROCESS_TERMINATION
type=ANOM_PROMISCUOUS SETTING_MODIFICATION
type=CRED_REFR USER_LOGIN USER_CHANGE_PERMISSIONS
type=PROCTILE PROCESS_UNCATEGORIZED PROCESS_LAUNCH
type=SERVICE_START USER_RESOURCE_ACCESS SERVICE_START
type=SERVICE_STOP USER_RESOURCE_ACCESS SERVICE_STOP
type=USER_ACCT USER_LOGIN/SETTING_MODIFICTION USER_LOGIN
type=USER_MGMT SETTING_MODIFICATION/GROUP_MODIFICATION GROUP_MODIFICATION
USER_ERR USER_LOGOUT USER_LOGIN

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.