Cambiar de SPL a YARA-L 2.0

Disponible en:

SecOps de Google SIEM

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

Información sobre la estructura de YARA-L 2.0

YARA-L 2.0 es el lenguaje de consulta unificado que se usa en Google SecOps para buscar amenazas de forma eficaz, crear paneles de control en tiempo real y crear reglas de detección de alta fidelidad en todos tus datos de registro empresariales a medida que se ingieren.

Este lenguaje funciona junto 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 en la 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. Para definir una consulta, se usan secciones distintas, como events, outcome y condition, para describir el patrón que quieres buscar, detectar o visualizar.

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

Función	SPL (procedimental)	YARA-L (declarativo)
Concepto principal	Transforma un flujo de datos paso a paso mediante una canalización de comandos.	Analiza y aplica una estructura de varias partes de condiciones y transformaciones a un flujo de datos operativos y de seguridad, identifica amenazas y extrae información valiosa.
Flujo de datos	Procedimental. Los resultados de un comando se canalizan como entrada al siguiente.	Estructura declarativa para procesar y correlacionar patrones de forma óptima a gran escala. No tendrás que preocuparte por la eficiencia.
Correlación de eventos	Depende de comandos explícitos como join, transaction y stats.	Se crea definiendo varios eventos y correlacionándolos en función de un campo común en la lógica de la consulta.
Ventanas de tiempo	Se gestiona como una ventana de búsqueda estática (por ejemplo, last 60m). Cada nueva búsqueda es una solicitud nueva.	Se trata de un periodo continuo que se define en la consulta (por ejemplo, over 5m).
Sintaxis	Controlado por comandos (por ejemplo, index=web).	Conciso y lógico (por ejemplo, metadata.event_type= "USER_LOGIN").

Estructura específica de las consultas

YARA-L aplica una estructura específica a las consultas, que es diferente de los comandos secuenciales y encadenados de SPL. Mientras que SPL genera resultados encadenando comandos, YARA-L define diferentes aspectos de la consulta en secciones distintas.

