Raccogli i log SFTP di VanDyke VShell

Supportato in:

Questo documento spiega come importare i log SFTP di VanDyke VShell in Google Security Operations utilizzando Bindplane con Syslog o Amazon S3 con un log shipper.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Accesso con privilegi al server o alla console di gestione VanDyke VShell
  • Per l'Opzione 1: un host Windows 2016 o versioni successive o Linux con systemd per l'agente Bindplane
  • Per l'Opzione 2: account AWS con accesso S3 e NXLog/Fluent Bit sul server VShell

Recupera le credenziali Google SecOps per l'agente Bindplane

Per autenticare l'agente Bindplane in Google SecOps, scegli uno dei seguenti metodi:

  • Nuove implementazioni: utilizza l'API Chronicle (opzione 1).
  • Deployment legacy: continua a utilizzare il file di autenticazione dell'acquisizione (opzione 2) fino al ritiro dell'API Ingestion il 20 luglio 2027.
  1. Accedi alla Google Cloud console e seleziona il progetto Google Cloud collegato alla tua istanza Google SecOps.
  2. Vai a IAM e amministrazione > Service account.
  3. Fai clic su Crea service account.
  4. Fornisci i seguenti dettagli di configurazione:
    • Nome service account: inserisci un nome per l'account (ad esempio bindplane-ingest).
    • Descrizione service account: inserisci una descrizione (ad esempio Bindplane agent log ingestion).
  5. Fai clic su Crea e continua.
  6. Nella sezione Concedi a questo account di servizio l'accesso al progetto, fai clic su Seleziona un ruolo e seleziona Chronicle Editor.
  7. Fai clic su Continua, quindi su Fine.
  8. Fai clic sul account di servizio che hai creato, quindi vai alla scheda Chiavi.
  9. Fai clic su Aggiungi chiave > Crea nuova chiave.
  10. Seleziona JSON e fai clic su Crea. Il file della chiave viene scaricato sul tuo computer.
  11. Salva il file della chiave come ingestion-auth.json nella directory del raccoglitore Bindplane (/opt/observiq-otel-collector/ingestion-auth.json su Linux o C:\Program Files\observIQ OpenTelemetry Collector\ingestion-auth.json su Windows) oppure aggiorna creds_file_path in config.yaml in modo che corrisponda al percorso in cui lo salvi.
  12. Vai a IAM e amministrazione > Impostazioni e copia il Numero progetto. Ti servirà per la configurazione dell'esportatore.

Opzione 2: scarica il file di autenticazione dell'acquisizione (legacy)

  1. Accedi alla console Google SecOps.
  2. Vai a Impostazioni SIEM > Agenti di raccolta.
  3. Scarica il file di autenticazione dell'acquisizione.
  4. Salva il file in modo sicuro sul sistema in cui verrà installato l'agente Bindplane.

Ottieni l'ID cliente Google SecOps

  1. Accedi alla console Google SecOps.
  2. Vai a Impostazioni SIEM > Profilo.
  3. Copia e salva l'ID cliente dalla sezione Dettagli dell'organizzazione.

Opzione 1: integrazione tramite Bindplane e Syslog

Questa opzione fornisce lo streaming dei log in tempo reale con una latenza minima ed è consigliata per la maggior parte dei deployment.

Installa l'agente Bindplane

Installa l'agente Bindplane sul sistema operativo Windows o Linux seguendo le istruzioni riportate di seguito.

Installazione di finestre

  1. Apri il prompt dei comandi o PowerShell come amministratore.

  2. Esegui questo comando:

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

Installazione di Linux

  1. Apri un terminale con privilegi root o sudo.

  2. Esegui questo comando:

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

Risorse aggiuntive per l'installazione

Per ulteriori opzioni di installazione, consulta la guida all'installazione dell'agente Bindplane.

Configura l'agente BindPlane per importare Syslog e inviarlo a Google SecOps

  1. Accedi al file di configurazione:

    • Individua il file config.yaml. In genere si trova nella directory /opt/observiq-otel-collector/ su Linux o nella directory di installazione su Windows.
    • Apri il file utilizzando un editor di testo (ad esempio nano, vi o Blocco note).

  2. Modifica il file config.yaml come segue:

    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
    • Sostituisci la porta e l'indirizzo IP in base alle esigenze della tua infrastruttura.
    • Sostituisci <LOCATION> con la regione della tua istanza Google SecOps (ad esempio us, europe o asia-southeast1). L'esportatore antepone chronicle.googleapis.com a questo valore.
    • Sostituisci <PROJECT_NUMBER> con il numero di progetto in IAM e amministrazione > Impostazioni.
    • Sostituisci YOUR_CUSTOMER_ID con l'ID cliente effettivo.
    • Aggiorna /path/to/ingestion-authentication-file.json con il percorso del file in cui è stato salvato il file della chiave del account di servizio (opzione 1).
    • Per TCP anziché UDP, sostituisci udplog con tcplog.

