Cette page a été traduite par l'API Cloud Translation.

Collecter les journaux SFTP VanDyke VShell

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer les journaux SFTP VanDyke VShell dans Google Security Operations à l'aide de Bindplane avec Syslog ou d'Amazon S3 avec un outil d'envoi de journaux. L'analyseur transforme les journaux bruts en un format UDM structuré. Il gère les formats JSON et SYSLOG, extrait les champs pertinents tels que les adresses IP, les ports et les détails des événements, et enrichit les données avec des informations contextuelles telles que les détails de la plate-forme et le niveau de gravité de la sécurité.

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

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.

Connectez-vous à la console Google SecOps.
Accédez à Paramètres du SIEM > Agents de collecte.
Téléchargez le fichier d'authentification d'ingestion. Enregistrez le fichier de manière sécurisée sur le système sur lequel Bindplane sera installé ou sur lequel vous configurerez le flux.

Obtenir l'ID client Google SecOps

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

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 fenêtres

Ouvrez l'invite de commandes ou PowerShell en tant qu'administrateur.

Exécutez la commande suivante :

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

Installation de Linux

Ouvrez un terminal avec les droits root ou sudo.

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

Autres ressources d'installation

Pour plus d'options d'installation, consultez ce guide d'installation.

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

Accédez au fichier de configuration :
1. Recherchez le fichier config.yaml. Il se trouve généralement dans le répertoire /etc/bindplane-agent/ sous Linux ou dans le répertoire d'installation sous Windows.
2. Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou le Bloc-notes).

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

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 <customer_id> par le numéro client réel.
Mettez à jour /path/to/ingestion-authentication-file.json en indiquant le chemin d'accès où le fichier d'authentification a été enregistré dans la section Obtenir le fichier d'authentification pour l'ingestion Google SecOps.
Pour utiliser TCP au lieu d'UDP, remplacez udplog par tcplog.

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 bindplane-agent
```
Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :
```
net stop BindPlaneAgent && net start BindPlaneAgent
```

Configurer le transfert Syslog sur VanDyke VShell

Pour VShell sur Windows

Connectez-vous au panneau de configuration VShell.
Accédez aux paramètres de journalisation.
Configurez la journalisation syslog à distance :
- Activez la journalisation sur le serveur syslog distant.
- Adresse du serveur : saisissez l'adresse IP de l'agent 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.
Cliquez sur Appliquer > OK.

Pour VShell sur Linux/macOS

Modifiez le fichier vshelld_config (généralement /etc/vshell/vshelld_config).

Configurez les paramètres suivants :

SyslogFacility LOG_LOCAL3
LogLevel INFO

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

Redémarrez le service VShell et le service 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

Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, vandyke-sftp-logs).
Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
Sélectionnez l'utilisateur créé.
Sélectionnez l'onglet Informations d'identification de sécurité.
Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
Sélectionnez Service tiers comme Cas d'utilisation.
Cliquez sur Suivant.
Facultatif : Ajoutez un tag de description.
Cliquez sur Créer une clé d'accès.
Cliquez sur 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.
Cliquez sur OK.
Sélectionnez l'onglet Autorisations.
Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
Sélectionnez Ajouter des autorisations.
Sélectionnez Joindre directement des règles.
Recherchez la règle AmazonS3FullAccess.
Sélectionnez la règle.
Cliquez sur Suivant.
Cliquez sur Ajouter des autorisations.

Installer et configurer Log Shipper sur VShell Server

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

Option A : Utiliser NXLog (Windows)

Téléchargez et installez NXLog Community Edition depuis nxlog.co.

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>

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

Créez un profil d'identifiants AWS :
```
Set-AWSCredential -AccessKey YOUR_ACCESS_KEY -SecretKey YOUR_SECRET_KEY -StoreAs default
```
1. Planifiez l'exécution du script PowerShell toutes les cinq minutes à l'aide du planificateur de tâches.

Option B : Utiliser Fluent Bit (Linux)

Installez Fluent Bit :

curl https://raw.githubusercontent.com/fluent/fluent-bit/master/install.sh | sh

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

Configurez les identifiants AWS :

export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY

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

Accédez à Paramètres SIEM> Flux.
Cliquez sur Add New Feed (Ajouter un flux).
Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, VanDyke VShell SFTP logs).
Sélectionnez Amazon S3 V2 comme type de source.
Sélectionnez VanDyke SFTP comme type de journal (personnalisé).
Cliquez sur Suivant.
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 des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
- ID de clé d'accès : clé d'accès utilisateur ayant accès 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.
- Libellés d'ingestion : libellé appliqué aux événements de ce flux.
Cliquez sur Suivant.
Vérifiez la configuration de votre nouveau flux 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 l'horodatage du champ logstash.collect.timestamp et le convertit en objet d'horodatage
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		Permet d'extraire différents champs à l'aide de modèles Grok et d'expressions régulières
	read_only_udm.metadata.event_type	Définissez-le sur "NETWORK_FTP".
	read_only_udm.metadata.log_type	Définissez-le 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-le sur "VANDYKE_SFTP".
	read_only_udm.metadata.vendor_name	Définissez-le sur "VANDYKE SOFTWARE".
	read_only_udm.network.application_protocol	Défini sur "SSH" si le champ de description contient "SSH2" ou "SSH", sinon défini 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 la valeur 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 syslog_severity est "notice", et sur "LOW" si syslog_severity 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

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