Collecter les journaux SFTP VanDyke VShell

Compatible avec :

Ce document explique comment ingérer des journaux SFTP VanDyke VShell dans Google Security Operations à l'aide de Bindplane avec Syslog ou d'Amazon S3 avec un expéditeur de journaux.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Accès privilégié au serveur ou à la console de gestion VanDyke VShell
  • Pour l'option 1 : un hôte Windows 2016 ou version ultérieure, ou Linux, avec systemd pour l'agent BindPlane
  • Pour l'option 2 : compte AWS avec accès S3 et NXLog/Fluent Bit sur le serveur VShell

Obtenir des identifiants Google SecOps pour l'agent BindPlane

Pour authentifier l'agent Bindplane auprès de Google SecOps, choisissez l'une des méthodes suivantes :

  • Nouveaux déploiements : utilisez l'API Chronicle (option 1).
  • Anciens déploiements : continuez à utiliser le fichier d'authentification d'ingestion (option 2) jusqu'à l'arrêt de l'API Ingestion le 20 juillet 2027.
  1. Connectez-vous à la consoleGoogle Cloud et sélectionnez le projet Google Cloud associé à votre instance Google SecOps.
  2. Accédez à IAM et administration > Comptes de service.
  3. Cliquez sur Créer un compte de service.
  4. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez un nom pour le compte (par exemple, bindplane-ingest).
    • Description du compte de service : saisissez une description (par exemple, Bindplane agent log ingestion).
  5. Cliquez sur Créer et continuer.
  6. Dans la section Autoriser ce compte de service à accéder au projet, cliquez sur Sélectionner un rôle, puis sélectionnez Éditeur Chronicle.
  7. Cliquez sur Continue (Continuer), puis sur Done (OK).
  8. Cliquez sur le compte de service que vous avez créé, puis accédez à l'onglet Clés.
  9. Cliquez sur Ajouter une clé > Créer une clé.
  10. Sélectionnez JSON, puis cliquez sur Créer. Le fichier de clé est téléchargé sur votre ordinateur.
  11. Enregistrez le fichier de clé sous le nom ingestion-auth.json dans le répertoire du collecteur Bindplane (/opt/observiq-otel-collector/ingestion-auth.json sous Linux ou C:\Program Files\observIQ OpenTelemetry Collector\ingestion-auth.json sous Windows), ou mettez à jour creds_file_path dans config.yaml pour qu'il corresponde au chemin d'accès où vous l'enregistrez.
  12. Accédez à IAM et administration > Paramètres, puis copiez le numéro du projet. Vous en aurez besoin pour configurer l'exportateur.

Option 2 : Télécharger le fichier d'authentification d'ingestion (ancien)

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres > Gestion des données > Agents de collecte. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Agents de collecte.
  3. Téléchargez le fichier d'authentification d'ingestion.
  4. Enregistrez le fichier de manière sécurisée sur le système où l'agent BindPlane sera installé.

Obtenir le numéro client Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres > Administration > Profil. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Profil.
  3. Copiez et enregistrez le numéro client de la section Détails de l'organisation.

Option 1 : Intégration via Bindplane et Syslog

Cette option permet de diffuser les journaux en temps réel avec une latence minimale. Elle est recommandée pour la plupart des déploiements.

Installer l'agent BindPlane

Installez l'agent BindPlane sur votre système d'exploitation Windows ou Linux en suivant les instructions ci-dessous.

Installation de Windows

  1. Ouvrez l'invite de commande ou PowerShell en tant qu'administrateur.
  2. Exécutez la commande suivante :

    msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet
    

Installation sous Linux

  1. Ouvrez un terminal avec des droits d'accès racine ou sudo.
  2. Exécutez la commande suivante :

    sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh
    

Ressources d'installation supplémentaires

Pour connaître les autres options d'installation, consultez le guide d'installation de l'agent BindPlane.

