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

Guide de l'utilisateur de la CLI Google SecOps

Compatible avec :

Google SecOps SIEM

Le SDK Google Security Operations fournit une interface de ligne de commande (CLI) complète qui facilite l'interaction avec les produits Google SecOps depuis votre terminal. La nouvelle CLI secops remplace l'ancienne chronicle_cli. Elle offre des fonctionnalités améliorées et une meilleure expérience utilisateur.

Présentation

La CLI secops permet d'accéder aux éléments suivants :

Rechercher et analyser les événements UDM
Gérer les flux, les transitaires et les analyseurs
Créer et gérer des règles de détection
Gérer les alertes et les demandes
Gérer les listes de référence et les tableaux de données
Exporter des données vers BigQuery et Google Cloud Storage
Demander à Gemini AI des insights sur la sécurité
Et bien plus

Les commandes Google SecOps CLI utilisent la syntaxe suivante :

$ secops COMMAND [SUBCOMMAND] [OPTIONS]

Par exemple, pour rechercher des événements :

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

Avant de commencer

Avant d'installer la Google SecOps CLI, assurez-vous de disposer des éléments suivants :

Python 3.8 ou version ultérieure installé dans votre environnement. Pour en savoir plus, consultez Installer Python.
Une instance Google SecOps disposant des autorisations d'accès appropriées.
Identifiants d'authentification (compte de service ou Identifiants par défaut de l'application).

Installation

Installez le SDK SecOps, qui inclut la CLI :

pip install secops

Vérifiez l'installation :

$ secops --help

Authentification

L'interface de ligne de commande est compatible avec plusieurs méthodes d'authentification :

Utiliser les identifiants par défaut de l'application (recommandé)

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

Utiliser un compte de service

Placez le fichier JSON de votre compte de service dans un emplacement sécurisé et faites-y référence dans les commandes :

$ 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\""

Configuration

Enregistrez les paramètres courants pour éviter de les répéter dans les commandes :

Enregistrer la configuration

# 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

Afficher la configuration

$ secops config view

Effacer la configuration

$ secops config clear

Régions

La CLI est compatible avec toutes les régions Google SecOps. Vous pouvez définir la région à l'aide des éléments suivants :

L'option --region avec n'importe quelle commande
Le fichier de configuration à l'aide de secops config set --region REGION

Voici quelques-unes des régions acceptées : * US (par défaut) * EUROPE * ASIA-SOUTHEAST1 * ASIA-SOUTH1 * AUSTRALIA-SOUTHEAST1 * EUROPE-WEST2, EUROPE-WEST3, EUROPE-WEST6, EUROPE-WEST9, EUROPE-WEST12 * et plus encore

Commandes principales

Événements de recherche

Recherchez des événements UDM à l'aide de la syntaxe de requête :

# 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

Informations sur l'entité

Obtenez des informations détaillées sur les adresses IP, les domaines ou les hachages de fichiers :

$ 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

Statistiques

Exécutez des analyses statistiques sur vos données :

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

Gestion des flux

Gérer les flux d'ingestion de données dans Google SecOps :

Lister les flux

$ secops feed list

Créer un flux

# 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"}}'

Mettre à jour le flux

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

Activer/Désactiver le flux

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

Supprimer le flux

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

Gestion des analyseurs

Les analyseurs traitent et normalisent les données de journaux brutes au format UDM :

Lister les analyseurs

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

Obtenir les détails de l'analyseur

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

Créer un analyseur

# 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\" } } }"

Test de l'analyseur

Testez un analyseur par rapport à des exemples de journaux avant le déploiement :

# 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"

Activer/Désactiver l'analyseur

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

Supprimer l'analyseur

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

Gestion des extensions d'analyseur

Les extensions d'analyseur étendent les analyseurs existants sans les remplacer :

Lister les extensions

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

Créer une extension

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

Activer l'extension

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

Gestion des redirecteurs

