Google SecOps CLI-Nutzerhandbuch

Unterstützt in:

Das Google Security Operations SDK bietet eine umfassende Befehlszeile (Command-Line Interface, CLI), mit der Sie ganz einfach über Ihr Terminal mit Google SecOps-Produkten interagieren können. Die neue secops-Befehlszeile ersetzt die alte chronicle_cli und bietet erweiterte Funktionen und eine verbesserte Nutzerfreundlichkeit.

Übersicht

Die secops-Befehlszeile bietet Zugriff auf:

  • UDM-Ereignisse suchen und analysieren
  • Feeds, Weiterleitungen und Parser verwalten
  • Erkennungsregeln erstellen und verwalten
  • Umgang mit Benachrichtigungen und Anfragen
  • Referenzlisten und Datentabellen verwalten
  • Daten nach BigQuery und Google Cloud Storage exportieren
  • Gemini AI nach Sicherheitsinformationen fragen
  • Und vieles mehr

Google SecOps CLI-Befehle verwenden die folgende Syntax:

$ secops COMMAND [SUBCOMMAND] [OPTIONS]

So suchen Sie beispielsweise nach Veranstaltungen:

$ secops search --query "metadata.event_type = \"NETWORK_CONNECTION\"" --time-window 24

Hinweis

Bevor Sie die Google SecOps CLI installieren, müssen folgende Voraussetzungen erfüllt sein:

  • Python 3.8 oder höher ist in Ihrer Umgebung installiert. Weitere Informationen finden Sie unter Python installieren.
  • Eine Google SecOps-Instanz mit den entsprechenden Zugriffsberechtigungen.
  • Authentifizierungsanmeldedaten (Dienstkonto oder Standardanmeldedaten für Anwendungen)

Installation

Installieren Sie das SecOps SDK, das die CLI enthält:

pip install secops

Installation prüfen:

$ secops --help

Authentifizierung

Die CLI unterstützt mehrere Authentifizierungsmethoden:

# Set up ADC with gcloud
gcloud auth application-default login

Dienstkonto verwenden

Speichern Sie die JSON-Datei Ihres Dienstkontos an einem sicheren Ort und verweisen Sie in Befehlen darauf:

$ secops search --service-account "/path/to/service-account.json" --customer-id "your-instance-id" --project-id "your-project-id" --query "metadata.event_type = \"USER_LOGIN\""

Konfiguration

Häufig verwendete Einstellungen speichern, um Wiederholungen in Befehlen zu vermeiden:

Konfiguration speichern

# Save instance and authentication settings
$ secops config set --customer-id "your-instance-id" --project-id "your-project-id" --region "us"

# Save service account path (optional)
$ secops config set --service-account "/path/to/service-account.json" --customer-id "your-instance-id" --project-id "your-project-id"

# Set default time window
$ secops config set --time-window 48

Konfiguration ansehen

$ secops config view

Konfiguration löschen

$ secops config clear

Regionen

Die CLI unterstützt alle Google SecOps-Regionen. Sie können die Region mit folgenden Methoden festlegen:

  • Das Flag --region mit einem beliebigen Befehl
  • Konfigurationsdatei mit secops config set --region REGION

Unterstützte Regionen:

  • US (Standard)
  • EUROPE
  • ASIA-SOUTHEAST1
  • ASIA-SOUTH1
  • AUSTRALIA-SOUTHEAST1
  • EUROPE-WEST2: EUROPE-WEST3, EUROPE-WEST6, EUROPE-WEST9, EUROPE-WEST12
  • Und weitere Funktionen

Wichtige Befehle

Ereignisse suchen

Mit der folgenden Abfragesyntax können Sie nach UDM-Ereignissen suchen:

# Search with UDM query
$ secops search --query "metadata.event_type = \"NETWORK_CONNECTION\"" --time-window 24 --max-events 100

# Search using natural language
$ secops search --nl-query "show me failed login attempts" --time-window 24

# Export results as CSV
$ secops search --query "metadata.event_type = \"USER_LOGIN\" AND security_result.action = \"BLOCK\"" \
    --fields "metadata.event_timestamp,principal.user.userid,principal.ip" \
    --time-window 24 --csv