Configurer l'agent BindPlane pour ingérer Syslog et l'envoyer à Google SecOps

  1. Accédez au fichier de configuration :

    • Trouvez le fichier config.yaml. En général, il se trouve dans le répertoire /opt/observiq-otel-collector/ sous Linux ou dans le répertoire d'installation sous Windows.
    • Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou Notepad).
  2. Modifiez le fichier config.yaml comme suit :

    receivers:
      udplog:
        # Replace the port and IP address as required
        listen_address: "0.0.0.0:514"
    
    exporters:
      chronicle/chronicle_w_labels:
        protocol: https
        # Region of your instance, for example us, europe, asia-southeast1
        location: <LOCATION>
        # Project number of the Google Cloud project linked to the instance
        project: '<PROJECT_NUMBER>'
        compression: gzip
        # Adjust the path to the credentials file you downloaded in Step 1
        creds_file_path: '/path/to/ingestion-authentication-file.json'
        # Replace with your actual customer ID from Step 2
        customer_id: YOUR_CUSTOMER_ID
        endpoint: chronicle.googleapis.com
        # Custom log type - requires parser extension
        log_type: 'VANDYKE_SFTP'
        raw_log_field: body
        ingestion_labels:
    
    service:
      pipelines:
        logs/source0__chronicle_w_labels-0:
          receivers:
            - udplog
          exporters:
            - chronicle/chronicle_w_labels
    
    • Remplacez le port et l'adresse IP selon les besoins de votre infrastructure.
    • Remplacez <LOCATION> par la région de votre instance Google SecOps (par exemple, us, europe ou asia-southeast1). L'exportateur ajoute cette valeur en préfixe à chronicle.googleapis.com.
    • Remplacez <PROJECT_NUMBER> par le numéro de projet indiqué dans IAM et administration > Paramètres.
    • Remplacez YOUR_CUSTOMER_ID par le numéro client réel.
    • Remplacez /path/to/ingestion-authentication-file.json par le chemin d'accès au fichier de clé du compte de service (option 1).
    • Pour utiliser TCP au lieu d'UDP, remplacez udplog par tcplog.

Ancien exportateur d'API d'ingestion

  • Si vous utilisez le fichier d'authentification d'ingestion de l'option 2, remplacez le bloc exporters par le code suivant. Définissez creds_file_path sur le chemin d'accès au fichier d'authentification d'ingestion. Si votre instance se trouve en dehors des États-Unis, remplacez malachiteingestion-pa.googleapis.com par votre point de terminaison régional (par exemple, europe-malachiteingestion-pa.googleapis.com).

    exporters:
      chronicle/chronicle_w_labels:
        compression: gzip
        # Adjust the path to the credentials file you downloaded in Step 1
        creds_file_path: '/path/to/ingestion-authentication-file.json'
        # Replace with your actual customer ID from Step 2
        customer_id: YOUR_CUSTOMER_ID
        endpoint: malachiteingestion-pa.googleapis.com
        # Custom log type - requires parser extension
        log_type: 'VANDYKE_SFTP'
        raw_log_field: body
        ingestion_labels:
    

Redémarrez l'agent BindPlane pour appliquer les modifications.

  • Pour redémarrer l'agent BindPlane sous Linux, exécutez la commande suivante :

    sudo systemctl restart observiq-otel-collector
    
  • Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :

    net stop observiq-otel-collector && net start observiq-otel-collector
    

Configurer le transfert Syslog sur VanDyke VShell

Pour VShell sous Windows

  1. Connectez-vous au panneau de configuration VShell.
  2. Accédez aux paramètres de journalisation.
  3. Configurez la journalisation syslog à distance :
    • Activez la journalisation sur un serveur syslog distant.
    • Adresse du serveur : saisissez l'adresse IP de Bindplane.
    • Port : saisissez 514 (ou le port que vous avez configuré).
    • Protocole : sélectionnez UDP (ou TCP si configuré).
    • Groupes de messages : sélectionnez Connexion, Authentification, SFTP, FTPS, HTTPS, Erreurs, Avertissements et Informations.
  4. Cliquez sur Appliquer > OK.

