Sintaxis del lenguaje YARA-L 2.0
En esta sección, se describen los elementos principales de la sintaxis de YARA-L. Consulta también la Descripción general del lenguaje YARA-L 2.0.
Estructura de la regla
Para YARA-L 2.0, debes especificar las declaraciones, definiciones y usos de las variables en el siguiente orden:
- meta
- eventos
- coincidencia (opcional)
- resultado (opcional)
- de transición
- opciones (opcional)
A continuación, se muestra la estructura genérica de una regla:
rule <rule Name>
{
meta:
// Stores arbitrary key-value pairs of rule details, such as who wrote
// it, what it detects on, version control, etc.
events:
// Conditions to filter events and the relationship between events.
match:
// Values to return when matches are found.
outcome:
// Additional information extracted from each detection.
condition:
// Condition to check events and the variables used to find matches.
options:
// Options to turn on or off while executing this rule.
}
Sintaxis de la sección de meta
La sección de meta se compone de varias líneas, en las que cada línea define un par clave-valor. Una parte de clave debe ser una cadena sin comillas, y una parte de valor debe ser una cadena entrecomillada:
<key> = "<value>"
El siguiente es un ejemplo de una línea de sección meta
válida:
meta:
author = "Google"
severity = "HIGH"
Sintaxis de la sección de eventos
En la sección events
, enumera los predicados para especificar lo siguiente:
- Declaraciones de variables
- Filtros de variables de eventos
- Uniones de variables de evento
Declaraciones de variables
Para las declaraciones de variables, usa la siguiente sintaxis:
<EVENT_FIELD> = <VAR>
<VAR> = <EVENT_FIELD>
Ambos son equivalentes, como se muestra en los siguientes ejemplos:
$e.source.hostname = $hostname
$userid = $e.principal.user.userid
Esta declaración indica que esta variable representa el campo especificado para la variable de evento. Cuando el campo de evento es un campo repetido, la variable de coincidencia puede representar cualquier valor en el array. También es posible asignar varios campos de evento a una sola coincidencia o variable de marcador de posición. Esta es una condición de unión transitiva.
Por ejemplo:
$e1.source.ip = $ip
$e2.target.ip = $ip
Son equivalentes a lo siguiente:
$e1.source.ip = $ip
$e1.source.ip = $e2.target.ip
Cuando se usa una variable, esta se debe declarar mediante la declaración de variables. Si una variable se usa sin ninguna declaración, se considera un error de compilación.
Filtros de variables de eventos
Una expresión booleana que actúa sobre una sola variable de evento se considera un filtro.
Uniones de variables de eventos
Todas las variables de evento que se usan en la regla deben unirse con todas las demás variables de evento de una de las siguientes maneras:
Directamente a través de una comparación de igualdad entre campos de evento de las dos variables de evento unidas, por ejemplo:
$e1.field = $e2.field
La expresión no debe incluir aritmética.De forma indirecta, a través de una unión transitiva que solo incluya un campo de evento (consulta la declaración de variables para obtener una definición de "unión transitiva"). La expresión no debe incluir aritmética.
Por ejemplo, si se usan $e1, $e2 y $e3 en la regla, las siguientes secciones de events
son válidas.
events:
$e1.principal.hostname = $e2.src.hostname // $e1 joins with $e2
$e2.principal.ip = $e3.src.ip // $e2 joins with $e3
events:
// $e1 joins with $e2 via function to event comparison
re.capture($e1.src.hostname, ".*") = $e2.target.hostname
events:
// $e1 joins with $e2 via an `or` expression
$e1.principal.hostname = $e2.src.hostname
or $e1.principal.hostname = $e2.target.hostname
or $e1.principal.hostname = $e2.principal.hostname
events:
// all of $e1, $e2 and $e3 are transitively joined via the placeholder variable $ip
$e1.src.ip = $ip
$e2.target.ip = $ip
$e3.about.ip = $ip
events:
// $e1 and $e2 are transitively joined via function to event comparison
re.capture($e2.principal.application, ".*") = $app
$e1.principal.hostname = $app
Sin embargo, estos son ejemplos de secciones events
no válidas.
events:
// Event to arithmetic comparison is an invalid join condition for $e1 and $e2.
$e1.principal.port = $e2.src.port + 1
events:
$e1.src.ip = $ip
$e2.target.ip = $ip
$e3.about.ip = "192.1.2.0" //$e3 is not joined with $e1 or $e2.
events:
$e1.src.port = $port
// Arithmetic to placeholder comparison is an invalid transitive join condition.
$e2.principal.port + 800 = $port
Sintaxis de sección de coincidencia
En la sección match
, enumera las variables de coincidencia para los eventos de grupo antes de verificar las condiciones de coincidencia. Esos campos se muestran con cada coincidencia.
- Especifica qué representa cada variable de coincidencia en la sección
events
. - Especifica la duración que se usará para correlacionar eventos después de la palabra clave
over
. Se ignoran los eventos fuera de la duración. Usa la siguiente sintaxis para especificar la duración:
<number><m/h/d>
En la que
m/h/d
significa minutos, horas y días, respectivamente.El tiempo mínimo que puedes especificar es 1 minuto.
El tiempo máximo que puedes especificar es de 48 horas.
El siguiente es un ejemplo de un match
válido:
$var1, $var2 over 5m
Esta sentencia muestra $var1
y $var2
(definidos en la sección events
) cuando la regla encuentra una coincidencia. El tiempo especificado es de 5 minutos. Los eventos que tienen más de 5 minutos de diferencia no se correlacionan y, por lo tanto, la regla los ignora.
Este es otro ejemplo de una sección match
válida:
$user over 1h
Esta sentencia muestra $user
cuando la regla encuentra una coincidencia. El período especificado es de 1 hora. Los eventos con más de una hora de diferencia no están correlacionados. La regla no los considera una detección.
Este es otro ejemplo de una sección match
válida:
$source_ip, $target_ip, $hostname over 2m
Esta sentencia muestra $source_ip
, $target_ip
y $hostname
cuando la regla encuentra una coincidencia. El período especificado es de 2 minutos. Los eventos que tienen más de 2 minutos de diferencia no están correlacionados. La regla no los considera una detección.
En los siguientes ejemplos, se ilustran secciones match
no válidas:
var1, var2 over 5m // invalid variable name
$user 1h // missing keyword
Manejo de valores cero en la sección de coincidencia
El motor de reglas filtra de forma implícita los valores cero de todos los marcadores de posición que se usan en la sección de coincidencia (""
para cadenas, 0
para números, false
para valores booleanos y el valor en la posición 0 para tipos enumerados).
En el siguiente ejemplo, se ilustran las reglas que filtran los valores cero.
rule ZeroValuePlaceholderExample {
meta:
events:
// Because $host is used in the match section, the rule behaves
// as if the following predicate was added to the events section:
// $host != ""
$host = $e.principal.hostname
// Because $otherPlaceholder was not used in the match section,
// there is no implicit filtering of zero values for $otherPlaceholder.
$otherPlaceholder = $e.principal.ip
match:
$host over 5m
condition:
$e
}
Sin embargo, si se asigna un marcador de posición a una función, las reglas no filtrar implícitamente los valores cero de los marcadores de posición que se utilizan en la sección de coincidencias. En el siguiente ejemplo, se ilustran las reglas que filtran los valores cero:
rule ZeroValueFunctionPlaceholder {
meta:
events:
// Even though $ph is used in the match section, there is no
// implicit filtering of zero values for $ph, because $ph is assigned to a function.
$ph = re.capture($e.principal.hostname, "some-regex")
match:
$ph over 5m
condition:
$e
}
Para inhabilitar el filtrado implícito de valores cero, puedes usar la opción allow_zero_values
en la sección de opciones.
Ventana de salto
De forma predeterminada, las reglas de YARA-L 2.0 con una sección de coincidencia se evalúan con ventanas de salto.
El intervalo de tiempo de la ejecución de la regla se divide en un conjunto de ventanas de salto superpuestas, cada una con la duración especificada en la sección match
. Luego, los eventos se correlacionan
dentro de cada ventana de salto.
Por ejemplo, para una regla que se ejecuta durante el intervalo de tiempo [1:00, 2:00], con una
Sección match
sobre 30m
, un conjunto posible de ventanas de salto superpuestas
que se puede generar es [1:00, 1:30], [1:03, 1:33] y [1:06, 1:36].
Estas ventanas se usan para correlacionar múltiples eventos.
Ventana deslizante
Usar ventanas de salto no es una manera eficaz de buscar eventos que ocurren en un orden específico (por ejemplo, si e1
ocurre hasta 2 veces
minutos después de e2
). Un caso del evento e1
y un caso del evento e2
se correlacionan solo si entran en la misma ventana de salto generada.
Una forma más eficaz de buscar tales secuencias de eventos es usar ventanas deslizantes.
Las ventanas variables con la duración especificada en la sección match
se generan cuando
comiencen o terminen con una variable de evento de tabla dinámica especificada. Luego, los eventos
se correlacionan dentro de cada ventana variable. Esto permite buscar eventos que ocurren en un orden específico (por ejemplo, e1
ocurre dentro de los 2 minutos de e2
). Una ocurrencia del evento e1
y una ocurrencia del evento e2
se correlacionan si el evento e1
ocurre dentro de la duración de la ventana deslizante después del evento e2
.
Especifica ventanas deslizantes en la sección match
de una regla de la siguiente manera:
<match-var-1>, <match-var-2>, ... over <duration> before|after <pivot-event-var>
La variable de evento de eje es la variable de evento en la que se basan las ventanas deslizantes. Si usas la palabra clave before
, se generan ventanas variables que terminan con
cada caso del evento de pivote. Si se usa la palabra clave after
, se generan ventanas deslizantes que comienzan con cada ocurrencia del evento de cambio.
Los siguientes son ejemplos de usos válidos de ventanas deslizantes:
$var1, $var2 over 5m after $e1
$user over 1h before $e2
Consulta un ejemplo de regla de ventana deslizante.
Google recomienda no usar ventanas deslizantes para las reglas de un solo evento, ya que estas están diseñadas para detectar varios eventos. Si una de tus reglas pertenece a esta categoría, Google recomienda una de las siguientes soluciones alternativas:
- Convierte la regla para usar múltiples variables de evento y actualiza la condición.
si la regla requiere más de un caso del evento.
- De manera opcional, considera agregar filtros de marca de tiempo en lugar de usar una ventana deslizante.
Por ejemplo,
$permission_change.metadata.event_timestamp.seconds < $file_creation.metadata.event_timestamp.seconds
- De manera opcional, considera agregar filtros de marca de tiempo en lugar de usar una ventana deslizante.
Por ejemplo,
- Quita la ventana corrediza.
Sintaxis de la sección de resultados
En la sección outcome
, puedes definir hasta 20 variables de resultado, con nombres arbitrarios. Estos resultados se almacenarán en las detecciones que
la regla. Cada detección puede tener valores diferentes para los resultados.
El nombre del resultado, $risk_score
, es especial. De manera opcional, puedes definir un resultado con este nombre y, si lo haces, debe ser un tipo de número entero o de punto flotante. Si se propaga, risk_score
se mostrará en la vista Enterprise Insights para las alertas que provienen de detecciones de reglas.
Si no incluyes una variable $risk_score
en la sección de resultados de una regla,
se establece uno de los siguientes valores predeterminados:
- Si la regla está configurada para generar una alerta,
$risk_score
se establece en 40. - Si la regla no está configurada para generar una alerta,
$risk_score
se establece en 15.
El valor de $risk_score
se almacena en el campo UDM security_result.risk_score
.
Tipos de datos de las variables de resultado
Cada variable de resultado puede tener un tipo de datos diferente, que se determina según la expresión que se usa para calcularla. Admitimos los siguientes tipos de datos de resultados:
- integer
- flotadores
- string
- listas de números enteros
- listas de flotantes
- listas de cadenas
Lógica condicional
Puedes usar la lógica condicional para calcular el valor de un resultado. Condicionales se especifican con el siguiente patrón de sintaxis:
if(BOOL_CLAUSE, THEN_CLAUSE)
if(BOOL_CLAUSE, THEN_CLAUSE, ELSE_CLAUSE)
Puedes leer una expresión condicional como "si BOOL_CLAUSE es verdadero, entonces mostrar THEN_CLAUSE, de lo contrario muestra ELSE_CLAUSE".
BOOL_CLAUSE debe evaluarse como un valor booleano. Una expresión de cláusula BOOL_CLAUSE tiene una forma similar a las expresiones de la sección events
. Por ejemplo, puede contener lo siguiente:
Nombres de campos de UDM con operador de comparación, por ejemplo:
if($context.graph.entity.user.title = "Vendor", 100, 0)
variable de marcador de posición que se definió en la sección
events
, por ejemplo:if($severity = "HIGH", 100, 0)
otra variable de resultado definida en la sección
outcome
, por ejemplo:if($risk_score > 20, "HIGH", "LOW")
funciones que muestran un valor booleano, por ejemplo:
if(re.regex($e.network.email.from, `.*altostrat.com`), 100, 0)
Buscar en una lista de referencia, por ejemplo:
if($u.principal.hostname in %my_reference_list_name, 100, 0)
comparación de agregación, por ejemplo:
if(count($login.metadata.event_timestamp.seconds) > 5, 100, 0)
THEN_CLAUSE y ELSE_CLAUSE deben ser del mismo tipo de datos. Admitimos números enteros, números de punto flotante y cadenas.
Puedes omitir ELSE_CLAUSE si el tipo de datos es un número entero o un número de punto flotante. Si se omite, el ELSE_CLAUSE da como resultado 0. Por ejemplo:
`if($e.field = "a", 5)` is equivalent to `if($e.field = "a", 5, 0)`
Debes proporcionar ELSE_CLAUSE si el tipo de datos es string o si THEN_CLAUSE es una variable de marcador de posición o una variable de resultado.
Operaciones matemáticas
Puedes usar operaciones matemáticas para calcular el tipo de datos de número entero o de punto flotante en las secciones outcome
y events
de una regla. Google Security Operations admite la suma, la resta, la multiplicación, la división y el módulo como operadores de nivel superior en un cálculo.
El siguiente fragmento es un ejemplo de cálculo en la sección outcome
:
outcome:
$risk_score = max(100 + if($severity = "HIGH", 10, 5) - if($severity = "LOW", 20, 0))
Las operaciones matemáticas se permiten en los siguientes tipos de operandos, siempre que cada operando y toda la expresión aritmética se agrupen correctamente (consulta Agrupaciones):
- Campos de eventos numéricos
- Variables de marcador de posición numéricas definidas en la sección
events
- Variables de resultado numéricas definidas en la sección
outcome
- Funciones que muestran números enteros o de punto flotante
- Agregaciones que muestran números enteros o de punto flotante
No se permite el módulo en los números de punto flotante.
Variables de marcadores de posición en los resultados
Cuando calcules las variables de resultado, puedes usar las variables de marcador de posición que se definieron en la sección de eventos de tu regla. En este ejemplo, supongamos que
Se definió $email_sent_bytes
en la sección de eventos de la regla:
Ejemplo de un solo evento:
// No match section, so this is a single-event rule.
outcome:
// Use placeholder directly as an outcome value.
$my_outcome = $email_sent_bytes
// Use placeholder in a conditional.
$other_outcome = if($file_size > 1024, "SEVERE", "MODERATE")
condition:
$e
Ejemplo de varios eventos:
match:
// This is a multi event rule with a match section.
$hostname over 5m
outcome:
// Use placeholder directly in an aggregation function.
$max_email_size = max($email_sent_bytes)
// Use placeholder in a mathematical computation.
$total_bytes_exfiltrated = sum(
1024
+ $email_sent_bytes
+ $file_event.principal.file.size
)
condition:
$email_event and $file_event
Variables de resultado en expresiones de asignación de resultado
Las variables de resultado se pueden usar para derivar otras variables de resultado, de manera similar a las variables de marcador de posición definidas en la sección events
. Puedes hacer referencia a una variable de resultado en la asignación de otra variable de resultado con un token $
seguido del nombre de la variable. Las variables de resultado deben definirse antes de que se pueda hacer referencia a ellas en el texto de la regla. Cuando se usan en una expresión de asignación, las variables de resultado deben
no estar agregadas (consulta Agregaciones).
En el siguiente ejemplo, la variable de resultado $risk_score
deriva su
de la variable de resultado $event_count
:
Ejemplo de varios eventos:
match:
// This is a multi event rule with a match section.
$hostname over 5m
outcome:
// Aggregates all timestamp on login events in the 5 minute match window.
$event_count = count($login.metadata.event_timestamp.seconds)
// $event_count cannot be aggregated again.
$risk_score = if($event_count > 5, "SEVERE", "MODERATE")
// This is the equivalent of the 2 outcomes above combined.
$risk_score2 = if(count($login.metadata.event_timestamp.seconds) > 5, "SEVERE", "MODERATE")
condition:
$e
Las variables de resultado se pueden usar en cualquier tipo de expresión del lado derecho de una asignación de resultado, excepto en las siguientes expresiones:
- Datos recopilados
- Llamadas a la función
Arrays.length()
- Con modificadores
any
oall
Datos recopilados
Los campos de eventos repetidos son valores no escalares. Es decir, una sola variable apunta a varios valores. Por ejemplo, la variable del campo de evento $e.target.ip
es un campo repetido y puede tener cero, uno o muchos valores de IP. Es un valor no escalar. Mientras que la variable del campo de evento $e.principal.hostname
no es un campo repetido y solo tiene 1 valor (es decir, un valor escalar).
Del mismo modo, los campos de eventos repetidos y no repetidos que se usan en la sección de resultados de una regla con una ventana de coincidencia son valores no escalares. Por ejemplo, la siguiente regla agrupa los eventos usando una sección de coincidencia y hace referencia a un campo de evento no repetido en la sección de resultados:
rule OutcomeAndMatchWindow{
...
match:
$userid over 5m
outcome:
$hostnames = array($e.principal.hostname)
...
}
Cualquier período de 5 minutos en el que se ejecute la regla puede contener cero, uno o muchos eventos. La sección de resultados opera en todos los eventos de una ventana de coincidencia. Cualquier variable de campo de evento a la que se haga referencia en el
resultado puede señalar cero, uno o muchos valores del campo en cada evento de la ventana de coincidencia.
En la regla anterior, si un período de 5 minutos contiene 5 eventos $e
, $e.principal.hostname
en la sección de resultados apunta a 5 nombres de host diferentes. La variable del campo del evento
Por lo tanto, $e.principal.hostname
es un valor no escalar en la sección de resultado de esta regla.
Debido a que las variables de resultado siempre deben producir un único valor escalar, cualquier valor no escalar que de las que depende una asignación de resultado deben agregarse para obtener un solo valor escalar. En una sección de resultado, los siguientes son valores no escalares y deben agregarse:
- Campos de evento (repetidos o no) cuando la regla usa una sección de coincidencia
- Marcadores de posición de eventos (repetidos o no) cuando la regla usa una sección de coincidencia
- Campos de eventos repetidos cuando la regla no utiliza una sección de coincidencia
- Marcadores de posición de eventos repetidos cuando la regla no usa una sección de coincidencia
Los campos de eventos escalares, los marcadores de posición de eventos escalares y las constantes pueden unirse
una agregación en una regla que no usa una sección de coincidencia. Sin embargo, la mayoría de las agregaciones generarán el valor unido y, por lo tanto, no son necesarias. La excepción es la agregación array()
, que se puede usar para convertir un valor escalar en un array.
Las variables de resultado se tratan como agregaciones: no deben volver a agregarse. cuando se mencione en otra asignación de resultados.
Puedes usar las siguientes funciones de agregación:
max()
: Muestra el máximo de todos los valores posibles. Solo funciona con números enteros y de punto flotante.min()
: Muestra el mínimo sobre todos los valores posibles. Solo funciona con números enteros y de punto flotante.sum()
: Muestra la suma de todos los valores posibles. Solo funciona con números enteros y números de punto flotante.count_distinct()
: Recopila todos los valores posibles y, luego, muestra el recuento distinto de valores posibles.count()
: se comporta comocount_distinct()
, pero muestra un recuento no distinto de los valores posibles.array_distinct()
: Recopila todos los valores distintos posibles y, luego, da como resultado una lista de estos valores. Integra truncará la lista de valores distintos a 25 elementos aleatorios. Primero se aplica la anulación de duplicación para obtener una lista distinta y, luego, la truncación.array()
: Se comporta comoarray_distinct()
, pero muestra una lista no distinta de valores. También trunca la lista de valores a 25 elementos aleatorios.period_start_for_max()
: Es el inicio del período en el que se produjo el máximo del valor indicado.period_start_for_min()
: Es el inicio del período en el que se produjo el valor mínimo de la lista.
La función de agregación es importante cuando una regla incluye una sección condition
que especifica que deben existir varios eventos, porque la función de agregación
operar en todos los eventos que generaron la detección.
Por ejemplo, si tus secciones outcome
y condition
contienen lo siguiente:
outcome:
$asset_id_count = count($event.principal.asset_id)
$asset_id_distinct_count = count_distinct($event.principal.asset_id)
$asset_id_list = array($event.principal.asset_id)
$asset_id_distinct_list = array_distinct($event.principal.asset_id)
condition:
#event > 1
Dado que la sección de condición requiere que haya más de un event
para cada
las funciones de agregación operarán en múltiples eventos. Supongamos que el
los siguientes eventos generaron una detección:
event:
// UDM event 1
asset_id="asset-a"
event:
// UDM event 2
asset_id="asset-b"
event:
// UDM event 3
asset_id="asset-b"
Luego, los valores de tus resultados serán los siguientes:
- $asset_id_count =
3
- $asset_id_distinct_count =
2
- $asset_id_list =
["asset-a", "asset-b", "asset-b"]
- $asset_id_distinct_list =
["asset-a", "asset-b"]
Ten en cuenta la siguiente información cuando uses la sección de resultados:
Otras notas y restricciones:
- La sección
outcome
no puede hacer referencia a una nueva variable de marcador de posición que todavía no se definió en la secciónevents
ni en la secciónoutcome
. - En la sección
outcome
, no se pueden usar variables de evento que no definido en la secciónevents
. - La sección
outcome
puede usar un campo de evento que no se haya en la secciónevents
, dado que la variable de evento a la que el evento al que pertenece ya se definió en la secciónevents
. - La sección
outcome
solo puede correlacionar variables de evento que ya hayan se correlacionaron en la secciónevents
. Las correlaciones ocurren cuando dos se igualan los campos de evento de diferentes variables de evento.
Puedes encontrar un ejemplo con la sección de resultados en la Descripción general de YARA-L 2.0. Consulta Cómo crear estadísticas adaptadas al contexto para obtener detalles sobre la detección de duplicados con la sección de resultados.
Sintaxis de la sección de condición
- Especifica una condición de coincidencia para los eventos y marcadores de posición definidos en la sección
events
. Para obtener más detalles, consulta la siguiente sección, Condicionales de eventos y marcadores de posición. - (Opcional) Usa la palabra clave
and
para especificar una condición de coincidencia con las variables de resultado definidas en la secciónoutcome
. Consulta la siguiente sección, Condicionales de resultados, para obtener más detalles.
Contar caracteres
El carácter #
es un carácter especial de la sección condition
. Si se usa antes de cualquier evento o nombre de variable de marcador de posición, representa la cantidad de eventos o valores distintos que satisfacen todas las condiciones de la sección events
.
Por ejemplo, #c > 1
significa que la variable c
debe ocurrir más de 1 vez.
Carácter de valor
El carácter $
es un carácter especial en la sección condition
. Si es
antes de cualquier nombre de variable de resultado, representa el valor de ese resultado.
Si se usa antes de cualquier evento o nombre de variable de marcador de posición (por ejemplo, $event
), representa #event > 0
.
Condicionales de eventos y marcadores de posición
Enumerar los predicados de condición para los eventos y las variables de marcador de posición aquí, unidos
con la palabra clave and
o or
. La palabra clave and
se puede usar entre cualquier
pero la palabra clave or
solo se puede usar cuando la regla solo tiene una
variable de evento único.
Este es un ejemplo válido del uso de or
entre dos marcadores de posición en el mismo evento:
rule ValidConditionOr {
meta:
events:
$e.metadata.event_type = "NETWORK_CONNECTION"
// Note that all placeholders use the same event variable.
$ph = $e.principal.user.userid // Define a placeholder variable to put in match section.
$ph2 = $e.principal.ip // Define a second placeholder variable to put in condition section.
$ph3 = $e.principal.hostname // Define a third placeholder variable to put in condition section.
match:
$ph over 5m
condition:
$ph2 or $ph3
}
Ejemplo no válido del uso de or
entre dos condiciones en eventos diferentes:
rule InvalidConditionOr {
meta:
events:
$e.metadata.event_type = "NETWORK_CONNECTION"
$e2.graph.metadata.entity_type = "FILE"
$e2.graph.entity.hostname = $e.principal.hostname
$ph = $e.principal.user.userid // Define a placeholder variable to put in match section.
match:
$ph over 5m
condition:
$e or $e2 // This line will cause an error because there is an or between events.
}
Condiciones delimitadas y no delimitadas
Las siguientes condiciones son condiciones limitadas. Fuerzan la existencia de la variable de evento asociada, lo que significa que al menos una ocurrencia del evento debe aparecer en cualquier detección.
$var // equivalent to #var > 0
#var > n // where n >= 0
#var >= m // where m > 0
Las siguientes condiciones son no delimitadas. Permiten que la variable de evento asociada no exista, lo que significa que es posible que no aparezca ninguna ocurrencia del evento en una detección y que cualquier referencia a campos en la variable de evento genere un valor cero. Las condiciones no delimitadas se pueden usar para detectar la ausencia de un evento durante un período. Por ejemplo, un evento de amenaza sin un evento de mitigación en un período de 10 minutos. Reglas que usan reglas se denominan reglas de inexistencia.
!$var // equivalent to #var = 0
#var >= 0
#var < n // where n > 0
#var <= m // where m >= 0
Requisitos para la inexistencia
Para que se compile una regla con no existencia, debe cumplir con los siguientes requisitos:
- Al menos un evento de la AUA debe tener una condición delimitada (es decir, debe existir al menos un evento de la AUA).
- Si un marcador de posición tiene una condición no delimitada, debe asociarse con al menos un evento de UDM limitado.
- Si una entidad tiene una condición no delimitada, debe estar asociada con al menos un evento de la AUA delimitado.
Considera la siguiente regla en la que se omite la sección de condición:
rule NonexistenceExample {
meta:
events:
$u1.metadata.event_type = "NETWORK_CONNECTION" // $u1 is a UDM event.
$u2.metadata.event_type = "NETWORK_CONNECTION" // $u2 is a UDM event.
$e1.graph.metadata.entity_type = "FILE" // $e1 is an Entity.
$e2.graph.metadata.entity_type = "FILE" // $e2 is an Entity.
$user = $u1.principal.user.userid // Match variable is required for Multi-Event Rule.
// Placeholder Associations:
// u1 u2
// | \ /
// port ip
// | \
// e1 e2
$u1.target.port = $port
$e1.graph.entity.port = $port
$u1.principal.ip = $ip
$u2.target.ip = $ip
$e2.graph.entity.ip = $ip
// UDM-Entity Associations:
// u1 - u2
// | \ |
// e1 e2
$u1.metadata.event_type = $u2.metadata.event_type
$e1.graph.entity.hostname = $u1.principal.hostname
$e2.graph.entity.hostname = $u1.target.hostname
$e2.graph.entity.hostname = $u2.principal.hostname
match:
$user over 5m
condition:
<condition_section>
}
Los siguientes son ejemplos válidos para <condition_section>
:
$u1 and !$u2 and $e1 and $e2
- Todos los eventos y entidades de la AUA están presentes en la sección de condiciones.
- Al menos un evento de UDM está delimitado.
$u1 and !$u2 and $e1 and !$e2
$e2
no está delimitado, lo que está permitido porque está asociado con$u1
, que está delimitado. Si$e2
no estuviera asociado con$u1
, no sería válido.
#port > 50 and #ip = 0
- No hay eventos ni entidades de la AUA en la sección de condiciones. Sin embargo, los marcadores de posición que están presentes abarcan todos los eventos y entidades de la AUA.
$ip
se asigna a$u1
y$u2
, y#ip = 0
es una condición no delimitada. Sin embargo, las condiciones limitadas son más estrictas que las ilimitadas. Como$port
se asigna a$u1
y#port > 50
es una condición delimitada,$u1
todavía está delimitada.
Los siguientes son ejemplos no válidos para <condition_section>
:
$u1 and $e1
- Cada evento y entidad de la AUA que aparece en la sección Eventos debe aparecer en la sección Condición (o tener un marcador de posición asignado que aparezca en la sección Condición).
$u1, $u2, $e1, $u2, #port > 50
- No se permiten comas como separadores de condiciones.
!$u1 and !$u2 and $e1 and $e2
- Infringe el primer requisito de que al menos un evento de UDM está delimitado.
($u1 or #port < 50) and $u2 and $e1 and $e2
- La palabra clave
or
no es compatible con condiciones no delimitadas.
- La palabra clave
($u1 or $u2) and $e1 and $e2
- La palabra clave
or
no se admite entre diferentes variables de evento.
- La palabra clave
not $u1 and $u2 and $e1 and $e2
- No se permite la palabra clave
not
para las condiciones de eventos y marcadores de posición.
- No se permite la palabra clave
#port < 50 and #ip = 0
- Los marcadores de posición que están presentes abarcan todos los eventos y entidades de la AUA. Sin embargo, todas las condiciones no tienen límites. Esto significa que ninguno de los eventos de la AUA está limitado, lo que hace que la regla no se compile.
Condicionales de resultados
Enumera los predicados de condición para las variables de resultado aquí, unidos con la palabra clave and
o or
, o precedidos por la palabra clave not
.
Especifica condicionales de resultado de manera diferente según el tipo de variable de resultado:
integer: se compara con un literal de número entero con los operadores
=, >, >=, <, <=, !=
, por ejemplo:$risk_score > 10
float: Compara con un número de punto flotante literal con operadores
=, >, >=, <, <=, !=
, por ejemplo:$risk_score <= 5.5
cadena: Compara con un literal de cadena con
=
o!=
, por ejemplo:$severity = "HIGH"
Lista de números enteros o arrays: Especifica la condición con la función
arrays.contains
, por ejemplo:arrays.contains($event_ids, "id_1234")
Clasificación de reglas
Especificar un resultado condicional en una regla que tiene una sección de coincidencia significa que la regla se clasificará como una de varios eventos para la cuota de reglas. Consulta Regla de evento único y Regla de evento múltiple para obtener más información sobre las clasificaciones de uno o varios eventos.
Sintaxis de la sección de opciones
En la sección options
, puedes especificar las opciones de la regla. Aquí tienes
un ejemplo de cómo especificar la sección de opciones:
rule RuleOptionsExample {
// Other rule sections
options:
allow_zero_values = true
}
Puedes especificar opciones con la sintaxis key = value
, en la que key
debe ser un nombre de opción predefinido y value
debe ser un valor válido para la opción, como se especifica para las siguientes opciones:
allow_zero_values
Los valores válidos para esta opción son true
y false
, que determinan
si esta opción está habilitada o no. El valor predeterminado es false
. Esta opción está inhabilitada si no se especifica en la regla.
Para habilitar este parámetro de configuración, agrega lo siguiente:
a la sección de opciones de tu regla: allow_zero_values = true
. De esta manera, se evitará que la regla filtre de forma implícita los valores cero de los marcadores de posición que se usan en la sección de coincidencias, como se describe en Manejo de valores cero en la sección de coincidencias.
Expresiones booleanas
Las expresiones booleanas son expresiones de tipo booleano.
Comparaciones
Para usar una expresión binaria como condición, usa la siguiente sintaxis:
<EXPR> <OP> <EXPR>
La expresión puede ser un campo de evento, una variable, un literal o una expresión de función.
Por ejemplo:
$e.source.hostname = "host1234"
$e.source.port < 1024
1024 < $e.source.port
$e1.source.hostname != $e2.target.hostname
$e1.metadata.collected_timestamp.seconds > $e2.metadata.collected_timestamp.seconds
$port >= 25
$host = $e2.target.hostname
"google-test" = strings.concat($e.principal.hostname, "-test")
"email@google.org" = re.replace($e.network.email.from, "com", "org")
Si ambos lados son literales, se considera un error de compilación.
Funciones
Algunas expresiones de función muestran un valor booleano, que se puede usar como un predicado individual en la sección events
. Estas funciones son las siguientes:
re.regex()
net.ip_in_range_cidr()
Por ejemplo:
re.regex($e.principal.hostname, `.*\.google\.com`)
net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")
Expresiones de lista de referencia
Puedes usar listas de referencia en la sección de eventos. Consulta la sección sobre listas de referencias para obtener más detalles.
Expresiones lógicas
Puedes usar los operadores and
y or
lógicos en la sección events
, como se muestra en los siguientes ejemplos:
$e.metadata.event_type = "NETWORK_DNS" or $e.metadata.event_type = "NETWORK_DHCP"
($e.metadata.event_type = "NETWORK_DNS" and $e.principal.ip = "192.0.2.12") or ($e.metadata.event_type = "NETWORK_DHCP" and $e.principal.mac = "AB:CD:01:10:EF:22")
not $e.metadata.event_type = "NETWORK_DNS"
De forma predeterminada, el orden de prioridad de mayor a menor es not
, and
, or
.
Por ejemplo, "a o b y c" se evalúa como "a o (b y c)" cuando los operadores or
y and
se definen de forma explícita en la expresión.
En la sección events
, los predicados se unen con el operador and
si no se define un operador de forma explícita.
El orden de evaluación puede ser diferente si el operador and
está implícito en la expresión.
Por ejemplo, considera las siguientes expresiones de comparación en las que or
se define de forma explícita. El operador and
está implícito.
$e1.field = "bat"
or $e1.field = "baz"
$e2.field = "bar"
Este ejemplo se interpreta de la siguiente manera:
($e1.field = "bat" or $e1.field = "baz")
and ($e2.field = "bar")
Debido a que or
se define de forma explícita, los predicados que rodean a or
se agrupan y evalúan primero.
El último predicado, $e2.field = "bar"
, se une de forma implícita con and
. El resultado es que cambia el orden de evaluación.
Tipos enumerados
Puedes usar los operadores con tipos enumerados. Puede aplicarse a reglas para simplificar y optimizar (usa un operador en lugar de listas de referencia) el rendimiento.
En el siguiente ejemplo, “USER_UNCATEGORIZED” y “USER_RESOURCE_DELETION” corresponden a 15,000 y 15,014, por lo que la regla buscará todos los eventos enumerados:
$e.metadata.event_type >= "USER_CATEGORIZED" and $e.metadata.event_type <= "USER_RESOURCE_DELETION"
Lista de eventos:
- USER_RESOURCE_DELETION
- USER_RESOURCE_UPDATE_CONTENT
- USER_RESOURCE_UPDATE_PERMISSIONS
- USER_STATS
- USER_UNCATEGORIZED
Modificador nocase
Cuando tienes una expresión de comparación entre valores de cadena o una expresión regular, puedes agregar nocase al final de la expresión para ignorar la mayúscula.
$e.principal.hostname != "http-server" nocase
$e1.principal.hostname = $e2.target.hostname nocase
$e.principal.hostname = /dns-server-[0-9]+/ nocase
re.regex($e.target.hostname, `client-[0-9]+`) nocase
No se puede usar cuando un tipo de campo es un valor enumerado. Los siguientes ejemplos no son válidos y generarán errores de compilación:
$e.metadata.event_type = "NETWORK_DNS" nocase
$e.network.ip_protocol = "TCP" nocase
Campos repetidos
En el modelo de datos unificado (UDM), algunos campos se etiquetan como repetidos, lo que indica que son listas de valores o de otros tipos de mensajes.
Campos repetidos y expresiones booleanas
Existen 2 tipos de expresiones booleanas que actúan en campos repetidos:
- Modificado
- Sin modificaciones
Considera el siguiente evento:
event_original {
principal {
// ip is a repeated field
ip: [ "192.0.2.1", "192.0.2.2", "192.0.2.3" ]
hostname: "host"
}
}
Expresiones modificadas
En las siguientes secciones, se describe el propósito y cómo usar los modificadores any
y all
en expresiones.
cualquiera
Si algún elemento del campo repetido satisface la condición, el evento en conjunto cumple con la condición.
event_original
cumple conany $e.principal.ip = "192.0.2.1"
.event_original
falla conany $e.repeated_field.field_a = "9.9.9.9
.
todos
Si todos los elementos del campo repetido cumplen con la condición, el evento en su totalidad la cumple.
event_original
cumple connet.ip_in_range_cidr(all $e.principal.ip, "192.0.2.0/8")
.event_original
fallaall $e.principal.ip = "192.0.2.2"
.
Cuando escribas una condición con any
o all
, ten en cuenta que negar la condición con not
podría no tener el mismo significado que usar el operador con la negación.
Por ejemplo:
not all $e.principal.ip = "192.168.12.16"
verifica si no todas las direcciones IP coincide con192.168.12.16
, lo que significa que la regla comprueba si al menos una dirección IP no coincide con192.168.12.16
.all $e.principal.ip != "192.168.12.16"
verifica si todas las direcciones IP no coinciden con192.168.12.16
, lo que significa que la regla verifica que ninguna dirección IP coincida con192.168.12.16
.
Restricciones:
- Los operadores
any
yall
solo son compatibles con campos repetidos (no con campos escalares). any
yall
no se pueden usar para unir dos campos repetidos. Por ejemplo,any $e1.principal.ip = $e2.principal.ip
no es válido.- Los operadores
any
yall
no son compatibles con la expresión de la lista de referencia.
Expresiones sin modificar
Con expresiones no modificadas, cada elemento del campo repetido se trata de forma individual. Si el campo repetido de un evento contiene n elementos, la regla se aplica a n copias del evento, en las que cada copia tiene uno de los elementos del campo repetido. Estas copias son transitorias y no se almacenan.
La regla se aplica a las siguientes copias:
texto del evento | principal.ip | principal.hostname |
---|---|---|
event_copy_1 | “192.0.2.1” | "anfitrión" |
event_copy_2 | “192.0.2.2” | "anfitrión" |
event_copy_3 | "192.0.2.3" | "host" |
Si alguna copia de un evento satisface todas las condiciones sin modificar en el campo repetido, el evento en su conjunto satisface todas las condiciones. Esto significa que, si tienes varias condiciones en un campo repetido, la copia del evento debe satisfacer todas. Los siguientes ejemplos de reglas usan el conjunto de datos del ejemplo anterior para demostrar este comportamiento.
La siguiente regla muestra una coincidencia cuando se ejecuta en el conjunto de datos de ejemplo event_original
, porque event_copy_1
satisface todos los predicados de eventos:
rule repeated_field_1 {
meta:
events:
net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/8") // Checks if IP address matches 192.x.x.x
$e.principal.ip = "192.0.2.1"
condition:
$e
}
La siguiente regla no muestra una coincidencia cuando se ejecuta en event_original
conjunto de datos de ejemplo, porque no hay ninguna copia de evento en $e.principal.ip
que
satisface todos los predicados del evento.
rule repeated_field_2 {
meta:
events:
$e.principal.ip = "192.0.2.1"
$e.principal.ip = "192.0.2.2"
condition:
$e
}
Las expresiones modificadas en campos repetidos son compatibles con las expresiones no modificadas en campos repetidos porque la lista de elementos es la misma para cada copia del evento. Considera la siguiente regla:
rule repeated_field_3 {
meta:
events:
any $e.principal.ip = "192.0.2.1"
$e.principal.ip = "192.0.2.3"
condition:
$e
}
La regla se aplica en las siguientes copias:
texto del evento | principal.ip | cualquier $e.principal.ip |
---|---|---|
event_copy_1 | “192.0.2.1” | [“192.0.2.1”, “192.0.2.2”, “192.0.2.3”] |
event_copy_2 | “192.0.2.2” | ["192.0.2.1", "192.0.2.2", "192.0.2.3"] |
event_copy_3 | "192.0.2.3" | ["192.0.2.1", "192.0.2.2", "192.0.2.3"] |
En este caso, todas las copias satisfacen any $e.principal.ip = "192.0.2.1"
, pero solo event_copy_3
satisface $e.principal.ip = "192.0.2.3". Como resultado, todo el evento coincidiría.
Otra forma de pensar en estos tipos de expresiones es la siguiente:
- Las expresiones en campos repetidos que usan
any
oall
operan en la lista enevent_original
. - Las expresiones en campos repetidos que no usan
any
oall
operan en eventosevent_copy_n
individuales.
Campos repetidos y marcadores de posición
Los campos repetidos funcionan con las asignaciones de marcadores de posición. Al igual que con las expresiones no modificadas en campos repetidos, se crea una copia del evento para cada elemento. Con el mismo ejemplo de event_copy
, el marcador de posición toma el valor del campo repetido de event_copy_n
para cada una de las copias del evento, en las que n es el número de copia del evento. Si el marcador de posición se usa en la sección de coincidencias, esto puede generar varias coincidencias.
En el siguiente ejemplo, se genera una coincidencia. El marcador de posición $ip
es igual a 192.0.2.1
para event_copy_1
, que satisface los predicados de la regla.
Las muestras de eventos de coincidencias contienen un solo elemento, event_original
.
// Generates 1 match.
rule repeated_field_placeholder1 {
meta:
events:
$ip = $e.principal.ip
$ip = "192.0.2.1"
$host = $e.principal.hostname
match:
$host over 5m
condition:
$e
}
En el siguiente ejemplo, se generan tres coincidencias. El marcador de posición $ip
es igual
a valores diferentes para cada una de las diferentes copias de event_copy_n
.
La agrupación se realiza en $ip
, ya que está en la sección de coincidencias. Por lo tanto, obtienes tres coincidencias.
donde cada coincidencia tiene un valor diferente para la variable de coincidencia $ip
. Cada coincidencia tiene la misma
ejemplo de evento: un solo elemento, event_original
.
// Generates 3 matches.
rule repeated_field_placeholder2 {
meta:
events:
$ip = $e.principal.ip
net.ip_in_range_cidr($ip, "192.0.2.0/8") // Checks if IP matches 192.x.x.x
match:
$ip over 5m
condition:
$e
}
Resultados con marcadores de posición asignados a campos repetidos
Los marcadores de posición se asignan a cada elemento de cada campo repetido, no a toda la lista. Por lo tanto, cuando se usan en la sección de resultados, el resultado se calcula solo con los elementos que satisficieron las secciones anteriores.
Ten en cuenta la siguiente regla:
rule outcome_repeated_field_placeholder {
meta:
events:
$ip = $e.principal.ip
$ip = "192.0.2.1" or $ip = "192.0.2.2"
$host = $e.principal.hostname
match:
$host over 5m
outcome:
$o = array_distinct($ip)
condition:
$e
}
Hay 4 etapas de ejecución para esta regla. La primera etapa es la copia del evento:
texto del evento | $ip | $host | $e |
---|---|---|---|
event_copy_1 | “192.0.2.1” | "anfitrión" | event_id |
event_copy_2 | “192.0.2.2” | "host" | event_id |
event_copy_3 | "192.0.2.3" | "host" | event_id |
Luego, la sección de eventos filtrará las filas que no coincidan con los filtros:
texto del evento | $ip | $host | $e |
---|---|---|---|
event_copy_1 | “192.0.2.1” | "anfitrión" | event_id |
event_copy_2 | “192.0.2.2” | "host" | event_id |
event_copy_3
se filtra porque "192.0.2.3"
no satisface $ip = "192.0.2.1" or $ip = "192.0.2.2"
.
Luego, la sección de coincidencias se agrupará por variables de coincidencia y la sección de resultados realizará la agregación en cada grupo:
$host | $o | $e |
---|---|---|
"anfitrión" | [“192.0.2.1”, “192.0.2.2”] | event_id |
$o = array_distinct($ip)
se calcula con $ip
de la etapa anterior y no de la etapa de copia de eventos.
Por último, la sección de condiciones filtrará cada grupo. Dado que esta regla solo comprueba la existencia de $e, la fila anterior producirá una sola detección.
$o
no contiene todos los elementos de $e.principal.ip
porque no todos los elementos cumplen con todas las condiciones de la sección de eventos. Sin embargo, todos los elementos de e.principal.ip
aparecerán en la muestra del evento porque esta usa event_original
.
Indexación de arrays
Puedes indexar arrays en campos repetidos. Para acceder al n-ésimo elemento del campo repetido, usa la sintaxis de lista estándar (los elementos se indexan a partir de 0). Un elemento fuera de rango muestra el valor predeterminado.
$e.principal.ip[0] = "192.168.12.16"
$e.principal.ip[999] = ""
Si hay menos de 1,000 elementos, se evalúa comotrue
.
Restricciones:
- Un índice debe ser un literal de número entero no negativo. Por ejemplo,
$e.principal.ip[-1]
no es válido. - Los valores que tienen un tipo
int
(por ejemplo, un marcador de posición establecido enint
) no cuentan. - La indexación de array no se puede combinar con
any
niall
. Por ejemplo,any $e.intermediary.ip[0]
no es válido. - La indexación de arrays no se puede combinar con la sintaxis de mapa. Por ejemplo,
$e.additional.fields[0]["key"]
no es válido. - Si la ruta del campo contiene varios campos repetidos, todos estos deben usar la indexación de array. Por ejemplo,
$e.intermediary.ip[0]
no es válido porqueintermediary
yip
son campos repetidos, pero solo hay un índice paraip
.
Mensajes repetidos
Cuando se repite un campo message
, se produce un efecto no deseado que reduce la probabilidad de que se produzca una coincidencia. Esto se ilustra en los siguientes ejemplos.
Considera el siguiente evento:
event_repeated_message {
// about is a repeated message field.
about {
// ip is a repeated string field.
ip: [ "192.0.2.1", "192.0.2.2", "192.0.2.3" ]
hostname: "alice"
}
about {
hostname: "bob"
}
}
Como se indica para las expresiones sin modificar en los campos repetidos, se crea una copia temporal del evento para cada elemento del campo repetido. Considera la siguiente regla:
rule repeated_message_1 {
meta:
events:
$e.about.ip = "192.0.2.1"
$e.about.hostname = "bob"
condition:
$e
}
La regla se aplica en las siguientes copias:
texto del evento | about.ip | about.hostname |
---|---|---|
event_copy_1 | “192.0.2.1” | "alice" |
event_copy_2 | “192.0.2.2” | "alice" |
event_copy_3 | "192.0.2.3" | “alicia” |
event_copy_4 | "" | “roberto” |
El evento no coincide con la regla porque no existe una copia del evento que satisfaga todas las expresiones.
Mensajes repetidos y indexación de arrays
Otro comportamiento inesperado puede ocurrir cuando se usa el indexado de array con expresiones no modificadas en campos de mensajes repetidos. Considera la siguiente regla de ejemplo que usa indexación de array:
rule repeated_message_2 {
meta:
events:
$e.about.ip = "192.0.2.1"
$e.about[1].hostname = "bob"
condition:
$e
}
La regla se aplica a las siguientes copias:
texto del evento | about.ip | about[1].hostname |
---|---|---|
event_copy_1 | “192.0.2.1” | "bob" |
event_copy_2 | “192.0.2.2” | "bob" |
event_copy_3 | "192.0.2.3" | “roberto” |
event_copy_4 | "" | “roberto” |
Dado que event_copy_1
satisface todas las expresiones en repeated_message_2
, el evento coincide con la regla.
Esto puede generar un comportamiento inesperado porque la regla repeated_message_1
no tenía indexación de array y no generaba coincidencias, mientras que la regla repeated_message_2
usaba indexación de array y generaba una coincidencia.
Comentarios
Designa comentarios con dos caracteres de barra (// comment
) o comentarios de varias líneas marcados con un asterisco de barras diagonales (/* comment */
), como lo harías en C.
Literales
Se admiten números enteros no negativos y literales de número de punto flotante, de cadena, booleanos y de expresión regular.
Literales de string y de expresión regular
Puedes usar cualquiera de los siguientes caracteres de comillas para encerrar cadenas en YARA-L 2.0. Sin embargo, el texto citado se interpreta de manera diferente según cuál utilices.
Comillas dobles ("): Se usa para cadenas normales. Debe incluir caracteres de escape.
Por ejemplo: “hello\tworld” —\t se interpreta como una tabulaciónAcento grave (`): Úsalo para interpretar todos los caracteres de forma literal.
Por ejemplo: "hello\tworld": \t no se interpreta como una pestaña.
Para las expresiones regulares, tienes dos opciones.
Si deseas usar expresiones regulares directamente sin la función re.regex()
, usa /regex/
para los literales de expresión regular.
También puedes usar literales de cadena como literales de expresión regular cuando usas la función re.regex()
. Ten en cuenta que, para los literales de cadenas de comillas dobles, debes escapar los caracteres de barra invertida con caracteres de barra invertida, lo que puede resultar incómodo.
Por ejemplo, las siguientes expresiones regulares son equivalentes:
re.regex($e.network.email.from, `.*altostrat\.com`)
re.regex($e.network.email.from, ".*altostrat\\.com")
$e.network.email.from = /.*altostrat\.com/
Google recomienda usar caracteres de comillas simples para las cadenas en expresiones regulares para facilitar la lectura.
Operadores
Puedes usar los siguientes operadores en YARA-L:
Operador | Descripción |
= | equal/declaration |
!= | no igual |
< | menor que |
<= | menor o igual que |
> | mayor que |
>= | mayor o igual que |
Variables
En YARA-L 2.0, todas las variables se representan como $<variable name>
.
Puedes definir los siguientes tipos de variables:
Variables de evento: Representan grupos de eventos en forma normalizada (UDM) o eventos de entidad. Especifica las condiciones para las variables de evento en la sección
events
. Para identificar las variables de evento, usa un nombre, una fuente de eventos y campos de eventos. Las fuentes permitidas sonudm
(para eventos normalizados) ygraph
(para eventos de entidad). Si se omite la fuente,udm
se establece como la fuente predeterminada. Los campos de evento se representan como una cadena de .<nombre del campo> (por ejemplo, $e.campo1.campo2). Las cadenas de campos de eventos siempre comienzan desde la fuente de nivel superior (UDM o entidad).Variables de coincidencia: Declara en la sección
match
. Las variables de coincidencia se convierten en campos de agrupación para la consulta, ya que se muestra una fila para cada conjunto único de variables de coincidencia (y para cada período). Cuando la regla encuentra una coincidencia, se muestran los valores de la variable de coincidencia. Especifica qué representa cada variable de coincidencia en la secciónevents
.Variables de marcador de posición: Decláralas y defínelas en la sección
events
. Las variables de marcador de posición son similares a las variables de coincidencia. Sin embargo, puedes usar variables de marcador de posición en la seccióncondition
para especificar las condiciones de coincidencia.
Usa variables de coincidencia y de marcador de posición para declarar relaciones entre campos de eventos mediante condiciones de unión transitivas (consulta la sintaxis de la sección de eventos para obtener más detalles).
Palabras clave
Las palabras clave en YARA-L 2.0 no distinguen entre mayúsculas y minúsculas. Por ejemplo, and
o AND
son equivalentes. Los nombres de las variables no deben entrar en conflicto con las palabras clave. Por ejemplo, $AND
o $outcome
no son válidos.
Las siguientes son palabras clave para las reglas del motor de detección: rule
, meta
, match
, over
, events
, condition
, outcome
, options
, and
, or
, not
, nocase
, in
, regex
, cidr
, before
, after
, all
, any
, if
, max
, min
, sum
, array
, array_distinct
, count
, count_distinct
, is
y null
.
Maps
YARA-L admite el acceso a mapas para structs y etiquetas.
structs y etiquetas
Algunos campos de UDM usan el tipo de datos Struct o Label.
Para buscar un par clave-valor específico en Struct y Label, usa la sintaxis de mapa estándar:
// A Struct field.
$e.udm.additional.fields["pod_name"] = "kube-scheduler"
// A Label field.
$e.metadata.ingestion_labels["MetadataKeyDeletion"] = "startup-script"
El acceso a mapas siempre devuelve una cadena.
Casos admitidos
Sección de eventos y resultados
// Using a Struct field in the events section
events:
$e.udm.additional.fields["pod_name"] = "kube-scheduler"
// Using a Label field in the outcome section
outcome:
$value = array_distinct($e.metadata.ingestion_labels["MetadataKeyDeletion"])
Cómo asignar un valor del mapa a un marcador de posición
$placeholder = $u1.metadata.ingestion_labels["MetadataKeyDeletion"]
Usa un campo de mapa en una condición de unión
// using a Struct field in a join condition between two udm events $u1 and $u2
$u1.metadata.event_type = $u2.udm.additional.fields["pod_name"]
Casos no admitidos
No se admiten mapas en los siguientes casos.
Combina palabras clave any
o all
con un mapa
Por ejemplo, no se admite lo siguiente:
all $e.udm.additional.fields["pod_name"] = "kube-scheduler"
Otros tipos de valores
La sintaxis del mapa solo puede mostrar un valor de cadena. En el caso de los tipos de datos Struct, la sintaxis de mapa solo puede acceder a claves cuyos valores son cadenas. No es posible acceder a claves cuyos valores sean otros tipos primitivos, como números enteros.
Manejo de valores duplicados
Los accesos a mapas siempre devuelven un solo valor. En lo poco común caso límite en el que el acceso al mapa podría referirse a múltiples valores, el acceso devolverá el primer valor de manera determinista.
Esto puede suceder en cualquiera de los siguientes casos:
Una etiqueta tiene una clave duplicada.
La estructura de etiquetas representa un mapa, pero no aplica la unicidad de las claves. Por convención, un mapa debe tener claves únicas, por lo que Google Security Operations no recomienda propagar una etiqueta con claves duplicadas.
El texto de la regla
$e.metadata.ingestion_labels["dupe-key"]
mostraría el primer valor posible,val1
, si se ejecutara en el siguiente ejemplo de datos:// Disrecommended usage of label with a duplicate key: event { metadata{ ingestion_labels{ key: "dupe-key" value: "val1" // This is the first possible value for "dupe-key" } ingestion_labels{ key: "dupe-key" value: "val2" } } }
Una etiqueta tiene un campo repetido de ancestro.
Un campo repetido puede contener una etiqueta como campo secundario. Dos diferentes entradas en el campo repetido de nivel superior pueden contener etiquetas que tengan la misma clave. El texto de la regla
$e.security_result.rule_labels["key"]
devolvería el primer valor posible,val3
, si se ejecuta en el siguiente ejemplo de datos:event { // security_result is a repeated field. security_result { threat_name: "threat1" rule_labels { key: "key" value: "val3" // This is the first possible value for "key" } } security_result { threat_name: "threat2" rule_labels { key: "key" value: "val4" } } }
Funciones
En esta sección, se describen las funciones de YARA-L 2.0 que puedes usar en la detección las reglas del motor de búsqueda y la búsqueda.
Estas funciones se pueden usar en las siguientes partes de una regla YARA-L:
events
.BOOL_CLAUSE
de un condicional en la sección de resultados.
arrays.concat
arrays.concat(string_array, string_array)
Descripción
Muestra un nuevo array de cadenas copiando elementos de las matrices de cadenas originales.
Tipos de datos de param
ARRAY_STRINGS
, ARRAY_STRINGS
Tipo de datos que se muestra
ARRAY_STRINGS
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se concatenan dos arrays de cadenas diferentes.
arrays.concat(["test1", "test2"], ["test3"]) = ["test1", "test2", "test3"]
Ejemplo 2
En el siguiente ejemplo, se concatenan arreglos con una string vacía.
arrays.concat([""], [""]) = ["", ""]
Ejemplo 3
En el siguiente ejemplo, se concatenan arrays vacíos.
arrays.concat([], []) = []
arrays.join_string
arrays.join_string(array_of_strings, optional_delimiter)
Descripción
Convierte un array de cadenas en una sola cadena separada por el parámetro opcional. Si no se proporciona un delimitador, se usa la cadena vacía.
Tipos de datos de parámetros
ARRAY_STRINGS
, STRING
Tipo de datos que se muestra
STRING
Muestras de código
Estos son algunos ejemplos de cómo usar la función:
Ejemplo 1
En este ejemplo, se une un array con elementos no nulos y un delimitador.
arrays.join_string(["foo", "bar"], ",") = "foo,bar"
Ejemplo 2
En este ejemplo, se une un array con un elemento nulo y un delimitador.
arrays.join_string(["foo", NULL, "bar"], ",") = "foo,bar"
Ejemplo 3
En este ejemplo, se une un array con elementos no nulos y sin delimitador.
arrays.join_string(["foo", "bar"]) = "foobar"
arrays.length
arrays.length(repeatedField)
Descripción
Muestra la cantidad de elementos de campo repetidos.
Tipos de datos de parámetros
LIST
Tipo de datos que se muestra
NUMBER
Muestras de código
Ejemplo 1
Muestra la cantidad de elementos de campo repetidos.
arrays.length($e.principal.ip) = 2
Ejemplo 2
Si hay varios campos repetidos a lo largo de la ruta, muestra la cantidad total de elementos de campo repetidos.
arrays.length($e.intermediary.ip) = 3
arrays.max
arrays.max(array_of_ints_or_floats)
Descripción
Muestra el elemento mayor de un array o cero si el array está vacío.
Tipos de datos de param
ARRAY_INTS|ARRAY_FLOATS
Tipo de datos que se muestra
FLOAT
Muestras de código
Estos son algunos ejemplos de cómo usar la función:
Ejemplo 1
En este ejemplo, se muestra el elemento mayor en un array de números enteros.
arrays.max([10, 20]) = 20.000000
Ejemplo 2
En este ejemplo, se muestra el elemento mayor en un array de números de punto flotante.
arrays.max([10.000000, 20.000000]) = 20.000000
arrays.min
arrays.min(array_of_ints_or_floats[, ignore_zeros=false])
Descripción
Muestra el elemento más pequeño de un array o cero si el array está vacío. Si el segundo argumento opcional se establece en verdadero, se ignoran los elementos iguales a cero.
Tipos de datos de param
ARRAY_INTS|ARRAY_FLOATS
, BOOL
Tipo de datos que se muestra
FLOAT
Muestras de código
Estos son algunos ejemplos de cómo usar la función:
Ejemplo 1
En este ejemplo, se muestra el elemento más pequeño de un array de números enteros.
arrays.min([10, 20]) = 10.000000
Ejemplo 2
En este ejemplo, se muestra el elemento más pequeño de un array de números de punto flotante.
arrays.min([10.000000, 20.000000]) = 10.000000
Ejemplo 3
En este ejemplo, se muestra el elemento más pequeño en un array de números de punto flotante, mientras se ignoran los ceros.
arrays.min([10.000000, 20.000000, 0.0], true) = 10.000000
arrays.size
arrays.size( array )
Descripción
Muestra el tamaño del arreglo. Muestra 0 para un arreglo vacío.
Tipos de datos de param
ARRAY_STRINGS|ARRAY_INTS|ARRAY_FLOATS
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se usa un array de cadenas que contiene dos elementos.
arrays.size(["test1", "test2"]) = 2
Ejemplo 2
En este ejemplo, se usa un array de int que contiene 3 elementos.
arrays.size([1, 2, 3]) = 3
Ejemplo 3
En este ejemplo, se usa un array de número de punto flotante que contiene 1 elemento
arrays.size([1.200000]) = 1
Ejemplo 4
En este ejemplo, se usa un array vacío.
arrays.size([]) = 0
arrays.index_to_int
arrays.index_to_int(array_of_inputs, index)
Descripción
Muestra el valor de un índice determinado en un array como un número entero. Cuando el índice es un número negativo, el valor se recupera de la parte posterior del array.
Tipos de datos de param
ARRAY_STRINGS|ARRAY_INTS|ARRAY_FLOATS
, INT
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
Esta llamada a función muestra 0 cuando el valor en el índice es una cadena no numérica.
arrays.index_to_int(["str0", "str1", "str2"], 1) = 0
Ejemplo 2
Esta función muestra el elemento en el índice -1.
arrays.index_to_int(["44", "11", "22", "33"], -1) = 33
Ejemplo 3
Muestra 0 para el elemento fuera de los límites.
arrays.index_to_int(["44", "11", "22", "33"], 5) = 0
Ejemplo 4
Esta función recupera el elemento del array de números de punto flotante en el índice 2.
arrays.index_to_int([1.100000, 1.200000, 1.300000], 1) = 1
Ejemplo 5
Esta función recupera el elemento del array int en el índice 0.
arrays.index_to_int([1, 2, 3], 2) = 1
cast.as_bool
cast.as_bool(string_or_int)
Descripción
La función convierte un valor de int o cadena en un valor booleano. Las llamadas a función con valores que no se pueden convertir mostrarán FALSE. Muestra VERDADERO solo para el número entero 1 y la cadena "true" que no distingue mayúsculas de minúsculas.
Tipos de datos de parámetros
INT|STRING
Tipo de datos que se muestra
BOOL
Muestras de código
Ejemplo 1
En este ejemplo, se muestra cómo transmitir una cadena no booleana.
cast.as_bool("123") = false
Ejemplo 2
Número entero verdadero (1)
cast.as_bool(1) = true
Ejemplo 3
Cadena verdadera
cast.as_bool("true") = true
Ejemplo 4
Cadena de verdad mayúscula
cast.as_bool("TRUE") = true
Ejemplo 5
Número entero negativo
cast.as_bool(-1) = false
Ejemplo 6
Número entero falso (0)
cast.as_bool(0) = false
Ejemplo 7
string vacía
cast.as_bool("") = false
cast.as_float
cast.as_float(string_to_cast)
Descripción
Convierte una cadena numérica en un número de punto flotante. Cualquier llamada a función con valores que no se puedan transmitir muestra 0. Los números de punto flotante mantienen una precisión de hasta 7 dígitos decimales.
Tipos de datos de param
STRING
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
Si conviertes una cadena no numérica, el resultado es 0.
cast.as_float("str") = 0.0000000
Ejemplo 2
La conversión de una cadena vacía muestra 0.
cast.as_float("") = 0.0000000
Ejemplo 3
La conversión de una string numérica válida muestra un valor flotante.
cast.as_float("1.012345678") = 1.0123456
Fingerprint
hash.fingerprint2011(byteOrString)
Descripción
Esta función calcula el hash fingerprint2011
de una secuencia de bytes de entrada
o cadena. Esta función muestra un valor de INT
sin signo en el rango [2, 0xFFFFFFFFFFFFFFFF]
.
Tipos de datos de parámetros
BTYE
, STRING
Tipo de datos que se muestra
INT
Muestra de código
id_fingerprint = hash.fingerprint2011("user123")
grupo
group(field1, field2, field3, ...)
Descripción
Agrupa campos de un tipo similar en una variable de marcador de posición.
En la búsqueda de UDM, agrupados campos se usan para buscar en varios campos del mismo tipo. El grupo es similar a los campos agrupados, excepto que te permite seleccionar los campos que deseas se agrupan para activar una detección. Puedes usar la función de grupo para recopilar información sobre una entidad específica (por ejemplo, un nombre de host, una dirección IP o un ID de usuario) en diferentes tipos de sustantivos.
Muestras de código
Ejemplo 1
Agrupa todas las direcciones IP y proporciona un recuento descendente de la dirección IP más frecuente en el intervalo de tiempo analizado.
$ip = group(principal.ip, about.ip, target.ip)
$ip != ""
match:
$ip
outcome:
$count = count_distinct(metadata.id)
order:
$count desc
hash.sha256
hash.sha256(string)
Descripción
Muestra un hash SHA-256 de la cadena de entrada.
Tipos de datos de parámetros
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se muestra el hash SHA-256 cuando la entrada es una string válida.
hash.sha256("str") = "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
Ejemplo 2
En este ejemplo, se muestra el hash SHA-256 cuando la entrada es una cadena vacía.
hash.sha256("") = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
math.abs
math.abs(numericExpression)
Descripción
Muestra el valor absoluto de una expresión de número entero o de punto flotante.
Tipos de datos de parámetros
NUMBER
Tipo de datos que se muestra
NUMBER
Muestras de código
Ejemplo 1
En este ejemplo, se muestra el valor True si el evento dura más de 5 minutos desde ese momento
especificado (en segundos del epoch Unix), sin importar si el evento llegó
antes o después del tiempo especificado. Una llamada a math.abs
no puede depender de varias variables o marcadores de posición. Por ejemplo, no puedes reemplazar el
de tiempo codificado de 1643687343 en el siguiente ejemplo con
$e2.metadata.event_timestamp.seconds
300 < math.abs($e1.metadata.event_timestamp.seconds - 1643687343)
math.ceil
math.ceil(number)
Descripción
Muestra el número entero más pequeño que no sea menor que el número especificado (redondeo hacia arriba). Se mostrará 0 si la entrada es nula o demasiado grande para caber en un int64.
Tipos de datos de param
FLOAT
Tipo de datos que se muestra
INT
Muestras de código
En esta sección, se incluyen ejemplos del uso de math.ceil
.
Ejemplo 1
En este ejemplo, se muestra el cielorraso de un número entero.
math.ceil(2.000000) = 2
Ejemplo 2
En este ejemplo, se muestra el techo de un número negativo.
math.ceil(-1.200000) = -1
Ejemplo 3
En este ejemplo, se muestra 0 como el límite máximo de un número que es demasiado grande para un número entero de 64 bits.
math.ceil(184467440737095516160.0) = 0
math.floor
math.floor(float_val)
Descripción
Muestra el valor entero más grande que no sea mayor que el valor proporcionado (redondeando hacia abajo). Muestra 0 si la entrada es nula o demasiado grande para caber en un int64.
Tipos de datos de parámetros
FLOAT
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra un caso de número positivo.
math.floor(1.234568) = 1
Ejemplo 2
En este ejemplo, se muestra el uso de mayúsculas y minúsculas de un número negativo.
math.floor(-1.234568) = -2
Ejemplo 3
En este ejemplo, se muestra el caso de cero.
math.floor(0.000000) = 0
math.geo_distance
math.geo_distance(longitude1, latitude1, longitude2, latitude2))
Descripción
Muestra la distancia entre dos ubicaciones geográficas (coordenadas). El resultado será -1 si la coordenada geográfica no es válida.
Tipos de datos de param
FLOAT
, FLOAT
, FLOAT
y FLOAT
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra la distancia cuando todos los parámetros son coordenadas válidas.
math.geo_distance(-122.020287, 37.407574, -122.021810, 37.407574) = 134.564318
Ejemplo 2
En este ejemplo, se muestra la distancia cuando uno de los parámetros es una coordenada truncada.
math.geo_distance(-122.000000, 37.407574, -122.021810, 37.407574) = 1926.421905
Ejemplo 3
En este ejemplo, se muestra -1 cuando uno de los parámetros es una coordenada no válida.
math.geo_distance(-122.897680, 37.407574, -122.021810, 97.407574) = -1.000000
Ejemplo 4
Este ejemplo muestra 0 cuando las coordenadas son las mismas.
math.geo_distance(-122.897680, 37.407574, -122.897680, 37.407574) = 0.000000
math.is_increasing
math.is_increasing(num1, num2, num3)
Descripción
Toma una lista de valores numéricos (números enteros o dobles) y muestra True
si los valores están en orden ascendente y False
de lo contrario.
Tipos de datos de param
INT|FLOAT
, INT|FLOAT
y INT|FLOAT
Tipo de datos que se muestra
BOOL
Muestras de código
Ejemplo 1
Este ejemplo incluye valores similares a marcas de tiempo en segundos.
math.is_increasing(1716769112, 1716769113, 1716769114) = true
Ejemplo 2
Este ejemplo incluye un doble negativo, un INT64 cero y un INT64 positivo.
math.is_increasing(-1.200000, 0, 3) = true
Ejemplo 3
Este ejemplo incluye un doble negativo, un INT64 cero y un INT64 negativo.
math.is_increasing(-1.200000, 0, -3) = false
Ejemplo 4
En este ejemplo, se incluyen dos dobles negativos y un valor INT64 cero.
math.is_increasing(-1.200000, -1.50000, 0) = false
Ejemplo 5
Este ejemplo incluye un doble negativo y dos valores que son iguales.
math.is_increasing(-1.200000, 0, 0) = false
math.log
math.log(numericExpression)
Descripción
Muestra el valor de registro natural de una expresión de número entero o de número de punto flotante.
Tipos de datos de parámetros
NUMBER
Tipo de datos que se muestra
NUMBER
Muestras de código
Ejemplo 1
math.log($e1.network.sent_bytes) > 20
math.pow
math.pow(base, exponent)
Descripción
Muestra el valor del primer arg elevado a la potencia del segundo arg. Muestra 0 en caso de desbordamiento.
Tipos de datos de param
base: INT|FLOAT
exponente: INT|FLOAT
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra el uso de mayúsculas y minúsculas de un número entero.
math.pow(2, 2) // 4.00
Ejemplo 2
En este ejemplo, se muestra el caso base de una fracción.
math.pow(2.200000, 3) // 10.648
Ejemplo 3
En este ejemplo, se muestra una base de fracción y un caso de potencia.
math.pow(2.200000, 1.200000) // 2.575771
Ejemplo 4
En este ejemplo, se muestra un caso de alimentación negativa.
math.pow(3, -3) // 0.037037
Ejemplo 5
En este ejemplo, se muestra una caja de alimentación con fracciones.
math.pow(3, -1.200000) // 0.267581
Ejemplo 6
En este ejemplo, se muestra un caso base negativo.
math.pow(-3, -3) // -0.037037
Ejemplo 7
En este ejemplo, se muestra un caso base de cero.
math.pow(0, 3) // 0
Ejemplo 8
En este ejemplo, se muestra una caja de alimentación cero.
math.pow(9223372036854775807, 0) // 1
Ejemplo 9
En este ejemplo, se muestra un caso de base grande.
math.pow(9223372036854775807, 1.200000) // 57262152889751593549824
math.random
math.random()
Descripción
Genera un valor seudoaleatorio de tipo DOUBLE en el rango de [0, 1)
, el cual incluye 0 pero no 1.
Tipo de datos que se muestra
FLOAT
Muestras de código
En el siguiente ejemplo, se verifica si el valor aleatorio está en el rango [0, 1)
.
none
if(math.random() >= 0 and math.random() < 1) = true
math.round
math.round(numericExpression, decimalPlaces)
Descripción
Muestra un valor redondeado al número entero más cercano o al número de decimales especificado.
Tipos de datos de param
NUMBER
Tipo de datos que se muestra
NUMBER
Muestras de código
math.round(10.7) // returns 11
math.round(1.2567, 2) // returns 1.25
math.round(-10.7) // returns -11
math.round(-1.2) // returns -1
math.round(4) // returns 4, math.round(integer) returns the integer
métricas
Las funciones de métricas pueden agregar grandes cantidades de datos históricos. Puedes usar esto en tu regla con metrics.functionName()
en la sección de resultados.
Para obtener más información, consulta Métricas de YARA-L.
net.ip_in_range_cidr
net.ip_in_range_cidr(ipAddress, subnetworkRange)
Descripción
Muestra true
cuando la dirección IP proporcionada se encuentra dentro de la subred especificada.
Puedes usar YARA-L para buscar eventos de la AUA en todas las direcciones IP
de una subred con la sentencia net.ip_in_range_cidr()
.
Se admite IPv4 e IPv6.
Para buscar en un rango de direcciones IP, especifica un campo de UDM de IP y un CIDR del rango de destino de la ruta. YARA-L puede controlar campos de direcciones IP únicos y repetidos.
Para buscar en un rango de direcciones IP, especifica un campo de UDM ip
y un rango de enrutamiento entre dominios sin clases (CIDR). YARA-L puede controlar campos de direcciones IP singulares y repetidos.
Tipos de datos de param
STRING
y STRING
Tipo de datos que se muestra
BOOL
Muestras de código
Ejemplo 1
Ejemplo de IPv4:
net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")
Ejemplo 2
Ejemplo de IPv6:
net.ip_in_range_cidr($e.network.dhcp.yiaddr, "2001:db8::/32")
Para ver una regla de ejemplo que usa la sentencia net.ip_in_range_cidr()
, consulta la regla de ejemplo en Evento único dentro de un rango de direcciones IP.
re.regex
Puedes definir la coincidencia de expresiones regulares en YARA-L 2.0 con cualquiera de las siguientes sintaxis:
Uso de la sintaxis de YARA-L: Relacionado con eventos. La siguiente es una representación genérica de esta sintaxis:
$e.field = /regex/
Con la sintaxis YARA-L: Como una función que toma los siguientes parámetros:
- Campo al que se aplica la expresión regular.
- Expresión regular especificada como una cadena.
La siguiente es una representación genérica de esta sintaxis:
re.regex($e.field, `regex`)
Descripción
Esta función muestra true
si la cadena contiene una subcadena que coincide con la expresión regular proporcionada. No es necesario agregar .*
al principio ni al final de la expresión regular.
Notas
- Para que coincida con la cadena exacta o solo con un prefijo o sufijo, incluye los caracteres de ancla
^
(inicio) y$
(fin) en la expresión regular. Por ejemplo,/^full$/
coincide exactamente con"full"
, mientras que/full/
podría coincidir."fullest"
,"lawfull"
y"joyfully"
. - Si el campo UDM incluye caracteres de nueva línea,
regexp
solo coincide con primera línea del campo UDM. Para aplicar la coincidencia de campos UDM completa, agrega un(?s)
al la expresión regular. Por ejemplo, reemplaza/.*allUDM.*/
por/(?s).*allUDM.*/
. - Puedes usar el modificador
nocase
después de las cadenas para indicar que la búsqueda debe ignorar el uso de mayúsculas.
Tipos de datos de param
STRING
, STRING
Tipos de expresiones de parámetros
ANY
, ANY
Tipo de datos que se muestra
BOOL
Muestras de código
Ejemplo 1
// Equivalent to $e.principal.hostname = /google/
re.regex($e.principal.hostname, "google")
re.capture
re.capture(stringText, regex)
Descripción
Captura (extrae) datos de una cadena con el patrón de expresión regular proporcionado en el argumento.
Esta función toma dos argumentos:
stringText
: Es la cadena original en la que se buscará.regex
: Es la expresión regular que indica el patrón que se debe buscar.
La expresión regular puede contener 0 o 1 grupos de captura entre paréntesis. Si la expresión regular contiene 0 grupos de captura, la función muestra la primera substring coincidente completa. Si la expresión regular contiene 1 grupo de captura, muestra la primera substring coincidente para el grupo de captura. Definir dos o más grupos de captura devuelve un error del compilador.
Tipos de datos de parámetros
STRING
y STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, si $e.principal.hostname
contiene "aaa1bbaa2" lo siguiente sería verdadero, ya que la función
muestra la primera instancia. En este ejemplo, no hay grupos de captura.
"aaa1" = re.capture($e.principal.hostname, "a+[1-9]")
Ejemplo 2
En este ejemplo, se capta todo lo que está después del símbolo @ en un correo electrónico. Si el botón
El campo $e.network.email.from
es test@google.com
; en el ejemplo, se muestra
google.com
El siguiente ejemplo contiene un grupo de captura.
"google.com" = re.capture($e.network.email.from , "@(.*)")
Ejemplo 3
Si la expresión regular no coincide con ninguna subcadena del texto, el
muestra una cadena vacía. Para omitir los eventos en los que no se produce ninguna coincidencia, excluye la cadena vacía, lo que es especialmente importante cuando usas re.capture()
con una desigualdad:
// Exclude the empty string to omit events where no match occurs.
"" != re.capture($e.network.email.from , "@(.*)")
// Exclude a specific string with an inequality.
"google.com" != re.capture($e.network.email.from , "@(.*)")
re.replace
re.replace(stringText, replaceRegex, replacementText)
Descripción
Realiza un reemplazo de expresiones regulares.
Esta función toma tres argumentos:
stringText
: La cadena original.replaceRegex
: Es la expresión regular que indica el patrón que se debe buscar.replacementText
: Es el texto que se insertará en cada coincidencia.
Muestra una cadena nueva derivada de la stringText
original, en la que todas las substrings que coinciden con el patrón en replaceRegex
se reemplazan por el valor en replacementText
. Puedes usar dígitos con escape de barra invertida (de \1
a \9
) dentro de replacementText
para insertar texto que coincida con el grupo entre paréntesis correspondiente en el patrón replaceRegex
. Usa \0
para hacer referencia a todo el texto coincidente.
La función reemplaza las coincidencias no superpuestas y priorizará reemplazar la primera ocurrencia que se encuentre. Por ejemplo, re.replace("banana", "ana", "111")
.
muestra la cadena “b111na”.
Tipos de datos de parámetros
STRING
, STRING
, STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se captura todo después del símbolo @
en un correo electrónico, se reemplaza com
por org
y, luego, se muestra el resultado. Observa el uso de funciones anidadas.
"email@google.org" = re.replace($e.network.email.from, "com", "org")
Ejemplo 2
En este ejemplo, se usan dígitos con escape de barra invertida en el argumento replacementText
para hacer referencia a coincidencias con el patrón replaceRegex
.
"test1.com.google" = re.replace(
$e.principal.hostname, // holds "test1.test2.google.com"
"test2\.([a-z]*)\.([a-z]*)",
"\\2.\\1" // \\1 holds "google", \\2 holds "com"
)
Ejemplo 3
Ten en cuenta los siguientes casos cuando trabajes con strings vacías y re.replace()
:
Usa una cadena vacía como replaceRegex
:
// In the function call below, if $e.principal.hostname contains "name",
// the result is: 1n1a1m1e1, because an empty string is found next to
// every character in `stringText`.
re.replace($e.principal.hostname, "", "1")
Para reemplazar una cadena vacía, puedes usar "^$"
como replaceRegex
:
// In the function call below, if $e.principal.hostname contains the empty
// string, "", the result is: "none".
re.replace($e.principal.hostname, "^$", "none")
sample_rate
optimization.sample_rate(byteOrString, rateNumerator, rateDenominator)
Descripción
Esta función determina si se debe incluir un evento basado en una variable estrategia de muestreo. Esta función muestra lo siguiente:
true
para una fracción de los valores de entrada, equivalente a (rateNumerator
/rateDenominator
), que indique que el evento debe incluirse en la muestra.false
que indica que el evento no se debe incluir en la muestra.
Esta función es útil para situaciones de optimización en las que desea procesar solo un subconjunto de eventos. Equivale a:
hash.fingerprint2011(byteOrString) % rateDenominator < rateNumerator
Tipos de datos de parámetros
- byteOrString: Expresión que se evalúa como
BYTE
oSTRING
. - rateNumerator: “INT”
- rateDenominator: 'INT'
Tipo de datos que se muestra
BOOL
Muestra de código
events:
$e.metadata.event_type = "NETWORK_CONNECTION"
$asset_id = $e.principal.asset.asset_id
optimization.sample_rate($e.metadata.id, 1, 5) // Only 1 out of every 5 events
match:
$asset_id over 1h
outcome:
$event_count = count_distinct($e.metadata.id)
// estimate the usage by multiplying by the inverse of the sample rate
$usage_past_hour = sum(5.0 * $e.network.sent_bytes)
condition:
// Requiring a certain number of events after sampling avoids bias (e.g. a
// device with just 1 connection will still show up 20% of the time and
// if we multiply that traffic by 5, we'll get an incorrect estimate)
$e and ($usage_past_hour > 1000000000) and $event_count >= 100
strings.base64_decode
strings.base64_decode(encodedString)
Descripción
Muestra una cadena que contiene la versión decodificada en base64 de la cadena codificada.
Esta función toma una cadena codificada en base64 como argumento. Si encodedString
no es una cadena codificada en base64 válida, la función muestra encodedString
sin cambios.
Tipos de datos de param
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
"test" = strings.base64_decode($e.principal.domain.name)
strings.coalesce
strings.coalesce(a, b, c, ...)
Descripción
Esta función toma una cantidad ilimitada de argumentos y muestra el valor de la primera expresión que no se evalúa como una cadena vacía (por ejemplo, "valor distinto de cero"). Si todos los argumentos se evalúan como una cadena vacía, la llamada a función muestra una cadena vacía.
Los argumentos pueden ser literales, campos de eventos o llamadas a funciones. Todos los argumentos deben ser del tipo STRING
. Si algún argumento es campos de evento, los atributos deben pertenecer al mismo evento.
Tipos de datos de param
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se incluyen variables de cadena como argumentos. La condición
se evalúa como verdadero cuando (1) $e.network.email.from
es suspicious@gmail.com
o
(2) $e.network.email.from
está vacío y $e.network.email.to
está
suspicious@gmail.com
"suspicious@gmail.com" = strings.coalesce($e.network.email.from, $e.network.email.to)
Ejemplo 2
En el siguiente ejemplo, se llama a la función coalesce
con más de dos
argumentos. Esta condición compara la primera dirección IP no nula del evento $e
.
con los valores de la lista de referencia ip_watchlist
. El orden en que se combinan los argumentos en esta llamada es el mismo que el orden en que se enumeran en la condición de la regla:
- Primero se evalúa
$e.principal.ip
. - A continuación, se evalúa
$e.src.ip
. - A continuación, se evalúa
$e.target.ip
. - Por último, la cadena "No IP" se devuelve como un valor predeterminado si el
ip
anterior no están establecidos.
strings.coalesce($e.principal.ip, $e.src.ip, $e.target.ip, "No IP") in %ip_watchlist
Ejemplo 3
En el siguiente ejemplo, se intenta unir principal.hostname
del evento $e1
y del evento $e2
. Se mostrará un error del compilador porque los argumentos son
variadas variables de evento.
// returns a compiler error
"test" = strings.coalesce($e1.principal.hostname, $e2.principal.hostname)
strings.concat
strings.concat(a, b, c, ...)
Descripción
Muestra la concatenación de una cantidad ilimitada de elementos, cada uno de los cuales puede ser una cadena, un número entero o un número de punto flotante.
Si algún argumento es campos de evento, los atributos deben pertenecer al mismo evento.
Tipos de datos de param
STRING
, FLOAT
, INT
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
El siguiente ejemplo incluye una variable de cadena y una variable de número entero como
argumentos. Tanto principal.hostname
como principal.port
provienen del mismo
evento, $e
, y se concatenan para mostrar una cadena.
"google:80" = strings.concat($e.principal.hostname, ":", $e.principal.port)
Ejemplo 2
En el siguiente ejemplo, se incluyen una variable de cadena y un literal de cadena como argumentos.
"google-test" = strings.concat($e.principal.hostname, "-test") // Matches the event when $e.principal.hostname = "google"
Ejemplo 3
En el siguiente ejemplo, se incluye una variable de cadena y un literal de número de punto flotante como argumentos. Cuando se representan como cadenas, los números de punto flotante que son números enteros tienen formato sin punto decimal (por ejemplo, 1.0 se representa como “1”). Además, los números de punto flotante que superan los dieciséis dígitos decimales se truncan al decimosexto decimal.
"google2.5" = strings.concat($e.principal.hostname, 2.5)
Ejemplo 4
El siguiente ejemplo incluye una variable de cadena, un literal de cadena,
una variable de número entero y un literal de número de punto flotante como argumentos. Todas las variables provienen del mismo evento, $e
, y se concatenan con las literales para mostrar una cadena.
"google-test802.5" = strings.concat($e.principal.hostname, "-test", $e.principal.port, 2.5)
Ejemplo 5
En el siguiente ejemplo, se intenta concatenar principal.port a partir del evento $e1
,
con principal.hostname
del evento $e2
. Se mostrará un error del compilador porque los argumentos son diferentes variables de eventos.
// Will not compile
"test" = strings.concat($e1.principal.port, $e2.principal.hostname)
strings.contains
strings.contains( str, substr )
Descripción
Muestra el valor true si una string determinada contiene la subcadena especificada. De lo contrario, muestra un valor falso.
Tipos de datos de param
STRING
y STRING
Tipo de datos que se muestra
BOOL
Muestras de código
Ejemplo 1
Este ejemplo muestra un valor verdadero porque la cadena tiene una substring "is".
strings.contains("thisisastring", "is") = true
Ejemplo 2
En este ejemplo, el resultado es falso porque la string no tiene la subcadena “that”.
strings.contains("thisisastring", "that") = false
strings.count_substrings
strings.count_substrings(string_to_search_in, substring_to_count)
Descripción
Cuando se proporciona una cadena y una subcadena, muestra un int64 del recuento de ocurrencias no superpuestas de la subcadena dentro de la cadena.
Tipos de datos de param
STRING
y STRING
Tipo de datos que se muestra
INT
Muestras de código
Esta sección contiene ejemplos que calculan la cantidad de veces que una subcadena aparece en una cadena determinada.
Ejemplo 1
En este ejemplo, se usa una cadena no nula y un carácter de subcadena único no nulo.
strings.count_substrings("this`string`has`four`backticks", "`") = 4
Ejemplo 2
En este ejemplo, se usa una cadena no nula y una subcadena no nula mayor que un carácter.
strings.count_substrings("str", "str") = 1
Ejemplo 3
En este ejemplo, se usa una cadena no nula y una subcadena vacía.
strings.count_substrings("str", "") = 0
Ejemplo 4
En este ejemplo, se usa una cadena vacía y una subcadena no nula mayor que un carácter.
strings.count_substrings("", "str") = 0
Ejemplo 5
En este ejemplo, se usa una cadena vacía y una subcadena vacía.
strings.count_substrings("", "") = 0
Ejemplo 6
En este ejemplo, se usa una cadena no nula y una subcadena no nula que es mayor que un carácter y mayor que una ocurrencia.
strings.count_substrings("fooABAbarABAbazABA", "AB") = 3
Ejemplo 7
En este ejemplo, se usa una cadena no nula y una subcadena no nula que es mayor que un carácter y más de un caso. Destaca la limitación con ocurrencias de subcadenas superpuestas.
strings.count_substrings("ABABABA", "ABA") = 2
strings.extract_domain
strings.extract_domain(url_string)
Descripción
Extrae el dominio de una cadena.
Tipos de datos de param
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se muestra una cadena vacía
strings.extract_domain("") = ""
Ejemplo 2
cadena aleatoria, no una URL
strings.extract_domain("1234") = ""
Ejemplo 3
varias espaldas
strings.extract_domain("\\\\") = ""
Ejemplo 4
caracteres que no son alfabéticos se manejan de forma elegante
strings.extract_domain("http://例子.卷筒纸.中国") = "卷筒纸.中国"
Ejemplo 5
Cómo controlar los URI
strings.extract_domain("mailto:?to=&subject=&body=") = ""
Ejemplo 6
varios caracteres antes de la URL real
strings.extract_domain(" \t !$5*^)&dahgsdfs;http://www.google.com") = "google.com"
Ejemplo 7
caracteres especiales en el URI #
strings.extract_domain("test#@google.com") = ""
Ejemplo 8
caracteres especiales en la URL #
strings.extract_domain("https://test#@google.com") = ""
Ejemplo 9
caso de prueba con resultado positivo
strings.extract_domain("https://google.co.in") = "google.co.in"
strings.extract_hostname
strings.extract_hostname(string)
Descripción
Extrae el nombre de host de una cadena. Esta función distingue mayúsculas de minúsculas.
Tipos de datos de param
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se muestra una cadena vacía.
strings.extract_hostname("") = ""
Ejemplo 2
cadena aleatoria, no una URL
strings.extract_hostname("1234") = "1234"
Ejemplo 3
varias barras inversas
strings.extract_hostname("\\\\") = ""
Ejemplo 4
Se manejan correctamente los caracteres que no son en inglés
strings.extract_hostname("http://例子.卷筒纸.中国") = "例子.卷筒纸.中国"
Ejemplo 5
Cómo controlar los URI
strings.extract_hostname("mailto:?to=&subject=&body=") = "mailto"
Ejemplo 6
varios caracteres antes de la URL real
strings.extract_hostname(" \t !$5*^)&dahgsdfs;http://www.google.com") = "www.google.com"
Ejemplo 7
caracteres especiales en el URI #
strings.extract_hostname("test#@google.com") = "test"
Ejemplo 8
caracteres especiales en la URL #
strings.extract_hostname("https://test#@google.com") = "test"
strings.from_hex
strings.from_hex(hex_string)
Descripción
Muestra los bytes asociados con la cadena hexadecimal determinada.
Tipos de datos de param
STRING
Tipo de datos que se muestra
BYTES
Muestras de código
Obtiene los bytes asociados con una string hexadecimal determinada.
Ejemplo 1
En este ejemplo, se muestran conversiones de caracteres que no son hexadecimales.
strings.from_hex("str") // returns empty bytes
Ejemplo 2
En este ejemplo, se muestra una entrada con una cadena vacía.
strings.from_hex("") // returns empty bytes
Ejemplo 3
En este ejemplo, se muestra la conversión de cadenas hexadecimales.
strings.from_hex("1234") // returns 1234 bytes
Ejemplo 4
En este ejemplo, se muestra la conversión de caracteres que no son ASCII.
strings.from_hex("筒纸.中国") // returns empty bytes
strings.ltrim
strings.ltrim(string_to_trim, cutset)
Descripción
Corta los espacios en blanco iniciales de una cadena determinada. Esta función quita los caracteres iniciales presentes en ese conjunto de corte.
Tipos de datos de parámetros
STRING
y STRING
Tipo de datos que se muestra
STRING
Muestras de código
Los siguientes son ejemplos de casos de uso.
Ejemplo 1
En este ejemplo, se usan el mismo primer y segundo argumento.
strings.ltrim("str", "str") = ""
Ejemplo 2
En este ejemplo, se usa una cadena vacía como segundo argumento.
strings.ltrim("str", "") = "str"
Ejemplo 3
En este ejemplo, se usa una cadena vacía como primer argumento y una cadena como segundo argumento.
strings.ltrim("", "str") = ""
Ejemplo 4
En este ejemplo, se usan cadenas que contienen espacios en blanco y una cadena como segundo argumento.
strings.ltrim("a aastraa aa ", " a") = "straa aa "
strings.reverse
strings.reverse(STRING)
Descripción
Muestra una cadena inversa de la cadena de entrada.
Tipos de datos de param
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se pasa una cadena corta.
strings.reverse("str") = "rts" // The function returns 'rts'.
Ejemplo 2
En el siguiente ejemplo, se pasa una cadena vacía.
strings.reverse("") = ""
Ejemplo 3
En el siguiente ejemplo, se pasa un palíndromo.
strings.reverse("tacocat") = "tacocat"
strings.rtrim
strings.rtrim(string_to_trim, cutset)
Descripción
Quita los espacios en blanco finales de una cadena determinada. Quita los caracteres finales que están presentes en ese conjunto de cortes.
Tipos de datos de parámetros
STRING
y STRING
Tipo de datos que se muestra
STRING
Muestras de código
Los siguientes son ejemplos de casos de uso.
Ejemplo 1
En el siguiente ejemplo, se pasa la misma cadena como primer y segundo argumento.
strings.rtrim("str", "str") = ""
Ejemplo 2
En el siguiente ejemplo, se pasa una cadena vacía como segundo argumento.
strings.rtrim("str", "") = "str"
Ejemplo 3
En el siguiente ejemplo, se pasa una cadena vacía como primer argumento y una cadena no vacía como segundo argumento.
strings.rtrim("", "str") = ""
Ejemplo 4
En el siguiente ejemplo, se pasa una cadena que contiene espacios en blanco como primer argumento y una cadena no vacía como segundo argumento.
strings.rtrim("a aastraa aa ", " a") = "a aasstr"
strings.to_lower
strings.to_lower(stringText)
Descripción
Esta función toma una cadena de entrada y muestra una cadena después de cambiar todos los caracteres a minúsculas.
Tipos de datos de parámetros
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se muestra true
.
"test@google.com" = strings.to_lower($e.network.email.to)
strings.to_upper
strings.to_upper(string_val)
Descripción
Muestra la cadena original con todos los caracteres alfabéticos en mayúsculas.
Tipos de datos de parámetros
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se muestra el argumento proporcionado en mayúsculas.
strings.to_upper("example") = "EXAMPLE"
strings.trim
strings.trim(string_to_trim, cutset)
Descripción
Recorta los espacios en blanco iniciales y finales de una cadena determinada. Además, quita los caracteres no deseados (especificados por el argumento cutset) de la cadena de entrada.
Tipos de datos de parámetros
STRING
y STRING
Tipo de datos que se muestra
STRING
Muestras de código
Los siguientes son ejemplos de casos de uso.
Ejemplo 1
En el siguiente ejemplo, se pasa la misma cadena como la cadena de entrada y el conjunto de corte, lo que genera una cadena vacía.
strings.trim("str", "str") // ""
Ejemplo 2
En el siguiente ejemplo, se pasa una cadena vacía como el conjunto de cortes, lo que genera la str de la cadena original porque no se especificaron caracteres en el conjunto de cortes para quitar.
strings.trim("str", "") = "str"
Ejemplo 3
En el siguiente ejemplo, la función produce una cadena vacía porque la cadena de entrada ya está vacía y no hay caracteres para quitar.
strings.trim("", "str") = ""
Ejemplo 4
En el siguiente ejemplo, la función produce str porque la función trim. quita lo siguiente:
- espacio en blanco al final en "a aastraa aa "
- los caracteres especificados en el conjunto de cortes (espacio, a)
strings.trim("a aastraa aa ", " a") = "str"
strings.url_decode
strings.url_decode(url_string)
Descripción
Dada una cadena de URL, decodifica los caracteres de escape y controla los caracteres UTF-8 codificados. Muestra una cadena vacía si la decodificación falla.
Tipos de datos de parámetros
STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se muestra un caso de prueba positivo.
strings.url_decode("three%20nine%20four") = "three nine four"
Ejemplo 2
En este ejemplo, se muestra un caso de cadena vacía.
strings.url_decode("") // ""
Ejemplo 3
En este ejemplo, se muestra el manejo de caracteres que no son del alfabeto.
strings.url_decode("%E4%B8%8A%E6%B5%B7%2B%E4%B8%AD%E5%9C%8B") // "上海+中國"
Ejemplo 4
En este ejemplo, se muestra una decodificación de URL de muestra.
strings.url_decode("http://www.google.com%3Fparam1%3D%22+1+%3E+2+%22%26param2%3D2%3B") // 'http://www.google.com?param1="+1+>+2+"¶m2=2;'
timestamp.as_unix_seconds
timestamp.as_unix_seconds(timestamp [, time_zone])
Descripción
Esta función muestra un número entero que representa la cantidad de segundos transcurridos desde un epoch Unix para la cadena de marca de tiempo determinada.
timestamp
es una cadena que representa una marca de tiempo válida de época. El formato debe ser%F %T
.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado esGMT
. Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- Es el nombre de la base de datos de TZ, por ejemplo,
America/Los_Angeles
. Para obtener más información, consulta la lista de zonas horarias de la base de datos tz en Wikipedia. - Es el desplazamiento de zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo, “-08:00”.
- Es el nombre de la base de datos de TZ, por ejemplo,
Estos son ejemplos de especificadores time_zone
válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
STRING
y STRING
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
Marca de tiempo de época válida
timestamp.as_unix_seconds("2024-02-22 10:43:00") = 1708598580
Ejemplo 2
Marca de tiempo válida de época con la zona horaria de América/Nueva_York
timestamp.as_unix_seconds("2024-02-22 10:43:00", "America/New_York") = 1708616580
timestamp.current_seconds
timestamp.current_seconds()
Descripción
Muestra un número entero que representa la hora actual en segundos Unix. Este es
casi igual a la marca de tiempo de detección y se basa en el momento
cuando se ejecute. Esta función es un sinónimo de la función timestamp.now()
.
Tipos de datos de param
NONE
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En el siguiente ejemplo, se muestra true
si el certificado venció por más tiempo
más de 24 horas. Calcula la diferencia de tiempo restando el Unix actual
segundos y, luego, la comparamos
con un operador mayor que.
86400 < timestamp.current_seconds() - $e.network.tls.certificate.not_after
timestamp.get_date
timestamp.get_date(unix_seconds [, time_zone])
Descripción
Esta función muestra una cadena con el formato YYYY-MM-DD
, que representa el día en que se encuentra una marca de tiempo.
unix_seconds
es un número entero que representa la cantidad de segundos transcurridos desde la época de Unix, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contiene ese valor.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado es “GMT”. Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- El nombre de la base de datos de TZ, por ejemplo, “America/Los_Angeles”. Para ver más consulta el "Nombre de la base de datos TZ" de esta página
- El desplazamiento de la zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo: “-08:00”.
Estos son ejemplos de especificadores de time_zone válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada en “GMT”.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_date($ts) = "2024-02-19"
Ejemplo 2
En este ejemplo, se usa un literal de string para definir time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_date($ts, "America/Los_Angeles") = "2024-02-20"
timestamp.get_minute
timestamp.get_minute(unix_seconds [, time_zone])
Descripción
Esta función muestra un número entero en el rango [0, 59]
que representa el minuto.
unix_seconds
es un número entero que representa la cantidad de segundos pasados de Unix época, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contenga ese valor.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado es “GMT”. Puedes especificar las zonas horarias con literales de cadena. Las opciones son las siguientes:- El nombre de la base de datos de TZ, por ejemplo, “America/Los_Angeles”. Para obtener más información, consulta la columna "Nombre de la base de datos de TZ" de esta página.
- El desplazamiento de la zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo: “-08:00”.
Estos son ejemplos de especificadores time_zone
válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada en “GMT”.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_hour($ts) = 15
Ejemplo 2
En este ejemplo, se usa un literal de string para definir time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_hour($ts, "America/Los_Angeles") = 15
timestamp.get_hour
timestamp.get_hour(unix_seconds [, time_zone])
Descripción
Esta función muestra un número entero en el rango [0, 23]
que representa la hora.
unix_seconds
es un número entero que representa la cantidad de segundos pasados de Unix época, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contenga ese valor.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado es "GMT". Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- El nombre de la base de datos de TZ, por ejemplo, “America/Los_Angeles”. Para ver más consulta el "Nombre de la base de datos TZ" de esta página
- El desplazamiento de la zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo: “-08:00”.
Estos son ejemplos de especificadores time_zone
válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada en “GMT”.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_hour($ts) = 15
Ejemplo 2
En este ejemplo, se usa un literal de string para definir time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_hour($ts, "America/Los_Angeles") = 15
timestamp.get_day_of_week
timestamp.get_day_of_week(unix_seconds [, time_zone])
Descripción
Esta función muestra un número entero en el rango [1, 7]
que representa el día del
semana a partir del domingo. Por ejemplo, 1 = domingo y 2 = lunes.
unix_seconds
es un número entero que representa la cantidad de segundos transcurridos desde la época de Unix, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contiene ese valor.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado es “GMT”. Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- El nombre de la base de datos de TZ, por ejemplo, “America/Los_Angeles”. Para obtener más información, consulta la columna "Nombre de la base de datos de TZ" de esta página.
- Es el desplazamiento de zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo, “-08:00”.
Estos son ejemplos de especificadores de time_zone válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada en “GMT”.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_day_of_week($ts) = 6
Ejemplo 2
En este ejemplo, se usa un literal de cadena para definir el time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_day_of_week($ts, "America/Los_Angeles") = 6
timestamp.get_timestamp
timestamp.get_timestamp(unix_seconds, optional timestamp_format, optional timezone)
Descripción
Esta función muestra una cadena con el formato YYYY-MM-DD
, que representa el día en que se encuentra una marca de tiempo.
unix_seconds
es un número entero que representa la cantidad de segundos transcurridos desde la época de Unix, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contiene ese valor.timestamp_format
es opcional y es una cadena que representa el formato de la marca de tiempo. Si se omite, el valor predeterminado es%F %T
. Puedes especificar el formato con literales de cadena. Para conocer las opciones, consulta Elementos de formato para partes de fecha y horatime_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado esGMT
. Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- El nombre de la base de datos de la zona horaria de IANA (TZ), por ejemplo,
America/Los_Angeles
. Para obtener más información, consulta la lista de zonas horarias de la base de datos tz en Wikipedia. - El desplazamiento de la zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo: “-08:00”.
- El nombre de la base de datos de la zona horaria de IANA (TZ), por ejemplo,
Estos son ejemplos de especificadores time_zone
válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
y STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada como GMT
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_timestamp($ts) = "2024-02-22 10:43:51"
Ejemplo 2
En este ejemplo, se usa un literal de string para definir time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_timestamp($ts, "%F %T", "America/Los_Angeles") = "2024-02-22 10:43:51"
Ejemplo 3
En este ejemplo, se usa un literal de cadena para definir el timestamp_format
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_timestamp($ts, "%Y-%m", "GMT") = "2024-02"
timestamp.get_week
timestamp.get_week(unix_seconds [, time_zone])
Descripción
Esta función muestra un número entero en el rango [0, 53]
que representa la semana del año. Las semanas comienzan con el domingo. Las fechas anteriores al primer domingo del año están en la semana 0.
unix_seconds
es un número entero que representa la cantidad de segundos pasados de Unix época, como$e.metadata.event_timestamp.seconds
, o un marcador de posición que contenga ese valor.time_zone
es opcional y es una cadena que representa una zona horaria. Si se omite, el valor predeterminado es "GMT". Puedes especificar zonas horarias mediante cadenas literales. Las opciones son las siguientes:- El nombre de la base de datos de TZ, por ejemplo, “America/Los_Angeles”. Para ver más consulta el "Nombre de la base de datos TZ" de esta página
- Es el desplazamiento de zona horaria desde UTC, en el formato
(+|-)H[H][:M[M]]
, por ejemplo, “-08:00”.
Estos son ejemplos de especificadores time_zone
válidos, que puedes pasar como segundo argumento a las funciones de extracción de tiempo:
"America/Los_Angeles", or "-08:00". ("PST" is not supported)
"America/New_York", or "-05:00". ("EST" is not supported)
"Europe/London"
"UTC"
"GMT"
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
En este ejemplo, se omite el argumento time_zone
, por lo que se establece de forma predeterminada en “GMT”.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_week($ts) = 0
Ejemplo 2
En este ejemplo, se usa un literal de cadena para definir el time_zone
.
$ts = $e.metadata.collected_timestamp.seconds
timestamp.get_week($ts, "America/Los_Angeles") = 0
timestamp.now
timestamp.now()
Descripción
Muestra el número de segundos desde 1970-01-01 00:00:00 UTC. También se conocida como época Unix.
Tipo de datos que se muestra
INT
Muestras de código
Ejemplo 1
El siguiente ejemplo muestra una marca de tiempo para el código ejecutado en 22 de mayo de 2024 a las 18:16:59.
timestamp.now() = 1716401819 // Unix epoch time in seconds for May 22, 2024 at 18:16:59
window.avg
window.avg(numeric_values [, should_ignore_zero_values])
Descripción
Muestra el promedio de los valores de entrada (que pueden ser números enteros o de punto flotante). Si estableces el segundo argumento opcional en verdadero, se ignorarán los valores cero.
Tipos de datos de parámetros
INT|FLOAT
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra el promedio de números enteros.
// This rule sets the outcome $size_mode to the average
// file size in the 5 minute match window.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.avg($e.file.size) // yields 2.5 if the event file size values in the match window are 1, 2, 3 and 4
Ejemplo 2
Este ejemplo muestra el promedio flotante.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.avg($e.file.size) // yields 1.75 if the event file size values in the match window are 1.1 and 2.4
Ejemplo 3
Promedio de entradas negativo
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.avg($e.file.size) // yields 0.6 if the event file size values in the match window are -1.1, 1.1, 0.0 and 2.4
Ejemplo 4
0 devuelve 0
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.avg($e.file.size) // yields 0 if the event file size values in the match window is 0
Ejemplo 5
Ignora los valores 0
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.avg($e.file.size, true) // yields 394 if the event file size values in the match window are 0, 0, 0 and 394
window.first
window.first(values_to_sort_by, values_to_return)
Descripción
Esta función de agregación muestra un valor de cadena derivado de un evento con el valor de int correlacionado más bajo en la ventana de coincidencia. Un ejemplo de caso de uso es obtener el ID de usuario del evento con la marca de tiempo más baja en la ventana de coincidencia (evento más antiguo).
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
STRING
Muestras de código
Obtiene un valor de cadena derivado de un evento con el valor int correlacionado más bajo en la ventana de coincidencia.
// This rule sets the outcome $first_event to the lowest correlated int value
// in the 5 minute match window.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$first_event = window.first($e.metadata.timestamp.seconds, $e.metadata.event_type) // yields v1 if the events in the match window are 1, 2 and 3 and corresponding values v1, v2, and v3.
window.last
window.last(values_to_sort_by, values_to_return)
Descripción
Esta función de agregación muestra un valor de cadena derivado de un evento con el valor de int correlacionado más alto en la ventana de coincidencia. Un ejemplo de caso de uso es obtener el ID de usuario del evento con la marca de tiempo más baja en la ventana de coincidencia (marca de tiempo más alta).
Tipos de datos de parámetros
INT
, STRING
Tipo de datos que se muestra
STRING
Muestras de código
Obtén un valor de cadena derivado de un evento con el valor int correlacionado más alto en la ventana de coincidencias.
// This rule sets the outcome $last_event to the highest correlated int value
// in the 5 minute match window.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$last_event = window.first($e.metadata.timestamp.seconds, $e.metadata.event_type) // yields v3 if the events in the match window are 1, 2 and 3 and corresponding values v1, v2, and v3.
window.median
window.median(numeric_values, should_ignore_zero_values)
Descripción
Muestra la mediana de los valores de entrada. Si hay 2 valores medios, solo 1 se elegirá de forma no determinista como el valor que se muestra.
Tipos de datos de parámetros
INT|FLOAT
, BOOL
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra la mediana cuando los valores de entrada no son cero.
rule median_file_size {
meta:
events:
$e.metadata.event_type = "FILE_COPY"
$userid = $e.principal.user.userid
match:
$userid over 1h
outcome:
$median_file_size = window.median($e.principal.file.size) // returns 2 if the file sizes in the match window are [1, 2, 3]
condition:
$e
}
Ejemplo 2
En este ejemplo, se muestra la mediana cuando la entrada incluye algunos valores cero que no se deben ignorar.
rule median_file_size {
meta:
events:
$e.metadata.event_type = "FILE_COPY"
$userid = $e.principal.user.userid
match:
$userid over 1h
outcome:
$median_file_size = window.median($e.principal.file.size) // returns 1 if the file sizes in the match window are [0,0, 1, 2, 3]
condition:
$e
}
Ejemplo 3
En este ejemplo, se muestra la mediana cuando la entrada incluye algunos valores cero que se deben ignorar.
rule median_file_size {
meta:
events:
$e.metadata.event_type = "FILE_COPY"
$userid = $e.principal.user.userid
match:
$userid over 1h
outcome:
$median_file_size = window.median($e.principal.file.size, true) // returns 2 if the file sizes in the match window are [0,0, 1, 2, 3]
condition:
$e
}
Ejemplo 4
En este ejemplo, se muestra la mediana cuando la entrada incluye todos los valores cero que deben ignorarse.
rule median_file_size {
meta:
events:
$e.metadata.event_type = "FILE_COPY"
$userid = $e.principal.user.userid
match:
$userid over 1h
outcome:
$median_file_size = window.median($e.principal.file.size) // returns 0 if the file sizes in the match window are [0,0]
condition:
$e
}
Ejemplo 5
En este ejemplo, se muestra que, cuando hay varias medianas, solo se muestra una.
rule median_file_size {
meta:
events:
$e.metadata.event_type = "FILE_COPY"
$userid = $e.principal.user.userid
match:
$userid over 1h
outcome:
$median_file_size = window.median($e.principal.file.size) // returns 1 if the file sizes in the match window are [1, 2, 3, 4]
condition:
$e
}
window.mode
window.mode(values)
Descripción
Muestra el modo de los valores de entrada. En caso de que haya varios valores de modo posibles, solo uno de esos valores se elegirá de manera no determinista como el valor que se muestra.
Tipos de datos de param
INT|FLOAT|STRING
Tipo de datos que se muestra
STRING
Muestras de código
Ejemplo 1
Obtiene el modo de los valores de la ventana de coincidencia.
// This rule sets the outcome $size_mode to the most frequently occurring
// file size in the 5 minute match window.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$size_mode = window.mode($e.file.size) // yields 1.6 if the event file size values in the match window are 1.6, 2, and 1.6
window.stddev
window.stddev(numeric_values)
Descripción
Muestra la desviación estándar de los valores de entrada en una ventana de coincidencia.
Tipos de datos de param
INT|FLOAT
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
En este ejemplo, se muestra la desviación estándar de los números enteros en una ventana de coincidencia.
// This rule creates a detection when the file size stddev in 5 minutes for a user is over a threshold.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.stddev($e.file.size) // yields 4.0 if the event file size values in the match window are [10, 14, 18].
condition:
$e and #p1 > 2
Ejemplo 2
En este ejemplo, se muestra la desviación estándar de los números de punto flotante en una ventana de coincidencias.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.stddev($e.file.size) // yields 4.488686 if the event file size values in the match window are [10.00, 14.80, 18.97].
condition:
$e and #p1 > 2
Ejemplo 3
En este ejemplo, se muestra la desviación estándar en una ventana de coincidencia que contiene números negativos.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.stddev($e.file.size) // yields 48.644972 if the event file size values in the match window are [-1, -56, -98].
condition:
$e and #p1 > 2
Ejemplo 4
En este ejemplo, se muestra con una desviación estándar de cero cuando todos los valores en la ventana de coincidencia son iguales.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.stddev($e.file.size) // yields 0.000000 if the event file size values in the match window are [1, 1, 1].
condition:
$e and #p1 > 2
Ejemplo 5
En este ejemplo, se muestra la desviación estándar de una ventana de coincidencias que contiene números positivos y negativos.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.stddev($e.file.size) // yields 1.000000 if the event file size values in the match window are [1, 0, -1].
condition:
$e and #p1 > 10
window.variance
window.variance(values)
Descripción
Esta función muestra la varianza especificada de los valores de entrada.
Tipos de datos de parámetros
INT|FLOAT
Tipo de datos que se muestra
FLOAT
Muestras de código
Ejemplo 1
Este ejemplo muestra la varianza de todos los números enteros.
// This rule creates a detection when the file size variance in 5 minutes for a user is over a threshold.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 16 if the event file size values in the match window are [10, 14, 18].
condition:
$e and #p1 > 10
Ejemplo 2
Este ejemplo muestra la varianza de todos los números de punto flotante.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 20.148300 if the event file size values in the match window are [10.00, 14.80, 18.97].
condition:
$e and #p1 > 10
Ejemplo 3
En este ejemplo, se muestra la varianza de los números negativos.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 2366.333333 if the event file size values in the match window are [-1, -56, -98].
condition:
$e and #p1 > 10
Ejemplo 4
Este ejemplo muestra un valor de varianza pequeño.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 0.000000 if the event file size values in the match window are [0.000000, 0.000000, 0.000100].
condition:
$e and #p1 > 10
Ejemplo 5
Este ejemplo muestra una varianza de cero.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 0.000000 if the event file size values in the match window are [1, 1, 1].
condition:
$e and #p1 > 10
Ejemplo 6
En este ejemplo, se muestra la varianza de números positivos y negativos.
events:
$e.user.userid = $userid
match:
$userid over 5m
outcome:
$p1 = window.variance($e.file.size) // yields 1.000000 if the event file size values in the match window are [1, 0, -1].
condition:
$e and #p1 > 10
Función en la asignación del marcador de posición
Puedes asignar el resultado de una llamada a función a un marcador de posición en la sección events
. Por ejemplo:
$placeholder = strings.concat($e.principal.hostname, "my-string").
Luego, puedes usar las variables de marcador de posición en las secciones match
, condition
y outcome
.
Sin embargo, existen dos limitaciones con la asignación de funciones a marcadores de posición:
Cada marcador de posición en la asignación de marcador de posición de función debe asignarse a una expresión que contenga un campo de evento. Por ejemplo, los siguientes ejemplos son válidos:
$ph1 = $e.principal.hostname $ph2 = $e.src.hostname // Both $ph1 and $ph2 have been assigned to an expression containing an event field. $ph1 = strings.concat($ph2, ".com")
$ph1 = $e.network.email.from $ph2 = strings.concat($e.principal.hostname, "@gmail.com") // Both $ph1 and $ph2 have been assigned to an expression containing an event field. $ph1 = strings.to_lower($ph2)
Sin embargo, el siguiente ejemplo no es válido:
$ph1 = strings.concat($e.principal.hostname, "foo") $ph2 = strings.concat($ph1, "bar") // $ph2 has NOT been assigned to an expression containing an event field.
La llamada a función debe depender de un evento y solo uno. Sin embargo, se puede usar más de un campo del mismo evento en los argumentos de llamada a función. Por ejemplo, se puede usar lo siguiente:
$ph = strings.concat($event.principal.hostname, "string2")
$ph = strings.concat($event.principal.hostname, $event.src.hostname)
Sin embargo, lo siguiente no es válido:
$ph = strings.concat("string1", "string2")
$ph = strings.concat($event.principal.hostname, $anotherEvent.src.hostname)
Sintaxis de las listas de referencia
Consulta nuestra página sobre listas de referencias para obtener más información sobre el comportamiento y la sintaxis de las listas de referencias.
Puedes usar listas de referencias en las secciones events
o outcome
. Este es el
sintaxis para usar varios tipos de listas de referencia en una regla:
// STRING reference list
$e.principal.hostname in %string_reference_list
// REGEX reference list
$e.principal.hostname in regex %regex_reference_list
// CIDR reference list
$e.principal.ip in cidr %cidr_reference_list
También puedes usar el operador not
y el operador nocase
con listas de referencia, como se muestra en el siguiente ejemplo:
// Exclude events whose hostnames match substrings in my_regex_list.
not $e.principal.hostname in regex %my_regex_list
// Event hostnames must match at least 1 string in my_string_list (case insensitive).
$e.principal.hostname in %my_string_list nocase
El operador nocase
es compatible con las listas STRING
y REGEX
.
Por motivos de rendimiento, Detection Engine restringe el uso de la lista de referencia.
- Cantidad máxima de declaraciones
in
en una regla, con o sin operadores especiales: 7 - Cantidad máxima de sentencias
in
con el operadorregex
: 4 - Cantidad máxima de declaraciones
in
con el operadorcidr
: 2
Verificación de tipos
Google Security Operations verifica el tipo de tu sintaxis YARA-L a medida que creas reglas en la interfaz. Los errores de verificación de tipo que se muestran te ayudan a revisar la regla de manera tal que funcione como se espera.
Los siguientes son ejemplos de predicados no válidos:
// $e.target.port is of type integer which cannot be compared to a string.
$e.target.port = "80"
// "LOGIN" is not a valid event_type enum value.
$e.metadata.event_type = "LOGIN"
Muestreo de eventos de detección
Las detecciones de las reglas de varios eventos contienen muestras de eventos para proporcionar contexto sobre los eventos que causaron la detección. Existe un límite de hasta 10 muestras de eventos para cada variable de evento definida en la regla. Por ejemplo, si una regla define 2 variables de evento, cada detección puede tener hasta 20 muestras de eventos. El límite se aplica a cada variable de evento por separado. Si una variable de evento tiene 2 eventos aplicables en esta detección y la otra variable de evento tiene 15 eventos aplicables, la detección resultante contiene 12 muestras de eventos (2 + 10).
Se omiten de la detección los ejemplos de eventos que superen el límite.
Si deseas obtener más información sobre los eventos que provocaron la detección, puedes usar las agregaciones en la sección de resultados para generar información adicional en la detección.
Si estás viendo detecciones en la IU, puedes descargar todos los muestras de eventos para una detección. Para obtener más información, consulta Descarga eventos.