Comando	Acción	Obligatorio | Opcional
meta	Define metadatos descriptivos de 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 consulta).
match	Agrupa por eventos y te permite especificar el periodo (por ejemplo, by 5m).	Opcional. Solo es obligatorio en las consultas de correlación de varios eventos.
outcome	Calcula métricas clave y obtiene estadísticas.	Opcional.
condition	Evalúa los criterios de la variable de consulta para determinar si se aplica un resultado (por ejemplo, #event >5).	Solo es obligatorio para las reglas. Opcional en búsquedas y paneles de control.
dedup	Elimina los eventos duplicados agrupándolos en función de variables clave (por ejemplo, target.user.userid, target.ip> y principal.hostname).	Opcional.
order	Ordena los resultados de los eventos recogidos definidos por campos específicos (por ejemplo, asc).	Opcional.
limit	Restringe el número máximo de eventos devueltos de la consulta.	Opcional.

Comandos habituales en SPL y YARA-L

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

Comando SPL search = sección events de YARA-L

El comando search de SPL equivale a la sección events de YARA-L. La sección events define los eventos y cómo se filtran inicialmente. Aunque otras secciones (como match o outcome) son opcionales, la sección events es fundamental para todas las reglas.

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

Por ejemplo:

metadata.event_type = "USER_LOGIN"

También puedes hacerlo de esta otra forma, si lo prefieres:

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

En la sección events de las reglas (y las consultas avanzadas), puedes usar variables de evento para simplificar la lógica.

Una variable de evento actúa como un grupo lógico de filtros que representa un evento específico o un grupo de eventos que cumplen determinados criterios.

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

La aplicación más habitual de las variables de evento es 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 el número de inicios de sesión fallidos de un usuario en un día. La regla se activa si supera un umbral definido.

En el ejemplo de regla, cada evento se define con la variable de evento ($e). La variable $e también se menciona en metadata.id para vincular los metadatos de la regla con 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 asegurarse de que se activa la regla, a menudo debe comprobar el recuento de los eventos agrupados. Puede especificar un recuento mínimo en la sección condition mediante la variable de evento. Por ejemplo, la condición (#e > 0) comprueba que exista al menos un evento que cumpla los criterios.

Comando SPL eval = sección outcome de YARA-L

El comando eval es una función fundamental de SPL que se usa para manipular y definir valores de campo en los resultados de 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 o sobrescribe el valor de un campo.
• Encadenamiento: se pueden encadenar varias expresiones mediante 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 función se gestiona principalmente en la sección outcome, donde puedes definir y calcular variables con funciones similares.

En los ejemplos de la siguiente tabla (y en los posteriores) se explica esta estructura de comandos:

Función	Descripción	Ejemplo de YARA-L
Operadores booleanos	Se usa en events y condition. Consulta Usar "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 Comparación entre SPL y YARA-L.

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

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

 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 espacio entre los dos campos. Al concatenar, los valores se leen como cadenas, independientemente del valor real.

En SPL, la consulta tendría un aspecto similar a este:

| eval full_name = first_name+" "+last_name

En YARA-L, la consulta de búsqueda tendría un aspecto similar a este:

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 la búsqueda stats, en la que puedes usar nombres de campo, en las reglas debes usar una variable de marcador de posición en la sección match. Para obtener más información, consulta el artículo Variables de coincidencia.

Siguiendo el ejemplo de la consulta de inicios de sesión fallidos, en el siguiente ejemplo se muestra cómo encontrar a los usuarios que han tenido cinco o más inicios de sesión fallidos en un intervalo de 10 minutos (10m) (se usan tanto variables de evento como 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 SPL where equivale a una combinación de las secciones events, outcome o condition de YARA-L. En la sección events, puede declarar eventos y especificar atributos concretos para ellos (por ejemplo, priniciapal.hostname = "xyz"). Después de declarar los eventos, puede 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 consulta devuelva un resultado.

En el siguiente ejemplo se muestra cómo definir una condición de umbral en un recuento agregado. La consulta se estructura para contar el número total de eventos de inicio de sesión fallidos por ID de usuario y, a continuación, usa la sección condition para mostrar los resultados solo de los usuarios que hayan registrado cinco o más inicios de sesión 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 dedup de YARA-L

El comando SPL dedup es equivalente a la sección dedup de YARA-L. Usa la sección dedup para eliminar los resultados duplicados especificados por un evento en la sección events.

Por ejemplo:

principal.hostname = "foo"

dedup:
   target.ip

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

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

En YARA-L, las secciones match y outcome proporcionan conjuntamente esta función:

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

• Ventanas de tiempo: la sección match permite especificar un periodo para agrupar eventos. Usa la palabra clave over (para las reglas) o by (para las búsquedas y los paneles de control) (por ejemplo, match: $userid by 1h). Esta función 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 e IP de destino

En el ejemplo siguiente 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 en un periodo de un día. La suma resultante de los bytes enviados se calcula 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)

Asignación de SPL a YARA-L

SPL procesa los datos paso a paso mediante comandos encadenados, 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, la capacidad expresiva de YARA-L te permite realizar muchas de las mismas tareas que haces en SPL, desde filtrados básicos hasta agregaciones y correlaciones complejas.

En esta sección se explican las diferencias asignando las funciones de SPL que ya conoces a sus equivalentes en el framework de YARA-L.

Comparar SPL con YARA-L

En esta tabla se comparan funciones y conceptos habituales del lenguaje SPL con sus equivalentes en YARA-L 2.0 o se explica cómo se gestiona el concepto en una estructura de consulta de YARA-L.

Comando o concepto de SPL	Finalidad	Equivalente de YARA-L	Descripción y asignación de YARA-L	Ejemplo de implementación de YARA-L
search	Filtrado de datos inicial	events sección	Define los campos y las condiciones del evento. No es necesario usar el prefijo events: para las búsquedas ni los paneles de control. Consulta un ejemplo.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL"
where	Filtrar aún más los resultados	Secciones events y condition	Aplica la lógica booleana, a menudo en resultados agregados. Consulta un ejemplo.	events: metadata.event_type = "USER_LOGIN" security_result.action = "FAIL" outcome: $failed_count = count(metadata.id) condition: $failed_count > 5
eval	Calcula nuevos valores a partir de campos, agregaciones y búsquedas de datos.	outcome o events	Consulta el ejemplo de SPL eval.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
stats	Agregaciones (count, sum, media)	match o outcome	Agrupar por campos de match. Calcula agregaciones en outcome. Consulta ejemplos en Agregaciones y consultas estadísticas y en el comando SPL stats.	metadata.event_type = "USER_LOGIN" outcome: $login_count = count(metadata.id)
dedup	Elimina los eventos duplicados en función de uno o varios campos.	dedup sección	Especifica los campos en los que se va a eliminar la duplicación.	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 de control. En la búsqueda, se muestran outcome variables.	metadata.event_type = "USER_LOGIN" select: principal.hostname
sort	Lista los resultados en orden ascendente o descendente.	order sección	Consulta un 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 el número de resultados devueltos.	limit sección	Consulta el ejemplo de 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 con varios valores	Gestionado con funciones de mv* (mvexpand y mvfilter)	Compatibilidad integrada	YARA-L desanida automáticamente las matrices en la sección de eventos. Las funciones de matriz están disponibles en outcome, si es necesario.	Consulta ejemplos de funciones de varios valores.
Ventanas de tiempo	earliest=-5m, latest=now	Sección match, over, by	Para las detecciones continuas, usa match: $field over 5m or by 5m. En los paneles de control de la interfaz de búsqueda, usa match: $field by 5m.	Consulte ejemplos en Ventanas temporales.

Consultas de agregación y estadísticas

En YARA-L, las funciones de agregación y estadísticas se suelen colocar 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. Mientras que el comando eval gestiona las transformaciones de campo por campo y de fila por fila (de forma similar a una expresión SELECT), stats realiza agregaciones a nivel de conjunto (de forma similar a GROUP BY en SQL).

En la siguiente tabla se muestra la sintaxis y el uso principales, así como cómo usar las estadísticas de forma 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 el número 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 el número 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 medio de un campo.	avg()	$host = principal.hostname match: $host by day outcome: $avg_bytes_sent = avg(network.sent_bytes)
min/max	Busca el valor mínimo o máximo de 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()	Calcula la mediana.	window.median	target.file.mime_type = "PDF" outcome: $median_file_size = window.median(target.file.size, false)
first() and last()	Devuelve valores en función del orden de los eventos en los resultados de 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 información, consulta las funciones adicionales.

Por ejemplo, una consulta multietapa puede monitorizar varios inicios de sesión fallidos en agregaciones por capas. Para obtener más información, consulta el ejemplo de agregación de varias fases y el artículo Crear consultas de varias fases en YARA-L.

Agregación multietapa (media horaria a semanal)

En este ejemplo de varias fases, primero se agregan los datos para obtener los bytes transferidos por host cada hora. A continuación, usa esa agregación para calcular la media general de esos intervalos por horas 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 multivalor (leer una matriz)

La sintaxis de YARA-L se ha diseñado para entender 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 comprueba automáticamente todos los valores de la matriz. No es necesario que uses una función especial para filtrar la matriz, solo tienes que indicar la condición que quieres que se cumpla. Por ejemplo, si el campo principal.ip del evento de registro contiene lo siguiente, el motor de YARA-L comprueba automáticamente todos los valores de la matriz 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 gestionar los campos de varios valores en los datos de registro. Los campos de varios valores, como una matriz de direcciones IP o una lista de grupos de usuarios, son una función habitual 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, se indica el campo que debe coincidir. YARA-L comprueba automáticamente si algún valor de la matriz de grupos coincide con "`admin`".	principal.user.group_identifiers = "admin"
mvcount()	Cuenta el número de valores de un campo de varios valores.	count() aplicado a un campo de la sección de consultas outcome. No es necesario desanidar ningún valor primero.	Consulta el ejemplo Contar el número de usuarios que pertenecen al grupo de personal de TI.
mvexpand	Crea un evento por cada valor de un campo de varios valores.	Gestiona los campos de varios valores de forma nativa e implícita. El desanidamiento se produce automáticamente.	Consulta el ejemplo Contar el número de usuarios que pertenecen al grupo de personal de TI.
mvjoin	Combina todos los valores de un campo de varios valores en una sola cadena para dar formato a los datos.	Los valores se almacenan automáticamente como una matriz en los resultados. La salida de YARA-L está estructurada, no es una cadena plana. Muestra el campo como una matriz si es necesario manipularla más. Para obtener más información, consulta el artículo sobre funciones de matriz.

Ejemplo: Contar el número de inicios de sesión de admin

En el ejemplo siguiente, 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 (una matriz).

• Desanidación implícita: YARA-L desanida automáticamente este campo de forma interna durante la evaluación de la consulta.
• Comprobación de la condición: un evento cumplirá la condición si alguno de los valores de la matriz $principal.user.group_identifiers es igual a "admin".
• No se necesita ningún comando explícito: a diferencia de SPL, no necesitas ningún comando específico para anular el anidamiento, como mvexpand.

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

• Un solo evento de UDM que contenga varios valores coincidentes en un campo repetido puede generar varias filas internas para evaluar las consultas.
• Como la sección events ya ha desanidado los eventos en función de cada valor coincidente de $principal.user.group_identifiers, la agregación count(metadata.id) cuenta cada una de estas instancias desanidadas.

Ejemplo: Contar el número 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: Crear una regla para recibir una alerta cuando se detecte 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
    }

Ventanas de tiempo

En YARA-L, el periodo de tiempo es un método para correlacionar eventos durante un periodo de tiempo específico y continuo. Cuando se usa en reglas, esta ventana se mueve continuamente con los datos entrantes, lo que permite detectar patrones en tiempo real de forma continua a medida que se desarrollan.

Este proceso es una parte fundamental del diseño de la detección automatizada y una de las ventajas de usar YARA-L. Si especificas el periodo, tus detecciones y paneles de control trabajarán continuamente con datos en tiempo real.

Función	SPL	YARA-L
Objetivo principal	Búsquedas estáticas y 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 de control)