Pour VShell sous Linux/macOS

  1. Modifiez le fichier vshelld_config (généralement /etc/vshell/vshelld_config).
  2. Configurez les paramètres suivants :

    SyslogFacility LOG_LOCAL3
    LogLevel INFO
    
  3. Configurez le syslog de votre système pour transférer LOG_LOCAL3 à l'agent Bindplane :

    • Modifiez /etc/rsyslog.conf ou /etc/syslog-ng/syslog-ng.conf.
    • Ajoutez local3.* @bindplane-agent-ip:514 (pour UDP) ou local3.* @@bindplane-agent-ip:514 (pour TCP).
  4. Redémarrez les services VShell et syslog :

    sudo systemctl restart vshelld
    sudo systemctl restart rsyslog
    

Option 2 : Intégration via AWS S3

Cette option est utile pour les environnements qui nécessitent l'archivage des journaux ou dans lesquels le transfert direct de syslog n'est pas possible. Notez que cela nécessite un expéditeur de journaux sur le serveur VShell, car AWS Lambda ne peut pas accéder aux fichiers sur site.

Configurer un bucket AWS S3 et IAM pour Google SecOps

  1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
  2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, vandyke-sftp-logs).
  3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
  4. Sélectionnez l'utilisateur créé.
  5. Sélectionnez l'onglet Security credentials (Identifiants de sécurité).
  6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
  7. Sélectionnez Service tiers comme Cas d'utilisation.
  8. Cliquez sur Suivant.
    • Facultatif : ajoutez une balise de description.
  9. Cliquez sur Créer une clé d'accès.
  10. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
  11. Cliquez sur OK.
  12. Sélectionnez l'onglet Autorisations.
  13. Cliquez sur Add permissions (Ajouter des autorisations) dans la section Permissions policies (Stratégies d'autorisation).
  14. Sélectionnez Ajouter des autorisations.
  15. Sélectionnez Associer directement des stratégies.
  16. Recherchez la stratégie AmazonS3FullAccess.
  17. Sélectionnez la règle.
  18. Cliquez sur Suivant.
  19. Cliquez sur Ajouter des autorisations.

Installer et configurer Log Shipper sur le serveur VShell

Choisissez l'une des options suivantes en fonction de votre système d'exploitation :

Option A : Utiliser NXLog (Windows)

  1. Téléchargez et installez NXLog Community Edition depuis nxlog.co.
  2. Modifier C:\Program Files\nxlog\conf\nxlog.conf :

    <Extension json>
        Module      xm_json
    </Extension>
    
    <Extension syslog>
        Module      xm_syslog
    </Extension>
    
    <Input vshell_log>
        Module      im_file
        File        "C:\\Program Files\\VanDyke Software\\VShell\\Log\\VShell.log"
        SavePos     TRUE
    
        <Exec>
            # Parse VShell log format
            if $raw_event =~ /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) "(.*)"$/
            {
                $EventTime = $1;
                $Protocol = $2;
                $EventType = $3;
                $SessionID = $4;
                $ClientIP = $5;
                $ClientPort = $6;
                $Username = $7;
                $Filename = $9;
                $BytesDown = $10;
                $BytesUp = $11;
                $ServerIP = $14;
                $ServerPort = $15;
                $EventMessage = $16;
    
                # Convert to JSON
                to_json();
            }
        </Exec>
    </Input>
    
    <Output s3>
        Module      om_exec
        Command     C:\scripts\upload_to_s3.ps1
        Args        %FILEPATH%
    </Output>
    
    <Route vshell_to_s3>
        Path        vshell_log => s3
    </Route>
    
  3. Créez le script PowerShell C:\scripts\upload_to_s3.ps1 :

    param([string]$FilePath)
    
    $bucket = "vandyke-sftp-logs"
    $key = "vshell/$(Get-Date -Format 'yyyy/MM/dd/HH')/$(Get-Date -Format 'yyyyMMddHHmmss').json"
    
    # Batch logs
    $logs = Get-Content $FilePath | ConvertFrom-Json
    $jsonLines = $logs | ForEach-Object { $_ | ConvertTo-Json -Compress }
    $content = $jsonLines -join "`n"
    
    # Upload to S3
    Write-S3Object -BucketName $bucket -Key $key -Content $content -ProfileName default
    
  4. Créez un profil d'identifiants AWS :

    Set-AWSCredential -AccessKey YOUR_ACCESS_KEY -SecretKey YOUR_SECRET_KEY -StoreAs default
    
  5. Planifiez l'exécution du script PowerShell toutes les cinq minutes à l'aide du planificateur de tâches.