Esportatore API di importazione legacy

  • Se utilizzi il file di autenticazione dell'acquisizione dell'Opzione 2, sostituisci il blocco exporters con il seguente. Imposta creds_file_path sul percorso del file di autenticazione dell'acquisizione e, se l'istanza si trova al di fuori degli Stati Uniti, sostituisci malachiteingestion-pa.googleapis.com con il tuo endpoint regionale (ad esempio, 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:

Riavvia l'agente Bindplane per applicare le modifiche

  • Per riavviare l'agente Bindplane in Linux, esegui questo comando:

    sudo systemctl restart observiq-otel-collector

  • Per riavviare l'agente Bindplane in Windows, puoi utilizzare la console Servizi o inserire il seguente comando:

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

Configura l'inoltro di Syslog su VanDyke VShell

Per VShell su Windows

  1. Accedi al pannello di controllo di VShell.
  2. Vai alle impostazioni di Logging.
  3. Configura il logging syslog remoto:
    • Abilita il logging sul server syslog remoto.
    • Indirizzo server: inserisci l'indirizzo IP di Bindplane.
    • Porta: inserisci 514 (o la porta configurata).
    • Protocol (Protocollo): seleziona UDP (o TCP se configurato).
    • Gruppi di messaggi: seleziona Connessione, Autenticazione, SFTP, FTPS, HTTPS, Errori, Avvisi e Informativi.
  4. Fai clic su Applica > OK.

Per VShell su Linux/macOS

  1. Modifica il file vshelld_config (in genere /etc/vshell/vshelld_config).

  2. Configura i seguenti parametri:

    SyslogFacility LOG_LOCAL3
LogLevel INFO

  3. Configura syslog del sistema per inoltrare LOG_LOCAL3 all'agente Bindplane:

    • Modifica /etc/rsyslog.conf o /etc/syslog-ng/syslog-ng.conf.
    • Aggiungi: local3.* @bindplane-agent-ip:514 (per UDP) o local3.* @@bindplane-agent-ip:514 (per TCP).

  4. Riavvia il servizio VShell e il servizio syslog:

    sudo systemctl restart vshelld
sudo systemctl restart rsyslog

Opzione 2: integrazione tramite AWS S3

Questa opzione è utile per gli ambienti che richiedono l'archiviazione dei log o in cui l'inoltro diretto di syslog non è fattibile. Tieni presente che è necessario un programma di spedizione dei log sul server VShell, poiché AWS Lambda non può accedere ai file on-premise.

Configura il bucket AWS S3 e IAM per Google SecOps

  1. Crea un bucket Amazon S3 seguendo questa guida dell'utente: Creazione di un bucket
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, vandyke-sftp-logs).
  3. Crea un utente seguendo questa guida dell'utente: Creazione di un utente IAM.
  4. Seleziona l'utente creato.
  5. Seleziona la scheda Security credentials (Credenziali di sicurezza).
  6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
  7. Seleziona Servizio di terze parti come Caso d'uso.
  8. Fai clic su Avanti.
    • (Facoltativo) Aggiungi un tag di descrizione.
  9. Fai clic su Crea chiave di accesso.
  10. Fai clic su Scarica file .csv per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
  11. Fai clic su Fine.
  12. Seleziona la scheda Autorizzazioni.
  13. Fai clic su Aggiungi autorizzazioni nella sezione Policy di autorizzazione.
  14. Seleziona Aggiungi autorizzazioni.
  15. Seleziona Collega direttamente le policy.
  16. Cerca la policy AmazonS3FullAccess.
  17. Seleziona la policy.
  18. Fai clic su Avanti.
  19. Fai clic su Aggiungi autorizzazioni.

Installa e configura Log Shipper sul server VShell

Scegli una delle seguenti opzioni in base al tuo sistema operativo:

Opzione A: utilizzo di NXLog (Windows)

  1. Scarica e installa NXLog Community Edition da nxlog.co.

  2. Modifica 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. Crea lo 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. Crea il profilo delle credenziali AWS:

    Set-AWSCredential -AccessKey YOUR_ACCESS_KEY -SecretKey YOUR_SECRET_KEY -StoreAs default

  5. Pianifica l'esecuzione dello script di PowerShell ogni 5 minuti utilizzando l'Utilità di pianificazione.

Opzione B: utilizzo di Fluent Bit (Linux)

  1. Installa Fluent Bit:

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

  2. Configura /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. Configura le credenziali AWS:

    export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY

  4. Avvia Fluent Bit:

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

Configura un feed in Google SecOps per importare i log di VanDyke VShell

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su + Aggiungi nuovo feed.
  3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, VanDyke VShell SFTP logs).
  4. Seleziona Amazon S3 V2 come Tipo di origine.
  5. Seleziona VanDyke SFTP come Tipo di log (personalizzato).
  6. Fai clic su Avanti.
  7. Specifica i valori per i seguenti parametri di input:
    • URI S3: s3://vandyke-sftp-logs/vshell/
    • Opzioni di eliminazione dell'origine: seleziona Conserva (consigliato) o l'opzione di eliminazione in base alle tue preferenze.
    • Età massima del file: includi i file modificati negli ultimi giorni. Il valore predefinito è 180 giorni.
    • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.
    • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.
    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
    • Etichette di importazione: l'etichetta applicata agli eventi di questo feed.
  8. Fai clic su Avanti.
  9. Controlla la nuova configurazione del feed di notizie nella schermata Finalizza, quindi fai clic su Invia.