Los ejemplos de esta sección ilustran la diferencia entre una ventana temporal acumulativa (con by) y una ventana temporal deslizante (con over) en YARA-L.

Ventana temporal de saltos de tamaño constante (by <time_unit>)

• Concepto: en la búsqueda de YARA-L, las ventanas de tiempo acumulativas crean intervalos de tiempo de tamaño fijo que no se superponen. El sistema procesa cada evento asignándolo a un único intervalo de tiempo específico en función de su marca de tiempo. Estos intervalos fijos son absolutos y se ajustan estrictamente a los marcadores de tiempo estándar, como días, horas o minutos.

• Uso: se usa habitualmente en las consultas de búsqueda y los paneles de control de Google SecOps para agregar datos en segmentos de tiempo discretos.

Ejemplo: recuento diario de inicios de sesión correctos por usuario

Esta consulta de búsqueda agrupa los eventos de inicio de sesión correctos por cada usuario único de cada día del calendario. En el siguiente ejemplo se muestra una ventana de tiempo acumulada 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 inicios de sesión correctos en Nov 17 y 15 en Nov 18, esta consulta genera dos filas independientes para jdoe, una por cada día, con los recuentos respectivos. El segmento Nov 17 incluye eventos de 2025-11-17 00:00:00 to 23:59:59 UTC.