Informationen zur juristischen Person

Detaillierte Informationen zu IP-Adressen, Domains oder Datei-Hashes abrufen:

$ secops entity --value "8.8.8.8" --time-window 24
$ secops entity --value "example.com" --time-window 24
$ secops entity --value "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" --time-window 24

Statistiken

Statistische Analysen für Ihre Daten ausführen:

$ secops stats --query "metadata.event_type = \"NETWORK_CONNECTION\"
match:
  target.hostname
outcome:
  \$count = count(metadata.id)
order:
  \$count desc" --time-window 24

Feedverwaltung

Datenaufnahmefeeds in Google SecOps verwalten:

Feeds auflisten

$ secops feed list

Feed erstellen

# Create an HTTP feed
$ secops feed create \
    --display-name "My HTTP Feed" \
    --details '{"logType":"projects/your-project-id/locations/us/instances/your-instance-id/logTypes/WINEVTLOG","feedSourceType":"HTTP","httpSettings":{"uri":"https://example.com/feed","sourceType":"FILES"}}'

Feed aktualisieren

$ secops feed update --id "feed-123" --display-name "Updated Feed Name"

Feed aktivieren/deaktivieren

$ secops feed enable --id "feed-123"
$ secops feed disable --id "feed-123"

Feed löschen

$ secops feed delete --id "feed-123"

Parserverwaltung

Parser verarbeiten und normalisieren Logrohdaten im UDM-Format:

Parser auflisten

$ secops parser list
$ secops parser list --log-type "WINDOWS"

Parserdetails abrufen

$ secops parser get --log-type "WINDOWS" --id "pa_12345"

Parser erstellen

# Create from file
$ secops parser create --log-type "CUSTOM_LOG" --parser-code-file "/path/to/parser.conf"

# Create from string
$ secops parser create --log-type "CUSTOM_LOG" --parser-code "filter { mutate { add_field => { \"test\" => \"value\" } } }"

Testparser

Parser vor der Bereitstellung mit Beispiellogs testen:

# Test with inline logs
$ secops parser run \
    --log-type OKTA \
    --parser-code-file "./parser.conf" \
    --log '{"message": "Test log 1"}' \
    --log '{"message": "Test log 2"}'

# Test with logs from file
$ secops parser run \
    --log-type WINDOWS \
    --parser-code-file "./parser.conf" \
    --logs-file "./sample_logs.txt"

Parser aktivieren/deaktivieren

$ secops parser activate --log-type "WINDOWS" --id "pa_12345"
$ secops parser deactivate --log-type "WINDOWS" --id "pa_12345"

Parser löschen

$ secops parser delete --log-type "WINDOWS" --id "pa_12345"

Verwaltung von Parser-Erweiterungen

Parser-Erweiterungen erweitern vorhandene Parser, ohne sie zu ersetzen:

Erweiterungen auflisten

$ secops parser-extension list --log-type OKTA

Erweiterung erstellen

$ secops parser-extension create --log-type OKTA \
    --log /path/to/sample.log \
    --parser-config-file /path/to/parser-config.conf

Erweiterung aktivieren

$ secops parser-extension activate --log-type OKTA --id "1234567890"

Forwarder-Verwaltung

Forwarder werden verwendet, um Logs mit bestimmten Konfigurationen zu erfassen:

Forwarder erstellen

# Basic forwarder
$ secops forwarder create --display-name "my-custom-forwarder"

# With metadata and settings
$ secops forwarder create --display-name "prod-forwarder" \
    --metadata '{"environment":"prod","team":"security"}' \
    --upload-compression true \
    --http-settings '{"port":80,"host":"example.com"}'

Weiterleitungen auflisten

$ secops forwarder list --page-size 100

Forwarder abrufen

$ secops forwarder get --id "1234567890"

Forwarder aktualisieren

$ secops forwarder update --id "1234567890" --display-name "updated-name"

Forwarder löschen

$ secops forwarder delete --id "1234567890"

Workflows für den BigQuery-Datenzugriff