Tabella di mappatura UDM

Campo log mappatura UDM Logica
agent.id read_only_udm.observer.asset_id Concatena "filebeat:" con il valore del campo agent.id
agent.type read_only_udm.observer.application Mappa direttamente il valore del campo agent.type
agent.version read_only_udm.observer.platform_version Mappa direttamente il valore del campo agent.version
ecs.version read_only_udm.metadata.product_version Mappa direttamente il valore del campo ecs.version
host.architecture read_only_udm.target.asset.hardware.cpu_platform Mappa direttamente il valore del campo host.architecture
host.hostname read_only_udm.target.hostname Mappa direttamente il valore del campo host.hostname
host.id read_only_udm.principal.asset_id Concatena "VANDYKE_SFTP:" con il valore del campo host.id
host.ip read_only_udm.target.ip Mappa direttamente ogni indirizzo IP nell'array host.ip a un campo read_only_udm.target.ip separato
host.mac read_only_udm.target.mac Mappa direttamente ogni indirizzo MAC nell'array host.mac a un campo read_only_udm.target.mac separato
host.os.kernel read_only_udm.target.platform_patch_level Mappa direttamente il valore del campo host.os.kernel
host.os.platform read_only_udm.target.platform Mappa il valore di host.os.platform su WINDOWS, LINUX, MAC o UNKNOWN_PLATFORM in base al valore
host.os.version read_only_udm.target.platform_version Mappa direttamente il valore del campo host.os.version
log.file.path read_only_udm.principal.process.file.full_path Mappa direttamente il valore del campo log.file.path
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp Analizza il timestamp dal campo logstash.collect.timestamp e lo converte in un oggetto timestamp
logstash.irm_environment read_only_udm.additional.fields.value.string_value Mappa direttamente il valore del campo logstash.irm_environment. La chiave è impostata su "irm_environment"
logstash.irm_region read_only_udm.additional.fields.value.string_value Mappa direttamente il valore del campo logstash.irm_region. La chiave è impostata su "irm_region"
logstash.irm_site read_only_udm.additional.fields.value.string_value Mappa direttamente il valore del campo logstash.irm_site. La chiave è impostata su "irm_site"
logstash.process.host read_only_udm.observer.hostname Mappa direttamente il valore del campo logstash.process.host
message Utilizzato per estrarre vari campi utilizzando pattern grok ed espressioni regolari
read_only_udm.metadata.event_type Imposta su "NETWORK_FTP"
read_only_udm.metadata.log_type Imposta su "VANDYKE_SFTP"
read_only_udm.metadata.product_event_type Estratto dal campo del messaggio utilizzando un pattern grok
read_only_udm.metadata.product_name Imposta su "VANDYKE_SFTP"
read_only_udm.metadata.vendor_name Impostalo su "VANDYKE SOFTWARE"
read_only_udm.network.application_protocol Impostato su "SSH" se il campo della descrizione contiene "SSH2" o "SSH", altrimenti impostato su "HTTP" se il campo del metodo corrisponde ai metodi HTTP
read_only_udm.network.http.method Estratto dal campo del messaggio utilizzando un pattern grok, solo se corrisponde ai metodi HTTP comuni
read_only_udm.network.http.referral_url Estratto dal campo del messaggio utilizzando un pattern grok
read_only_udm.network.http.response_code Estratto dal campo del messaggio utilizzando un pattern grok e convertito in un numero intero
read_only_udm.network.ip_protocol Impostato su "TCP" se il campo della descrizione contiene "TCP"
read_only_udm.principal.ip Estratto dal campo del messaggio utilizzando un pattern grok
read_only_udm.principal.port Estratto dal campo del messaggio utilizzando un pattern grok e convertito in un numero intero
read_only_udm.security_result.description Estratto dal campo del messaggio utilizzando un pattern grok
read_only_udm.security_result.severity Impostato su "HIGH" se syslog_severity è "error" o "warning", "MEDIUM" se è "notice" e "LOW" se è "information" o "info"
read_only_udm.security_result.severity_details Mappa direttamente il valore del campo syslog_severity
read_only_udm.target.ip Estratto dal campo del messaggio utilizzando un pattern grok
read_only_udm.target.port Estratto dal campo del messaggio utilizzando un pattern grok e convertito in un numero intero
read_only_udm.target.process.pid Estratto dal campo del messaggio utilizzando un pattern grok
syslog_severity Utilizzato per determinare la gravità di security_result
username event.idm.read_only_udm.target.user.userid Mappato dal log delle modifiche
username event.idm.read_only_udm.target.user.user_display_name Mappato dal log delle modifiche
id event.idm.read_only_udm.additional.fields Mappato dal log delle modifiche
reason security_result.summary Mappato dal log delle modifiche
srcip principal.ip Mappato dal log delle modifiche
username principal.user.user_display_name Mappato dal log delle modifiche

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.