Transición de SPL a YARA-L 2.0

Se admite en los siguientes sistemas operativos:

Google SecOps SIEM

Esta guía está dirigida a los usuarios que ya conocen el lenguaje de procesamiento de búsquedas (SPL) de Splunk. Proporciona una introducción rápida a YARA-L 2.0, el lenguaje principal para crear búsquedas, paneles y reglas de detección en Google Security Operations.

Comprende la estructura de YARA-L 2.0

YARA-L 2.0 es el lenguaje de consultas unificado que se usa en Google SecOps para realizar búsquedas de amenazas potentes, crear paneles en tiempo real y generar reglas de detección de alta fidelidad en todos los datos de registro de tu empresa a medida que se transfieren.

El lenguaje funciona en conjunto con el motor de detección de Google SecOps y te permite buscar amenazas y otros eventos en grandes volúmenes de datos.

Diferencias básicas de estructura entre SPL y YARA-L

SPL usa una serie de comandos encadenados con caracteres de barra vertical (|), mientras que YARA-L se basa en secciones. Defines una búsqueda con secciones distintas, como events, outcome y condition, para describir un patrón que deseas buscar, detectar o visualizar.

En la siguiente tabla, se compara la estructura básica entre SPL y YARA-L:

Función	SPL (procedural)	YARA-L (declarativa)
Concepto principal	Transforma un flujo de datos paso a paso con una canalización de comandos.	Analiza y aplica una estructura multipartita de condiciones y transformaciones a un flujo de datos operativos y de seguridad, identifica amenazas y extrae estadísticas valiosas.
Flujo de datos	Procedimental Los resultados de un comando se canalizan como entrada para el siguiente.	Estructura declarativa para procesar y correlacionar patrones de manera óptima a gran escala. Elimina la necesidad de pensar en la eficiencia.
Correlación de eventos	Se basa en comandos explícitos como join, transaction y stats.	Se compila definiendo varios eventos y correlacionándolos en función de un campo común dentro de la lógica de la consulta.
Intervalos	Se maneja como una ventana de búsqueda estática (por ejemplo, last 60m). Cada búsqueda nueva es una solicitud nueva.	Se controla como un período continuo y deslizante definido dentro de la consulta (por ejemplo, over 5m).
Sintaxis	Controlado por comandos (por ejemplo, index=web)	Concisa y basada en la lógica (por ejemplo, metadata.event_type= "USER_LOGIN")

Estructura específica de las consultas

YARA-L aplica una estructura específica para las consultas, que es diferente de los comandos secuenciales canalizados de SPL. Si bien SPL genera resultados encadenando comandos, YARA-L define diferentes aspectos de la búsqueda en secciones distintas.