Les transférateurs permettent d'ingérer des journaux avec des configurations spécifiques :

Créer un redirecteur

# 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"}'

Lister les redirecteurs

$ secops forwarder list --page-size 100

Obtenir le redirecteur

$ secops forwarder get --id "1234567890"

Mettre à jour un redirecteur

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

Supprimer le redirecteur

$ secops forwarder delete --id "1234567890"

Ingestion de journaux

Ingérer les journaux dans Google SecOps :

Ingérer des journaux bruts

# 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\"}"

Ingérer des événements UDM

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

Lister les types de journaux

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

Générer un mappage UDM

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

Gestion des règles

Gérer les règles de détection :

Règles de la liste

$ secops rule list --page-size 50

Créer une règle

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

Mettre à jour la règle

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

Activer/Désactiver une règle

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

Tester la règle

Testez une règle par rapport aux données de l'historique :

# 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

Valider la règle

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

Supprimer la règle

$ secops rule delete --id "ru_12345"

Gestion des alertes

Recevoir et gérer les alertes :

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

Gestion des demandes

Récupérez les détails de la demande :

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

Tables de données

Les tables de données sont des collections de données structurées à utiliser dans les règles de détection :

Créer une table de données

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

Ajouter des lignes

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

Lister les lignes

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

Supprimer la table de données

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

Listes de référence

Les listes de référence sont des listes de valeurs simples pour les règles de détection :

Créer une liste de références

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

Mettre à jour la liste de références

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

Lister les listes de référence

$ secops reference-list list

Exportation de données

Exporter des données pour analyse :

Créer une exportation

# 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

Vérifier l'état de l'exportation

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

Annuler l'exportation

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

Lister les types de journaux disponibles pour l'exportation

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

Intégration de Gemini AI

Interrogez Gemini AI pour obtenir des insights sur la sécurité :

# 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"

Activer Gemini :

$ secops gemini --opt-in

Gestion des tableaux de bord

Gérer les tableaux de bord natifs :

Créer un tableau de bord

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

Lister les tableaux de bord

$ secops dashboard list --page-size 10

Mettre à jour le tableau de bord

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

Exporter/Importer un tableau de bord

# 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

Ajouter un graphique au tableau de bord

$ 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}'

Supprimer le tableau de bord

$ secops dashboard delete --id dashboard-id

Exemples avancés

Workflow complet de l'analyseur

Récupérer, tester et déployer un analyseur :

# 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 de recherche et d'exportation

Rechercher des événements et exporter les résultats :

# 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

Tester et déployer des règles

Créez, testez et déployez une règle de détection :

# 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

Dépannage

Problèmes courants

Erreurs d'authentification

Si vous rencontrez des erreurs d'authentification :

Vérifier la validité de vos identifiants
Vérifiez que votre compte de service dispose des autorisations nécessaires.
Assurez-vous que l'ADC est correctement configuré : gcloud auth application-default login

Erreurs liées à la région

Si vous obtenez des erreurs liées à la région :

Vérifiez que la région est acceptée.
Vérifiez que votre instance se trouve dans la région spécifiée.
Utiliser l'option --region ou la définir dans la configuration

Limiter le débit

Pour les problèmes de limitation du débit :

Réduire la fréquence des appels d'API
Utiliser la pagination pour les grands ensembles de résultats
Mettre en œuvre un intervalle exponentiel entre les tentatives

Obtenir de l'aide

Affichez l'aide pour n'importe quelle commande :

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

Migration depuis chronicle_cli

Si vous migrez depuis l'ancienne chronicle_cli, voici un mappage des commandes courantes :

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`

La nouvelle CLI secops offre de nombreuses fonctionnalités supplémentaires qui ne sont pas disponibles dans chronicle_cli, y compris :

Recherche en langage naturel
Intégration de Gemini AI
Gestion des tableaux de bord
Tests et validation des règles
Tableaux de données et listes de référence
Gestion des demandes
Et bien plus