Google Security Operations unterstützt den Self-Service-Zugriff auf Google Security Operations-Daten (sowohl SIEM als auch SOAR) in BigQuery. Mit der Google Security Operations CLI können Sie Identity and Access Management (IAM)-Rollen zuweisen, die einer Nutzer-E-Mail-Adresse die folgenden Berechtigungen gewähren:

  • roles/bigquery.dataViewer
  • roles/bigquery.jobUser
  • roles/storage.objectViewer

Die E-Mail-Adresse muss die GAIA-E-Mail-Adresse (Google Accounts and ID Administration) eines Google SecOps-Kunden sein.

Weitere Informationen zu diesen Rollen finden Sie unter Tabellendaten exportieren.

Befehle

Befehl bigquery

Der Befehl bigquery verwendet das Argument provide_access.

Verwendungssyntax:

$ chronicle_cli bigquery ARGUMENT [OPTIONS]

Argumente

provide_access-Argument

Sie werden aufgefordert, die E‑Mail-Adresse eines Nutzers einzugeben. Die E-Mail-Adresse muss die GAIA-E-Mail-Adresse (Google Accounts and ID Administration) eines Google SecOps Security-Kunden sein. Der Nutzer erhält die erforderlichen IAM-Rollen für folgende Aktionen:

  • Daten und Metadaten aus BigQuery-Tabellen lesen (roles/bigquery.dataViewer)
  • Abfragen für BigQuery-Tabellendaten ausführen (roles/bigquery.jobUser)
  • Daten in Cloud Storage-Buckets lesen(roles/storage.objectViewer)
Verwendungsbeispiel
$ chronicle_cli bigquery provide_access
$ Enter email: xyz@gmail.com
Erfolgsantwort
Providing BigQuery access...
Access provided to email: xyz@gmail.com

Providing BigQuery access...
Error while providing access:
Response code: 400

Optionen

Hilfe (-h / --help)

Mit der Option -h oder --help können Sie die Verwendung oder Beschreibung eines beliebigen Befehls oder einer beliebigen Option aufrufen.

Fehlerbehebung

In diesem Abschnitt wird die Ausgabe angezeigt, die in der Konsole für verschiedene Arten von Antwortcodes aus der API-Antwort zu sehen ist.

provide_access Argument-Antwortcodes

Antwortcode Konsolenausgabe
400 Die E‑Mail-Adresse ist nicht vorhanden.
Alle anderen Antwortcodes Fehler beim Abrufen des Feeds. Antwortcode: {status code} Fehler: {error message}

Log-Aufnahme

Protokolle in Google SecOps aufnehmen:

Rohdatenlogs aufnehmen

# From file
$ secops log ingest --type "OKTA" --file "/path/to/okta_logs.json"

# With labels
$ secops log ingest --type "WINDOWS" --file "/path/to/logs.xml" \
    --labels "environment=production,team=security"

# Inline message
$ secops log ingest --type "WINDOWS" --message "{\"event\": \"data\"}"

UDM-Ereignisse aufnehmen

$ secops log ingest-udm --file "/path/to/udm_event.json"

Logtypen auflisten

$ secops log types
$ secops log types --search "windows"

UDM-Zuordnung generieren

$ secops log generate-udm-mapping \
    --log-format "JSON" \
    --log '{"id":"123","user":"test_user","source_ip":"192.168.1.10"}'

Regelverwaltung

Erkennungsregeln verwalten:

Regeln für Listen

$ secops rule list --page-size 50

Regel erstellen

$ secops rule create --file "/path/to/rule.yaral"

Regel aktualisieren

$ secops rule update --id "ru_12345" --file "/path/to/updated_rule.yaral"

Regel aktivieren/deaktivieren

$ secops rule enable --id "ru_12345" --enabled true
$ secops rule enable --id "ru_12345" --enabled false

Regel testen

Regel mit Verlaufsdaten testen:

# Test for last 24 hours
$ secops rule test --file "/path/to/rule.yaral" --time-window 24

# Test with specific time range
$ secops rule test --file "/path/to/rule.yaral" \
    --start-time "2023-07-01T00:00:00Z" \
    --end-time "2023-07-02T00:00:00Z" \
    --max-results 1000