Option B : Utiliser Fluent Bit (Linux)

  1. Installez Fluent Bit :

    curl https://raw.githubusercontent.com/fluent/fluent-bit/master/install.sh | sh
    
  2. Configurez /etc/fluent-bit/fluent-bit.conf :

    [SERVICE]
        Flush        5
        Daemon       On
        Log_Level    info
    
    [INPUT]
        Name              tail
        Path              /var/log/vshell/vshell.log
        Parser            vshell_parser
        Tag               vshell.*
        Refresh_Interval  5
        Mem_Buf_Limit     10MB
    
    [PARSER]
        Name        vshell_parser
        Format      regex
        Regex       ^(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (?<protocol>\S+) (?<event_type>\S+) (?<session_id>\S+) (?<client_ip>\S+) (?<client_port>\S+) (?<username>\S+) (?<dash>\S+) (?<filename>\S+) (?<bytes_down>\S+) (?<bytes_up>\S+) (?<field1>\S+) (?<field2>\S+) (?<server_ip>\S+) (?<server_port>\S+) "(?<event_message>[^"]*)"
    
    [OUTPUT]
        Name                  s3
        Match                 vshell.*
        bucket                vandyke-sftp-logs
        region                us-east-1
        use_put_object        On
        total_file_size       5M
        upload_timeout        10s
        compression           gzip
        s3_key_format         /vshell/%Y/%m/%d/%H/%{hostname}_%{uuid}.json.gz
    
  3. Configurez les identifiants AWS :

    export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
    export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
    
  4. Démarrez Fluent Bit :

    sudo systemctl enable fluent-bit
    sudo systemctl start fluent-bit
    

Configurer un flux dans Google SecOps pour ingérer les journaux VanDyke VShell

  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.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, VanDyke VShell SFTP logs).
  4. Sélectionnez Amazon S3 V2 comme Type de source.
  5. Sélectionnez VanDyke SFTP comme Type de journal (personnalisé).
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • URI S3 : s3://vandyke-sftp-logs/vshell/
    • Options de suppression de la source : sélectionnez Conserver (recommandé) ou l'option de suppression de votre choix.
    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours. La valeur par défaut est de 180 jours.
    • ID de clé d'accès : clé d'accès utilisateur permettant d'accéder au bucket S3.
    • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
    • Espace de noms de l'élément : espace de noms de l'élément.
    • Étiquettes d'ingestion : étiquette appliquée aux événements de ce flux.
  8. Cliquez sur Suivant.
  9. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ du journal mappage UDM Logique