Comando	Acción	Obligatorio | Opcional
meta	Establece metadatos descriptivos para la regla, como el autor, la descripción y la gravedad.	Solo es obligatorio para las reglas.
events	Define y filtra eventos.	Obligatorio (lógica principal de la búsqueda).
match	Agrupa por eventos y te permite especificar el período (por ejemplo, by 5m).	Es opcional. Solo se requiere para las consultas de correlación de varios eventos.
outcome	Calcula métricas clave y obtiene estadísticas.	Es opcional.
condition	Evalúa los criterios de la variable de búsqueda para determinar si se aplica un resultado (por ejemplo, #event >5).	Solo es obligatorio para las reglas. Es opcional en la búsqueda y los paneles.
dedup	Quita los eventos duplicados agrupándolos según variables clave (por ejemplo, target.user.userid, target.ip>, principal.hostname).	Es opcional.
order	Ordena los resultados de los eventos recopilados definidos por campos específicos (por ejemplo, asc).	Es opcional.
limit	Restringe la cantidad máxima de eventos que se devuelven de la búsqueda.	Es opcional.

Comandos comunes en SPL y YARA-L

La estructura de la sección de YARA-L te permite usar los mismos comandos comunes que se encuentran en SP. En esta sección, se describen las similitudes y diferencias.

Comando SPL search = Sección YARA-L events

El comando search en SPL equivale a la sección events en YARA-L. La sección events define los eventos y cómo se filtran inicialmente. Si bien otras secciones (como match o outcome) son opcionales, la sección events es fundamental para cada regla.

Nota: No es necesario que declares "events:" en las búsquedas y los paneles, pero el encabezado de la sección es obligatorio en las reglas.

Por ejemplo:

metadata.event_type = "USER_LOGIN"

o:

principal.hostname != "" AND metadata.event_type = "NETWORK_CONNECTION"

En la sección events de las reglas (y las búsquedas avanzadas), usas variables de evento para simplificar tu lógica.

Una variable de evento actúa como una agrupación lógica de filtros y representa un evento específico o un grupo de eventos que coinciden con ciertos criterios.

Por ejemplo, para definir una variable de evento, como $e, úsala como prefijo de todos los eventos y filtros relacionados en la sección events de tu consulta. Luego, puedes usar esa variable en otras secciones de la consulta (como match o outcome) para hacer referencia a ese grupo específico de eventos y sus campos de datos.

Las variables de eventos se suelen aplicar en las reglas de detección. En el siguiente ejemplo, se muestra cómo usar la variable de evento ($e) en una regla para agrupar eventos y encontrar la cantidad de accesos fallidos de un usuario en un día. Luego, la regla se activa si supera un umbral definido.

En el ejemplo de regla, cada evento se define con la variable de evento ($e). También se hace referencia a la variable $e en metadata.id para vincular los metadatos de la regla a los eventos definidos.

rule DailyFailedLoginAttempts {
 meta:
   author = "Alex"
   description = "Detects a high number of failed login attempts for a single user within a day."

events:
   // Alias for each event
   $e.metadata.event_type = "USER_LOGIN"
   $e.security_result.action = "FAIL"
   $e.principal.user.userid != ""
   $userid = $e.principal.user.userid

match:
   // Group events by principal.user.userid within a 24-hour window
   $userid over 1d

outcome:
   // Count the number of unique event IDs for each user per day
   $daily_failed_login_count = count($e.metadata.id)

condition:
   // Trigger a detection if the daily failed login count exceeds a threshold
   // You should adjust this threshold based on your environment's baseline.
   #e > 0
}

Para asegurarte de que se active la regla, a menudo debes verificar el recuento de los eventos agrupados. Puedes especificar un recuento mínimo en la sección condition con la variable de evento. Por ejemplo, la condición (#e > 0) verifica que exista al menos un evento que coincida con los criterios.

Comando SPL eval = Sección YARA-L outcome

El comando eval es una función fundamental del SPL que se usa para manipular y definir valores de campos en los resultados de la búsqueda.

• Propósito: Calcula y define nuevos valores de campo.
• Funcionalidad: Evalúa expresiones matemáticas, de cadena o booleanas.
• Resultado: El resultado de la evaluación crea un campo nuevo o reemplaza el valor de un campo existente.
• Encadenamiento: Se pueden encadenar varias expresiones con una coma (por ejemplo, | eval A=1, B=A+1).
• Procesamiento secuencial: Las expresiones de una cadena se procesan de forma secuencial, lo que permite que los cálculos posteriores hagan referencia a los campos creados o modificados por expresiones anteriores y se basen en ellos.

Nota: En YARA-L, esta funcionalidad se controla principalmente con la sección outcome, en la que puedes definir y calcular variables con funciones similares.

En los ejemplos de la siguiente tabla (y después), se explica la estructura de este comando:

Función	Descripción	Ejemplo de YARA-L
Operadores booleanos	Se usa en events y condition. Consulta Usa "o" en la sección de condiciones.	metadata.log_type != "" or metadata.event_type = "NETWORK_DNS"
Campos calculados	Se usa en la sección outcome.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = cast.as_int(network.sent_bytes)
Creación de nombres de campos dinámicos	Se usa en la sección outcome.	Consulta ejemplos en Compara SPL con YARA-L.

Ejemplo: Crea un campo nuevo que contenga el resultado de un cálculo

Con YARA-L, crea un campo nuevo, bytes, en cada evento. Para calcular los bytes, suma los valores de los campos bytes enviados y los campos bytes recibidos.

 metadata.event_type = "SCAN_NETWORK"
 principal.hostname != ""
 $host = principal.hostname

match:
   $host

outcome:
   $bytes = cast.as_int(sum(network.sent_bytes))

Ejemplo: Concatenar valores de dos campos

Usa el carácter de punto (.) para concatenar los valores del campo first_name con los valores del campo last_name. Usa comillas ("") para insertar un carácter de espacio entre los dos campos. Cuando se concatenan, los valores se leen como cadenas, independientemente del valor real.

En SPL, la consulta se vería de la siguiente manera:

| eval full_name = first_name+" "+last_name

En YARA-L, la búsqueda se vería de la siguiente manera:

principal.user.first_name = $first_name
principal.user.last_name = $last_name

outcome:
  $full_name = strings.concat(principal.user.first_name = $first_name
  principal.user.last_name = $last_name

outcome:
   $full_name = strings.concat($first_name, " ", $last_name))

Nota: Además de una búsqueda de stats, en la que puedes usar nombres de campos, en las reglas, debes usar una variable de marcador de posición en la sección match. Para obtener más información, consulta Variables de coincidencia.

Con el ejemplo de consulta de acceso fallido, el siguiente ejemplo te permite encontrar usuarios que tuvieron cinco o más accesos fallidos en un lapso de 10 minutos (10m) entre cada uno (con variables de evento y de marcador de posición):

metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"
target.user.userid = $userid

match:
  $userid by 10m

outcome:
   $login_count= count(metadata.id)

condition:
   $login_count > 5

Comando SPL where = Sección condition de YARA-L

El comando where de SPL equivale a una combinación de las secciones events, outcome o condition en YARA-L. En la sección events, puedes declarar eventos y especificar atributos específicos para ellos (por ejemplo, priniciapal.hostname = "xyz"). Después de declarar tus eventos, puedes usar operadores booleanos, operadores de comparación y resultados de funciones de agregación (de la sección outcome) para definir los parámetros que deben cumplir los eventos para que la búsqueda devuelva un resultado.

En el siguiente ejemplo, se muestra cómo establecer una condición de umbral en un recuento agregado. La consulta está estructurada para contar la cantidad total de eventos de acceso fallido por ID de usuario y, luego, utiliza la sección condition para generar resultados solo para los usuarios que registraron cinco o más accesos fallidos.

metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"

match:
  target.user.userid

outcome:
  // metadata.id counts all unique events associated with failed logins.
  $count = count(metadata.id)
  //metadata.id counts all unique events associated with blocked logins.

condition:
  $count > 5

Comando SPL dedup = Sección YARA-L dedup

El comando SPL dedup equivale a la sección dedup en YARA-L. Usa la sección dedup para anular la duplicación de los resultados duplicados que especifica un evento en la sección events.

Por ejemplo:

principal.hostname = "foo"

dedup:
   target.ip

Comando stats de SPL = sección match o outcome de YARA-L (o ambas)

En SPL, la agregación suele controlarse con la familia de comandos stats, que especifica el tipo de agregación (como count, distinct count, max, min) y el campo "group by".

En YARA-L, las secciones match y outcome proporcionan conjuntamente esta capacidad:

• Lógica de agregación: La sección match crea agregaciones definiendo el grupo de eventos que se deben tener en cuenta (match: $grouping_field by time). Luego, la sección outcome define las funciones de agregación específicas que se deben calcular para ese grupo (por ejemplo, count(), min(), max()).

• Ventanas de tiempo: La sección match admite la especificación de una ventana de tiempo para agrupar eventos. Usa la palabra clave over (para reglas) o by (para búsquedas y paneles) (por ejemplo, match: $userid by 1h). Esta funcionalidad es similar a SPL, como "timechart", "streamstats" y "eventstats". Para obtener más información, consulta Ventanas de tiempo.

Ejemplo: Calcula la suma de bytes agrupados por nombre de host principal y dirección IP de destino

En el siguiente ejemplo, se usa la sección match para definir un grupo de agregación basado en el nombre de host principal y la dirección IP de destino durante un período de un día. Luego, se calcula la suma resultante de los bytes enviados en la sección outcome.

metadata.event_type = "NETWORK_CONNECTION"
network.sent_bytes > 0
principal.hostname != ""
target.ip != ""

// Define placeholder variables for grouping
$principal_hostname = principal.hostname
$target_ip = target.ip

// Group events by principal hostname, target IP, and day
match:
  $principal_hostname, $target_ip by day

// Calculate the sum of sent bytes for each group
outcome:
  $daily_bytes_sent = sum(network.sent_bytes)

Asigna SPL a YARA-L

SPL procesa los datos paso a paso a través de comandos canalizados, mientras que YARA-L usa una estructura declarativa basada en secciones para definir patrones y acciones. A pesar de estas diferencias fundamentales en el enfoque, el poder expresivo de YARA-L te permite realizar muchas de las mismas tareas que sueles hacer en SPL, desde el filtrado básico hasta las agregaciones y correlaciones complejas.

En esta sección, se explican las diferencias a través de la asignación de funciones conocidas de SPL a sus equivalentes dentro del framework de YARA-L.

Comparación de SPL con YARA-L

En esta tabla, se comparan las funciones y los conceptos comunes del lenguaje SPL con sus equivalentes en YARA-L 2.0 o se explica cómo se maneja el concepto dentro de una estructura de consulta de YARA-L.

Comando o concepto de SPL	Objetivo	Equivalente de YARA-L	Descripción y asignación de YARA-L	Ejemplo de implementación de YARA-L
search	Filtrado de datos inicial	Sección events	Define los campos y las condiciones del evento. No se necesita el prefijo events: para las búsquedas ni los paneles. Consulta el ejemplo.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL"
where	Filtrado adicional de los resultados	Secciones events y condition	Aplicar lógica booleana, a menudo en resultados agregados Ver ejemplo.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL" outcome: $failed_count = count(metadata.id) condition: $failed_count > 5
eval	Calcula valores nuevos a partir de campos, agregaciones y búsquedas de datos existentes	Sección outcome o events	Consulta el ejemplo de SPL eval.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
stats	Agregaciones (count, sum, promedio)	match o outcome	Agrupa los campos en match. Calcula los agregados en outcome. Consulta los ejemplos en Agregaciones y consultas estadísticas y comando stats de SPL.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
dedup	Quita los eventos duplicados según uno o más campos	Sección dedup	Especifica los campos en los que se anularán los elementos duplicados.	metadata.event_type = "USER_LOGIN" security_result.action = "FAIL" $user = target.user.userid dedup: $user
table	Define la salida de la columna de la tabla	select o unselect	Se usa en los paneles. En la búsqueda, se muestran las variables outcome.	metadata.event_type = "USER_LOGIN" select: principal.hostname
sort	Enumera los resultados en orden ascendente o descendente.	Sección order	Consulta el ejemplo en la siguiente celda de la tabla.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = uint64(network.sent_bytes) order: $bytes desc
limit	Restringe la cantidad de resultados que se muestran	Sección limit	Consulta el ejemplo en la siguiente celda.	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" outcome: $id = metadata.id $host = principal.hostname $bytes = cast.as_int(network.sent_bytes) order: $bytes desc limit: 3
Funciones de valores múltiples	Se controla con funciones mv* (mvexpand, mvfilter).	Compatibilidad integrada	YARA-L anula automáticamente el anidamiento de los arrays en la sección de eventos. Las funciones de array están disponibles en outcome, si es necesario.	Consulta ejemplos de funciones de varios valores.
Intervalos	earliest=-5m, latest=now	Sección match, over, by	Para las detecciones continuas, usa match: $field over 5m or by 5m. Para los paneles en la IU de búsqueda, usa match: $field by 5m.	Consulta los ejemplos en Ventanas de tiempo.

Consultas estadísticas y de agregación

En YARA-L, las funciones de agregación y estadísticas suelen colocarse en la sección outcome, y la agregación se basa en la sección match.

El comando stats es el mecanismo principal para implementar la agregación de datos en las consultas de YARA-L. Transforma los datos de eventos sin procesar en métricas de seguridad resumidas. Si bien el comando eval controla las transformaciones a nivel del campo, fila por fila (de manera similar a una expresión SELECT), stats realiza una agregación a nivel del conjunto (de manera similar a GROUP BY en SQL).

En la siguiente tabla, se proporciona la sintaxis y el uso principales, y se muestra cómo usar las estadísticas de manera eficaz para implementar una lógica de seguridad sofisticada basada en patrones de datos y valores atípicos estadísticos.

Función SPL	Descripción	Equivalente de YARA-L	Ejemplo de implementación de YARA-L
count	Cuenta la cantidad de eventos.	count()	metadata.event_type= "USER_LOGIN" security_result.action= "FAIL" outcome: $event_count = count(metadata.id) condition: $event_count > 2
dc (count_distinct)	Cuenta la cantidad de valores únicos de un campo.	count_distinct()	metadata.event_type = "USER_LOGIN" outcome: $unique_users=count_distinct(principal.user.userid)
sum	Calcula la suma de los valores de un campo.	sum()	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" $host = principal.hostname match: $host outcome: $bytes = sum(network.sent_bytes)
avg	Calcula el valor promedio de un campo.	avg()	$host = principal.hostname match: $host by day outcome: $avg_bytes_sent = avg(network.sent_bytes)
min/max	Encuentra el valor mínimo o máximo para un campo.	min() o max()	metadata.event_type = "SCAN_NETWORK" principal.hostname != "" $host = principal.hostname match: $host outcome: $bytes = max(network.sent_bytes)- min(network.sent_bytes)
median()	Encuentra el valor de la mediana.	window.median	target.file.mime_type = "PDF" outcome: $median_file_size = window.median(target.file.size, false)
first() and last()	Devuelve valores según el orden de los eventos en los resultados de la búsqueda.	window.first/window.last	metadata.event_type = "NETWORK_CONNECTION" principal.ip != "" match: principal.ip outcome: $event_count = count(metadata.id) $first_seen = window.first(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds)) $last_seen = window.last(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
STDDEV()	Calcula la desviación estándar, que mide la dispersión de un conjunto de datos.	window.stddv	principal.hostname= $host match: $host over 5m outcome: $stddev = window.stddev(network.sent_bytes)

Para obtener más detalles, consulta las funciones adicionales.

Por ejemplo, una consulta de varias etapas puede hacer un seguimiento de varios intentos de acceso fallidos en agregaciones estratificadas. Para obtener más detalles, consulta el ejemplo de agregación en varias etapas y Crea consultas en varias etapas en YARA-L.

Agregación en varias etapas (promedio de datos por hora a semanales)

En este ejemplo de varias etapas, primero se agregan los datos para encontrar los bytes transferidos por host cada hora. Luego, usa esa agregación para calcular el promedio general de esos buckets horarios de los últimos siete días.

stage bytes_per_host {
metadata.event_type = "SCAN_NETWORK"
principal.hostname != ""
$host = principal.hostname

match:
  $host by hour

outcome:
  $bytes = cast.as_int(sum(network.sent_bytes))
}

$host = $bytes_per_host.host

match:
  $host

outcome:
  $hour_buckets = array_distinct(timestamp.get_timestamp($bytes_per_host.window_start))
  $num_hour_buckets = count_distinct($bytes_per_host.window_start)
  $avg_hourly_bytes = avg($bytes_per_host.bytes)

Funciones de varios valores (leer un array)

La sintaxis de YARA-L se diseñó para comprender que un campo puede tener varios valores. Cuando escribes una consulta que incluye un evento con un campo de varios valores en la sección events, el lenguaje verifica automáticamente cada valor del array. No es necesario que uses una función especial para filtrar el array, solo debes indicar la condición que deseas que coincida. Por ejemplo, si el campo principal.ip del evento de registro contiene lo siguiente, el motor de YARA-L verificará automáticamente cada valor del array principal.ip. Si alguno de los valores es "10.1.1.5", se cumple la condición.

["10.1.1.5", "10.2.2.6", "10.3.3.7"]

En la siguiente tabla, se muestra una comparación entre YARA-L y SPL sobre cómo administrar los campos de varios valores en los datos de registro. Los campos de varios valores, como un array de direcciones IP o una lista de grupos de usuarios, son una función común en los registros estructurados.

Función SPL	Purpose	Equivalente de YARA-L	Ejemplo de implementación de YARA-L
mvfilter()	Filtra un campo de varios valores para conservar solo los valores coincidentes.	Cuando se usa en la sección events de una consulta de YARA-L, enumera el campo que debe coincidir. YARA-L verifica automáticamente si algún valor del array de grupos coincide con "`admin`".	principal.user.group_identifiers = "admin"
mvcount()	Cuenta la cantidad de valores en un campo de varios valores.	count() aplicado a un campo en la sección de la consulta outcome No es necesario anular el anidamiento de ningún valor primero.	Consulta el ejemplo Cuenta la cantidad de usuarios que pertenecen al grupo de personal de TI.
mvexpand	Crea un evento nuevo para cada valor en un campo de varios valores.	Maneja campos de varios valores de forma nativa e implícita. El desanidamiento se realiza automáticamente.	Consulta el ejemplo Cuenta la cantidad de usuarios que pertenecen al grupo de personal de TI.
mvjoin	Une todos los valores de un campo de varios valores en una sola cadena para fines de formato de datos.	Los valores se almacenan automáticamente como un array en los resultados. El resultado de YARA-L está estructurado, no es una cadena plana. Muestra el campo como un array si se necesita una mayor manipulación del array. Para obtener más información, usa las funciones de array.

Ejemplo: Cuenta la cantidad de inicios de sesión en admin

En el siguiente ejemplo, la condición $metadata.event_type = "USER_LOGIN" filtra los eventos en los que event_type es "USER_LOGIN":

events:
 metadata.event_type = "USER_LOGIN" // Changed to a more appropriate event type for login
 principal.user.group_identifiers = "admin"

outcome:
 // This counts each unique event ID where the principal user is in the `"admin"` group.
 $admin_login_count = count(metadata.id)

El campo $principal.user.group_identifiers= "admin" es un campo repetido (un array).

• Anidamiento implícito: YARA-L desanida automáticamente este campo de forma interna durante la evaluación de la consulta.
• Verificación de la condición: Un evento satisfará la condición si alguno de los valores dentro del array $principal.user.group_identifiers es igual a "admin".
• No se necesita ningún comando explícito: A diferencia de SPL, no necesitas un comando de anidación específico como mvexpand.

La sección sobre el impacto en la agregación (outcome) significa que la anidación implícita es fundamental en la sección outcome (por ejemplo, outcome: $admin_login_count = count(metadata.id))). Ten en cuenta el siguiente impacto:

• Un solo evento del UDM que contiene varios valores coincidentes en un campo repetido puede generar varias filas internas para la evaluación de consultas.
• Dado que la sección events ya ha desanidado de manera eficaz los eventos según cada valor coincidente en $principal.user.group_identifiers, la agregación count(metadata.id) cuenta cada una de estas instancias desanidadas.

Ejemplo: Cuenta la cantidad de usuarios que pertenecen al grupo de personal de TI

SPL:

index=<your_index_name> user_id="jsmith" 
| where match(memberOf, "Domain Admins|IT Staff|HR") 
| mvexpand memberOf 
| stats count by memberOf 
| mvexpand actions 
| table memberOf, count, actions

YARA-L (búsqueda):

 principal.user.userid = "jsmith"
 additional.fields["memberOf"] = $group
   $group = /Domain Admins|IT Staff|HR/ nocase
 
 match:
   $group by 1h
 
 outcome:
   $group_count = count_distinct(metadata.id)
   $memberOf = array_distinct($group)
   $risk_score = max(50)

Ejemplo: Crea una regla para generar una alerta cuando se encuentre un hash de archivo específico

SPL:

| eval file_hashes="hash12345,hash67890,hashABCDE" 
| makemv delim="," file_hashes 
| mvexpand file_hashes 
| search file_hashes="hash67890" 
| table _time, file_hashes

YARA-L (regla):

    rule specific_file_hash_detected {
    
    meta:
      rule_name = "Specific File Hash Detected"
      description = "Detects events where a specific file hash is present."
      severity = "Medium"
    
    events:
      $e.target.file.sha256 == "hash67890"
    
    outcome:
      $time = array_distinct($e.metadata.event_timestamp)
      $file_hashes = array_distinct($e.target.file.sha256)
    
    condition:
      $e
    }

Intervalos

En YARA-L, el análisis de ventanas temporales es un método para correlacionar eventos durante un período específico y continuo. Cuando se usa en reglas, esta ventana se mueve continuamente con los datos entrantes, lo que proporciona la detección continua en tiempo real de patrones que se desarrollan con el tiempo.

Este proceso es una parte clave del diseño para la detección automatizada y es uno de los beneficios de usar YARA-L. Si especificas el período, tus detecciones y paneles funcionarán continuamente con datos en tiempo real.

Función	SPL	YARA-L
Objetivo principal	Búsqueda estática, análisis ad hoc	Detección continua y correlación automatizada
Funciones principales	earliest, latest, span, transaction	over, by
Ejemplo de 5 minutos	earliest=-5m (búsqueda estática) o transaction maxspan=5m	match: [event] over 5m (detección continua en reglas) o [event] by 5m (búsqueda y paneles)

En los ejemplos de esta sección, se ilustra la diferencia entre una ventana de tiempo continua (con by) y una ventana de tiempo deslizante (con over) en YARA-L.

Período de ventana de saltos (by <time_unit>)

• Concepto: Se usan en la búsqueda de YARA-L. Las ventanas deslizantes crean intervalos de tiempo fijos y no superpuestos de tamaño fijo. El sistema procesa cada evento asignándolo a exactamente un bucket de tiempo específico según su marca de tiempo. Estos intervalos fijos son absolutos y se alinean estrictamente con los marcadores de tiempo estándar, como días, horas o minutos.

• Uso: Se usa comúnmente en las búsquedas y los paneles de Google SecOps para agregar datos en segmentos de tiempo discretos.

Ejemplo: Recuento diario de inicios de sesión exitosos por usuario

Esta búsqueda agrupa los eventos de acceso exitoso por cada usuario único dentro de cada día del calendario. En el siguiente ejemplo, se muestra una ventana deslizante de búsqueda de YARA-L (by day):

events:
  //Filter for successful login events
  metadata.event_type = "USER_LOGIN"
  principal.user.userid != ""

match:
  //Group by each unique user ID, aggregated over a calendar day.
  principal.user.userid by day

outcome:
  //Count how many successful logins occurred for this user on this specific day.
  $daily_success_count = count(metadata.id)
  
  //Get the timestamp of the FIRST event within this daily group.
  $first_event_time = window.first(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
  
  //Get the timestamp of the LAST event within this daily group.
  $last_event_time = window.last(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))

Cómo funciona: Si el usuario jdoe tiene 10 accesos exitosos en Nov 17 y 15 en Nov 18, esta consulta genera dos filas separadas para jdoe, una para cada día, con los recuentos respectivos. El bucket Nov 17 incluye eventos de 2025-11-17 00:00:00 to 23:59:59 UTC.

Período variable (over <duration>)

• Concepto: Se usan en las reglas de YARA-L. Los períodos deslizantes son períodos que se mueven y que pueden superponerse con una duración especificada. Son ideales para correlacionar eventos que ocurren cerca unos de otros.

• Uso: Se usa principalmente en las reglas de YARA-L para detectar patrones o secuencias de eventos dentro de un período continuo.

Ejemplo: Detecta varios intentos de acceso fallidos en un plazo de 5 minutos

En este ejemplo de regla de YARA-L, se genera una detección si un solo usuario tiene más de 5 failed logins intentos en cualquier período continuo de 5-minute:

rule TooManyFailedLogins_SlidingWindow {
 meta:
   author = "Alex"
   description = "Detects when a user has more than 5 failed logins within a 5-minute sliding window."
   severity = "Medium"

events:
   // Define an event variable $e for failed login attempts
   $e.metadata.event_type = "USER_LOGIN"
   $e.security_result.action = "FAIL"
   $e.principal.user.userid != ""
   $userid = $e.principal.user.userid

match:
   // Group events by userid over a continuous 5-minute sliding window.
   // Any events for the same $userid within 5 minutes of each other are grouped.
   $userid over 5m

outcome:
   // Count the number of failed login events within each 5-minute window for the grouped userid.
   $failed_count = count($e.metadata.id)

condition:
   // Trigger a detection if the count of failed logins in ANY 5-minute window is greater than 5.
   #e > 5
}

Cómo funciona: El sistema supervisa continuamente los intentos de acceso fallidos. En cualquier momento, considera los últimos 5 minutos de eventos para cada usuario. Por ejemplo, si entre 10:02:30 y 10:07:30, el usuario jdoe acumula seis intentos de acceso fallidos, se activa una detección. Este período se desplaza constantemente hacia adelante, lo que permite la detección de patrones en tiempo real, independientemente de los límites del calendario.

¿Qué sigue?

• Obtén más información en la Descripción general de YARA-L 2.0
• Explora la sintaxis completa del lenguaje YARA-L 2.0
• Obtén información para escribir reglas de Detection Engine
• Novedades en los blogs de Google SecOps

¿Necesitas más ayuda? Obtén respuestas de miembros de la comunidad y profesionales de Google SecOps.