Regel validieren

$ secops rule validate --file "/path/to/rule.yaral"

Regel löschen

$ secops rule delete --id "ru_12345"

Benachrichtigungen verwalten

So erhalten und verwalten Sie Benachrichtigungen:

$ secops alert --time-window 24 --max-alerts 50
$ secops alert --snapshot-query "feedback_summary.status != \"CLOSED\"" --time-window 24

Fallverwaltung

Details zur Supportanfrage abrufen:

$ secops case --ids "case-123,case-456"

Datentabellen

Datentabellen sind Sammlungen strukturierter Daten, die in Erkennungsregeln verwendet werden:

Datentabelle erstellen

$ secops data-table create \
    --name "suspicious_ips" \
    --description "Known suspicious IP addresses" \
    --header '{"ip_address":"CIDR","description":"STRING","severity":"STRING"}'

Zeilen hinzufügen

$ secops data-table add-rows \
    --name "suspicious_ips" \
    --rows '[["192.168.1.100","Scanning activity","Medium"]]'

Zeilen auflisten

$ secops data-table list-rows --name "suspicious_ips"

Datentabelle löschen

$ secops data-table delete --name "suspicious_ips"

Referenzlisten

Referenzlisten sind einfache Wertelisten für Erkennungsregeln:

Referenzliste erstellen

$ secops reference-list create \
    --name "admin_accounts" \
    --description "Administrative accounts" \
    --entries "admin,administrator,root,superuser"

Referenzliste aktualisieren

$ secops reference-list update \
    --name "admin_accounts" \
    --entries "admin,administrator,root,superuser,sysadmin"

Referenzlisten auflisten

$ secops reference-list list

Datenexport

Daten zur Analyse exportieren:

Export erstellen

# Export specific log type
$ secops export create \
    --gcs-bucket "projects/my-project/buckets/my-bucket" \
    --log-type "WINDOWS" \
    --time-window 24

# Export all logs
$ secops export create \
    --gcs-bucket "projects/my-project/buckets/my-bucket" \
    --all-logs \
    --time-window 168

Exportstatus prüfen

$ secops export status --id "export-123"

Export abbrechen

$ secops export cancel --id "export-123"

Verfügbare Logtypen für den Export auflisten

$ secops export log-types --time-window 24

Google AI-Integration

Google AI nach Sicherheitsinformationen fragen:

# Ask about security concepts
$ secops gemini --query "What is Windows event ID 4625?"

# Generate detection rules
$ secops gemini --query "Write a rule to detect PowerShell downloading files"

# Get vulnerability information
$ secops gemini --query "Tell me about CVE-2021-44228"

So aktivieren Sie Gemini:

$ secops gemini --opt-in

Dashboard-Verwaltung

Native Dashboards verwalten:

Dashboard erstellen

$ secops dashboard create \
    --display-name "Security Overview" \
    --description "Security monitoring dashboard" \
    --access-type PRIVATE

Dashboards auflisten

$ secops dashboard list --page-size 10

Dashboard aktualisieren

$ secops dashboard update --id dashboard-id \
    --display-name "Updated Security Dashboard" \
    --description "Updated security monitoring dashboard"

Dashboard exportieren/importieren

# Export
$ secops dashboard export --dashboard-names 'projects/your-project-id/locations/us/instances/your-instance-id/nativeDashboard/xxxxxxx'

# Import
$ secops dashboard import --dashboard-data-file dashboard_data.json

Diagramm zum Dashboard hinzufügen

$ secops dashboard add-chart --dashboard-id dashboard-id \
    --display-name "DNS Query Chart" \
    --description "Shows DNS query patterns" \
    --query-file dns_query.txt \
    --chart_layout '{"startX": 0, "spanX": 12, "startY": 0, "spanY": 8}'

Dashboard löschen

$ secops dashboard delete --id dashboard-id

Erweiterte Beispiele

Parser-Workflow abschließen

Parser abrufen, testen und bereitstellen:

# List parsers
$ secops parser list --log-type "OKTA" > okta_parsers.json