agent.id read_only_udm.observer.asset_id Concatène "filebeat:" avec la valeur du champ agent.id
agent.type read_only_udm.observer.application Mappe directement la valeur du champ agent.type
agent.version read_only_udm.observer.platform_version Mappe directement la valeur du champ agent.version
ecs.version read_only_udm.metadata.product_version Mappe directement la valeur du champ ecs.version
host.architecture read_only_udm.target.asset.hardware.cpu_platform Mappe directement la valeur du champ host.architecture
host.hostname read_only_udm.target.hostname Mappe directement la valeur du champ host.hostname
host.id read_only_udm.principal.asset_id Concatène "VANDYKE_SFTP:" avec la valeur du champ host.id
host.ip read_only_udm.target.ip Mappe directement chaque adresse IP du tableau host.ip à un champ read_only_udm.target.ip distinct.
host.mac read_only_udm.target.mac Mappe directement chaque adresse MAC du tableau host.mac à un champ read_only_udm.target.mac distinct.
host.os.kernel read_only_udm.target.platform_patch_level Mappe directement la valeur du champ host.os.kernel
host.os.platform read_only_udm.target.platform Mappe la valeur de host.os.platform sur WINDOWS, LINUX, MAC ou UNKNOWN_PLATFORM en fonction de la valeur.
host.os.version read_only_udm.target.platform_version Mappe directement la valeur du champ host.os.version
log.file.path read_only_udm.principal.process.file.full_path Mappe directement la valeur du champ log.file.path
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp Analyse le code temporel du champ logstash.collect.timestamp et le convertit en objet de code temporel
logstash.irm_environment read_only_udm.additional.fields.value.string_value Mappe directement la valeur du champ logstash.irm_environment. La clé est définie sur "irm_environment".
logstash.irm_region read_only_udm.additional.fields.value.string_value Mappe directement la valeur du champ logstash.irm_region. La clé est définie sur "irm_region".
logstash.irm_site read_only_udm.additional.fields.value.string_value Mappe directement la valeur du champ logstash.irm_site. La clé est définie sur "irm_site".
logstash.process.host read_only_udm.observer.hostname Mappe directement la valeur du champ logstash.process.host
message Utilisé pour extraire divers champs à l'aide de modèles grok et d'expressions régulières
read_only_udm.metadata.event_type Définissez cette option sur "NETWORK_FTP".
read_only_udm.metadata.log_type Définissez cette option sur "VANDYKE_SFTP".
read_only_udm.metadata.product_event_type Extrait du champ de message à l'aide d'un modèle grok
read_only_udm.metadata.product_name Définissez cette option sur "VANDYKE_SFTP".
read_only_udm.metadata.vendor_name Définissez cette valeur sur "VANDYKE SOFTWARE".
read_only_udm.network.application_protocol Définissez sur "SSH" si le champ de description contient "SSH2" ou "SSH", sinon définissez sur "HTTP" si le champ de méthode correspond aux méthodes HTTP
read_only_udm.network.http.method Extrait du champ de message à l'aide d'un modèle grok, uniquement s'il correspond aux méthodes HTTP courantes
read_only_udm.network.http.referral_url Extrait du champ de message à l'aide d'un modèle grok
read_only_udm.network.http.response_code Extrait du champ de message à l'aide d'un modèle grok et converti en entier
read_only_udm.network.ip_protocol Définissez sur "TCP" si le champ de description contient "TCP".
read_only_udm.principal.ip Extrait du champ de message à l'aide d'un modèle grok
read_only_udm.principal.port Extrait du champ de message à l'aide d'un modèle grok et converti en entier
read_only_udm.security_result.description Extrait du champ de message à l'aide d'un modèle grok
read_only_udm.security_result.severity Définissez sur "HIGH" si syslog_severity est "error" ou "warning", sur "MEDIUM" si c'est "notice" et sur "LOW" si c'est "information" ou "info".
read_only_udm.security_result.severity_details Mappe directement la valeur du champ syslog_severity
read_only_udm.target.ip Extrait du champ de message à l'aide d'un modèle grok
read_only_udm.target.port Extrait du champ de message à l'aide d'un modèle grok et converti en entier
read_only_udm.target.process.pid Extrait du champ de message à l'aide d'un modèle grok
syslog_severity Utilisé pour déterminer la gravité du security_result
username event.idm.read_only_udm.target.user.userid Mappé à partir du journal des modifications
username event.idm.read_only_udm.target.user.user_display_name Mappé à partir du journal des modifications
id event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
reason security_result.summary Mappé à partir du journal des modifications
srcip principal.ip Mappé à partir du journal des modifications
username principal.user.user_display_name 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.