Se usó la API de Cloud Translation para traducir esta página.

Guía del usuario de la CLI de Google SecOps

Compatible con:

Google SecOps SIEM

El SDK de Google Security Operations proporciona una interfaz de línea de comandos (CLI) integral que facilita la interacción con los productos de Google SecOps desde tu terminal. La nueva CLI de secops reemplaza la CLI heredada de chronicle_cli con una funcionalidad mejorada y una experiencia del usuario optimizada.

Descripción general

La CLI de secops proporciona acceso a lo siguiente:

Cómo buscar y analizar eventos de UDM
Administra feeds, reenviadores y analizadores
Crea y administra reglas de detección
Cómo controlar alertas y casos
Administra listas de referencia y tablas de datos
Exporta datos a BigQuery y Google Cloud Storage
Consulta a la IA de Gemini para obtener estadísticas de seguridad
Y mucho más

Los comandos de la CLI de SecOps de Google usan la siguiente sintaxis:

$ secops COMMAND [SUBCOMMAND] [OPTIONS]

Por ejemplo, para buscar eventos, haz lo siguiente:

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

Antes de comenzar

Antes de instalar la CLI de Google SecOps, asegúrate de tener lo siguiente:

Python 3.8 o una versión posterior instalado en tu entorno Para obtener más información, consulta Cómo instalar Python.
Una instancia de Google SecOps con los permisos de acceso adecuados
Credenciales de autenticación (cuenta de servicio o credenciales predeterminadas de la aplicación)

Instalación

Instala el SDK de SecOps, que incluye la CLI:

pip install secops

Verifica la instalación:

$ secops --help

Autenticación

La CLI admite varios métodos de autenticación:

Usa las credenciales predeterminadas de la aplicación (recomendado)

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

Usa la cuenta de servicio

Coloca el archivo JSON de tu cuenta de servicio en una ubicación segura y haz referencia a él en los comandos:

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

Configuración

Guarda la configuración común para evitar repeticiones en los comandos:

Guardar configuración

# 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

Ver configuración

$ secops config view

Borrar configuración

$ secops config clear

Regiones

La CLI admite todas las regiones de SecOps de Google. Puedes establecer la región con las siguientes opciones:

La marca --region con cualquier comando
El archivo de configuración con secops config set --region REGION

Las regiones admitidas incluyen las siguientes: * US (predeterminada) * EUROPE * ASIA-SOUTHEAST1 * ASIA-SOUTH1 * AUSTRALIA-SOUTHEAST1 * EUROPE-WEST2, EUROPE-WEST3, EUROPE-WEST6, EUROPE-WEST9, EUROPE-WEST12 * Y muchas más

Comandos principales

Eventos de búsqueda

Busca eventos de UDM con la sintaxis de consulta:

# 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

Información de la entidad

Obtén información detallada sobre IPs, dominios o hashes de archivos:

$ 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

Estadísticas

Ejecuta análisis estadísticos en tus datos:

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

Administración de feeds

Administra los feeds de transferencia de datos en Google SecOps:

Enumera feeds

$ secops feed list

Crear feeds

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

Actualizar feeds

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

Habilitar o inhabilitar el feed

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

Borrar feed

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

Administración de analizadores

Los analizadores procesan y normalizan los datos de registro sin procesar en formato UDM:

Enumera los analizadores

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

Obtén detalles del analizador

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

Crear analizador

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

Analizador de prueba

Prueba un analizador en registros de muestra antes de la implementación:

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

Activar o desactivar el analizador

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

Borrar analizador

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

Administración de extensiones del analizador

Las extensiones del analizador amplían los analizadores existentes sin reemplazarlos:

Haz una lista de extensiones

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

Crear extensión

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

Activa la extensión

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

Administración de empresas de transporte

Los reenvíadores se usan para transferir registros con configuraciones específicas:

Crea un reenvío

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

Enumera los servidores de reenvío

$ secops forwarder list --page-size 100

Obtener reenviador

$ secops forwarder get --id "1234567890"

Actualizar reenviador

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

Borrar el reenviador

$ secops forwarder delete --id "1234567890"

Recepción de registros

Transfiere registros a Google SecOps:

Transfiere registros sin procesar

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

Transfiere eventos de UDM

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

Enumera los tipos de registros

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

Genera la asignación de UDM

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

Administración de reglas

Administra las reglas de detección:

Reglas de la lista

$ secops rule list --page-size 50

Crear regla

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

Actualizar regla

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

Habilitar o inhabilitar la regla

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

Probar regla

Para probar una regla en relación con los datos históricos, sigue estos pasos:

# 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

Validar regla

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

Borrar regla

$ secops rule delete --id "ru_12345"

Administración de alertas

Recibe y administra alertas:

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

Administración de casos

Recupera los detalles del caso:

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

Tablas de datos

Las tablas de datos son colecciones de datos estructurados que se usan en las reglas de detección:

Crear tabla de datos

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

Agregar filas

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

Enumera filas

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

Borrar tabla de datos

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

Listas de referencia

Las listas de referencia son listas de valores simples para las reglas de detección:

Crea una lista de referencias

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

Actualiza la lista de referencias

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

Enumera las listas de referencia

$ secops reference-list list

Exportación de datos

Sigue estos pasos para exportar datos para el análisis:

Crear exportación

# 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

Verificar el estado de exportación

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

Cancelar exportación

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

Enumera los tipos de registros disponibles para la exportación

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

Integración de la IA de Gemini

Consulta a la IA de Gemini para obtener estadísticas de seguridad:

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

Habilita Gemini:

$ secops gemini --opt-in

Administración de paneles

Administra paneles nativos:

Crear panel

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

Enumera los paneles

$ secops dashboard list --page-size 10

Actualizar panel

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

Panel de exportación/importación

# 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

Agregar gráfico al panel

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

Borrar panel

$ secops dashboard delete --id dashboard-id

Ejemplos avanzados

Flujo de trabajo de Complete Parser

Recupera, prueba e implementa un analizador:

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

Flujo de trabajo de búsqueda y exportación

Busca eventos y exporta los resultados:

# 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

Pruebas e Deployment de reglas

Crea, prueba e implementa una regla de detección:

# 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

Soluciona problemas

Problemas comunes

Errores de autenticación

Si encuentras errores de autenticación, haz lo siguiente:

Verifica que tus credenciales sean válidas
Verifica que tu cuenta de servicio tenga los permisos necesarios
Asegúrate de que ADC esté configurado correctamente: gcloud auth application-default login

Errores de región

Si recibes errores relacionados con la región, haz lo siguiente:

Verifica que la región sea compatible
Verifica que tu instancia esté en la región especificada
Usa la marca --region o configúrala

Límite de frecuencia

Si tienes problemas con el límite de frecuencia, haz lo siguiente:

Reduce la frecuencia de las llamadas a la API
Usa la paginación para conjuntos de resultados grandes
Implementa la retirada exponencial para los reintentos

Obtener ayuda

Para ver la ayuda de cualquier comando, haz lo siguiente:

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

Migración desde chronicle_cli

Si migras desde el chronicle_cli heredado, aquí tienes un mapeo de los comandos comunes:

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 nueva CLI de secops ofrece muchas funciones adicionales que no están disponibles en chronicle_cli, incluidas las siguientes:

Búsqueda en lenguaje natural
Integración de la IA de Gemini
Administración de paneles
Pruebas y validación de reglas
Tablas de datos y listas de referencia
Administración de casos
Y mucho más