# Get parser details
PARSER_ID=$(cat okta_parsers.json | jq -r '.[0].name' | awk -F'/' '{print $NF}')
$ secops parser get --log-type "OKTA" --id "$PARSER_ID" > parser_details.json

# Extract parser code
cat parser_details.json | jq -r '.cbn' | base64 -d > okta_parser.conf

# Test parser
$ secops parser run \
    --log-type "OKTA" \
    --parser-code-file "okta_parser.conf" \
    --logs-file "sample_logs.txt" > parser_result.json

# Activate if successful
$ secops parser activate --log-type "OKTA" --id "$PARSER_ID"

Workflow für Suche und Export

Nach Ereignissen suchen und Ergebnisse exportieren:

# Search for failed logins
$ secops search \
    --query "metadata.event_type = \"USER_LOGIN\" AND security_result.action = \"BLOCK\"" \
    --fields "metadata.event_timestamp,principal.user.userid,principal.ip" \
    --time-window 24 \
    --csv > failed_logins.csv

# Get entity details for suspicious IPs
cat failed_logins.csv | awk -F',' '{print $3}' | sort -u | while read ip; do
    secops entity --value "$ip" --time-window 72
done

Regel testen und bereitstellen

Erkennungsregel erstellen, testen und bereitstellen:

# Create rule file
cat > suspicious_activity.yaral << 'EOF'
rule suspicious_powershell {
    meta:
        description = "Detects suspicious PowerShell activity"
        severity = "Medium"
    events:
        $e.metadata.event_type = "PROCESS_LAUNCH"
        $e.principal.process.file.full_path = /powershell\.exe/i nocase
        $e.principal.process.command_line = /download|invoke-expression|hidden/i nocase
    condition:
        $e
}
EOF

# Validate rule
$ secops rule validate --file suspicious_activity.yaral

# Test against historical data
$ secops rule test --file suspicious_activity.yaral --time-window 168

# Create and enable if tests pass
$ secops rule create --file suspicious_activity.yaral
$ secops rule enable --id "ru_generated_id" --enabled true

Fehlerbehebung

Allgemeine Probleme

Authentifizierungsfehler

Wenn Authentifizierungsfehler auftreten, können Sie Folgendes versuchen:

  1. Anmeldedaten überprüfen
  2. Prüfen, ob Ihr Dienstkonto die erforderlichen Berechtigungen hat
  3. Prüfen Sie, ob ADC richtig konfiguriert ist: gcloud auth application-default login

Regionsfehler

Wenn Sie regionale Fehler erhalten:

  1. Prüfen, ob die Region unterstützt wird
  2. Prüfen, ob sich Ihre Instanz in der angegebenen Region befindet
  3. --region-Flag verwenden oder in der Konfiguration festlegen

Ratenbegrenzung

Bei Problemen mit der Ratenbegrenzung:

  1. Häufigkeit von API-Aufrufen verringern
  2. Paginierung für große Ergebnismengen verwenden
  3. Exponentiellen Backoff für Wiederholungen implementieren

Hilfe

Hilfe zu einem beliebigen Befehl aufrufen:

$ secops --help
$ secops search --help
$ secops rule create --help

Migration von chronicle_cli

Wenn Sie von der alten chronicle_cli migrieren, finden Sie hier eine Zuordnung der gängigen Befehle:

chronicle_cli SecOps
chronicle_cli feeds create secops feed create
chronicle_cli feeds list secops feed list
chronicle_cli feeds update secops feed update
chronicle_cli feeds delete secops feed delete
chronicle_cli parsers list secops parser list
chronicle_cli parsers create secops parser create
chronicle_cli parsers activate secops parser activate
chronicle_cli forwarders create secops forwarder create
chronicle_cli forwarders list secops forwarder list

Die neue secops-Befehlszeile bietet viele zusätzliche Funktionen, die in chronicle_cli nicht verfügbar sind, darunter:

  • Suche in natürlicher Sprache
  • Gemini AI-Integration
  • Dashboard-Verwaltung
  • Regeltests und ‑validierung
  • Datentabellen und Referenzlisten
  • Fallverwaltung
  • Und vieles mehr

Zusätzliche Ressourcen