Ventana temporal deslizante (over <duration>)

• Concepto: se usan en reglas de YARA-L. Las ventanas deslizantes son ventanas de tiempo que se mueven y que pueden superponerse con una duración específica. Son ideales para correlacionar eventos que se producen con una proximidad determinada entre sí.

• Uso: se usa principalmente en reglas de YARA-L para detectar patrones o secuencias de eventos en un periodo continuo.

Ejemplo: Detectar varios inicios de sesión fallidos en un plazo de 5 minutos

Este ejemplo de regla YARA-L genera una detección si un solo usuario tiene más de 5 failed logins intentos en cualquier periodo 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 monitoriza continuamente los inicios de sesión fallidos. En cualquier momento, tiene en cuenta los últimos 5 minutos de eventos de cada usuario. Por ejemplo, si entre las 10:02:30 y las 10:07:30, el usuario jdoe acumula seis intentos de inicio de sesión fallidos, se activará una detección. Esta ventana se desplaza constantemente hacia delante, lo que permite detectar patrones en tiempo real, independientemente de los límites del calendario.

Siguientes pasos

• Consulta más información en la descripción general de YARA-L 2.0.
• Consulta la sintaxis completa del lenguaje YARA-L 2.0.
• Consulta información sobre cómo escribir reglas de Detection Engine.
• Novedades en los blogs de Google SecOps

¿Necesitas más ayuda? Recibe respuestas de los miembros de la comunidad y de los profesionales de Google SecOps.