Syntaxe du langage YARA-L 2.0

Cette section décrit les principaux éléments de la syntaxe YARA-L. Consultez également la présentation du langage YARA-L 2.0.

Structure de la règle

Pour YARA-L 2.0, vous devez spécifier les déclarations, les définitions et les utilisations de variables dans l'ordre suivant:

1. Meta
2. événement
3. correspondance (facultatif)
4. résultat (facultatif)
5. condition
6. options (facultatif)

Remarque:Si vous omettez la section facultative match, la règle peut correspondre à un seul événement.

Voici la structure générique d'une règle:

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.
}

Commentaires

Désignez des commentaires avec deux barres obliques (// comment) ou des commentaires multilignes déclenchés par une barre oblique (/* comment */), comme vous le feriez en C.

Littéraux

Les entiers non négatifs (sans points décimaux), les littéraux de chaîne, booléens et d'expression régulière sont acceptés.

Littéraux de chaîne et d'expression régulière

Vous pouvez utiliser l'un des guillemets suivants pour délimiter des chaînes dans YARA-L 2.0. Toutefois, le texte des messages précédents est interprété différemment selon l'option choisie.

1. Guillemets doubles (") : à utiliser pour les chaînes normales. Doit inclure des caractères d'échappement.
   Par exemple, "hello\tworld" :\t est interprété comme un onglet

2. Guillemets précédents (`) : permet d'interpréter tous les caractères de manière littérale.
   Par exemple, "hello\tworld" :\t n'est pas interprété comme un onglet.

Pour les expressions régulières, deux options s'offrent à vous.

Si vous souhaitez utiliser des expressions régulières directement sans la fonction re.regex(), utilisez /regex/ pour les littéraux d'expression régulière.

Vous pouvez également utiliser des littéraux de chaîne en tant que littéraux d'expression régulière lorsque vous utilisez la fonction re.regex(). Notez que pour les littéraux de chaîne entre guillemets doubles, vous devez échapper les barres obliques inverses avec des barres obliques inverses, qui peuvent sembler maladroites.

Par exemple, les expressions régulières suivantes sont équivalentes:

• re.regex($e.network.email.from, `.*altostrat\.com`)
• re.regex($e.network.email.from, ".*altostrat\\.com")
• $e.network.email.from = /.*altostrat\.com/

Pour plus de lisibilité, Google recommande d'utiliser des guillemets pour les chaînes dans les expressions régulières.

Opérateurs

Vous pouvez utiliser les opérateurs suivants dans YARA-L:

Opérateur	Description
=	égal/déclaration
!=	différent(e) de
<	inférieur à
<=	inférieur ou égal à
>	supérieur à
>=	supérieur ou égal à

Variables

Dans YARA-L 2.0, toutes les variables sont représentées par $<variable name>.

Vous pouvez définir les types de variables suivants:

• Variables d'événement : représentent des groupes d'événements au format normalisé (UDM) ou d'entités. Spécifiez les conditions des variables d'événements dans la section events. Vous identifiez les variables d'événement à l'aide d'un nom, d'une source d'événements et de champs d'événement. Les sources autorisées sont udm (pour les événements normalisés) et graph (pour les événements d'entité). Si la source est omise, udm est défini comme source par défaut. Les champs d'événement sont représentés par une chaîne de .<nom de champ> (par exemple, $e.field1.field2). Les chaînes de champs d'événement commencent toujours par la source de premier niveau (UDM ou Entity).

• Variables de correspondance : déclarez-les dans la section match. Les variables de correspondance deviennent des champs de regroupement pour la requête, car une ligne est renvoyée pour chaque ensemble unique de variables de correspondance (et pour chaque période). Lorsque la règle trouve une correspondance, les valeurs des variables de correspondance sont renvoyées. Spécifiez ce que chaque variable de correspondance représente dans la section events.

• Variables d'espaces réservés : déclarez et définissez dans la section events. Les variables d'espace réservé sont semblables aux variables de correspondance. Toutefois, vous pouvez utiliser des variables d'espace réservé dans la section condition pour spécifier des conditions de correspondance.

Remarque : Chaque variable d'espace réservé doit être mappée sur un champ d'événement. Par exemple, si vous ne référencez que l'espace réservé suivant dans cette ligne d'une règle, la compilation échouerait, car $var n'est pas lié à une variable d'événement : $e.field != $var

Utilisez des variables de correspondance et des variables d'espace réservé pour déclarer des relations entre les champs d'événement via des conditions de jointure transitives (pour en savoir plus, consultez la page Syntaxe des sections d'événements).

Maps

Structures et étiquettes

Certains champs UDM utilisent le type de données Structure ou Libellé.

Pour rechercher une paire clé-valeur spécifique à la fois dans Struct et dans Libellé, utilisez la syntaxe de mappage standard:

// A Struct field.
$e.udm.additional.fields["pod_name"] = "kube-scheduler"
// A Label field.
$e.metadata.ingestion_labels["MetadataKeyDeletion"] = "startup-script"

Cas compatibles

Section "Événements et résultats"

// 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"])

Attribuer une valeur de mappage à un espace réservé

$placeholder = $u1.metadata.ingestion_labels["MetadataKeyDeletion"]

Utiliser un champ de mappage dans une condition de jointure

// 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"]

Cas non compatibles

Combiner des mots clés any ou all avec une carte

Par exemple, les éléments suivants ne sont pas compatibles actuellement : all $e.udm.additional.fields["pod_name"] = "kube-scheduler"

Functions

Cette section décrit les fonctions de YARA-L 2.0 compatibles avec Chronicle dans le moteur de détection.

Vous pouvez utiliser ces fonctions dans les zones suivantes d'une règle:

• events.
• BOOL_CLAUSE d'une condition dans la section des résultats.

Fonctions de chaîne

Chronicle est compatible avec les fonctions de manipulation de chaînes suivantes:

• string.concat(a, b)
• string.coalesce(a, b)
• string.to_lower(stringText)
• string.to_upper(stringText)
• string.base64_decode(StringString)

Les sections suivantes expliquent comment les utiliser.

Concaténer des chaînes ou des entiers

Renvoie la concaténation de deux chaînes, de deux entiers ou d'une combinaison des deux.

strings.concat(a, b)

Cette fonction prend deux arguments, qui peuvent être des chaînes ou des entiers, et renvoie les deux valeurs concaténées sous forme de chaîne. Les entiers sont castés en chaîne avant la concaténation. Les arguments peuvent être des littéraux ou des champs d'événement. Si les deux arguments sont des champs, les deux attributs doivent provenir du même événement.

L'exemple suivant inclut une variable de chaîne et un littéral de chaîne en tant qu'arguments.

"google-test" = strings.concat($e.principal.hostname, "-test")

L'exemple suivant inclut une variable de chaîne et une variable entière en tant qu'arguments. principal.hostname et principal.port proviennent du même événement, $e, et sont concaténés pour renvoyer une chaîne.

"google80" = strings.concat($e.principal.hostname, $e.principal.port)

L'exemple suivant tente de concaténer principal.port à partir de l'événement $e1, avec principal.hostname à partir de l'événement $e2. Il renverra une erreur de compilateur, car les arguments sont des variables d'événements différentes.

// returns a compiler error
"test" = strings.concat($e1.principal.port, $e2.principal.hostname)

Valeurs de chaîne coalescées

Renvoie la valeur de la première expression qui ne renvoie pas de chaîne vide (par exemple, "valeur non nulle"). Si les deux arguments renvoient une chaîne vide, l'appel de fonction renvoie une chaîne vide.

strings.coalesce(a, b)

Les arguments peuvent être des littéraux, des champs d'événement ou des appels de fonctions. Les deux arguments doivent être de type STRING. Si les deux arguments sont des champs, les deux attributs doivent provenir du même événement.

L'exemple suivant inclut une variable de chaîne et un littéral de chaîne en tant qu'arguments. La condition est évaluée à true lorsque (1) $e.network.email.from est [e-mail] ou (2) $e.network.email.from est vide et $e.network.email.to est [e-mail].

"[e-mail]" = strings.coalesce($e.network.email.from, $e.network.email.to)

L'exemple suivant inclut des appels coalesce imbriqués. Cette condition compare la première adresse IP non nulle de l'événement $e aux valeurs de la liste de référence ip_watchlist. L'ordre dans lequel les arguments sont fusionnés dans cet appel est le même que celui dans lequel ils sont énumérés dans la condition de règle:

1. $e.principal.ip est évaluée en premier.
2. $e.src.ip est ensuite évaluée.
3. $e.target.ip est ensuite évaluée.
4. Enfin, la chaîne "Aucune adresse IP" est renvoyée comme valeur par défaut si les champs IP précédents ne sont pas définis.

strings.coalesce(
  strings.coalesce($e.principal.ip, $e.src.ip),
  strings.coalesce($e.target.ip, "No IP")
) in %ip_watchlist

L'exemple suivant tente de fusionner principal.hostname à partir des événements $e1 et $e2. Il renverra une erreur de compilateur, car les arguments sont des variables d'événements différentes.

// returns a compiler error
"test" = strings.coalesce($e1.principal.hostname, $e2.principal.hostname)

Convertir la chaîne en majuscules ou en minuscules

Ces fonctions renvoient un texte de chaîne après avoir modifié tous les caractères en majuscules ou en minuscules.

• string.to_lower(stringText)
• string.to_upper(stringText)

"[e-mail]" = strings.to_lower($e.network.email.from)
"[e-mail]" = strings.to_upper($e.network.email.to)

Décoder une chaîne en base64

Renvoie une chaîne contenant la version décodée en base64 de la chaîne encodée.

strings.base64_decode(encodedString)

Cette fonction utilise une chaîne encodée en base64 comme argument. Si encodedString n'est pas une chaîne encodée en base64 valide, la fonction renvoie encodedString en l'état.

Cet exemple renvoie la valeur "True" si "principal.domain.name" est "dGVzdA==", qui est un encodage base64 pour la chaîne "test".

"test" = strings.base64_decode($e.principal.domain.name)

Fonctions d'expression régulière

Chronicle est compatible avec les fonctions d'expression régulière suivantes:

• re.regex(stringText, regex)
• re.capture(stringText, regex) :
• re.replace(stringText, replaceRegex, replaceText)

Correspondance avec expression régulière

Vous pouvez définir la correspondance d'expressions régulières dans YARA-L 2.0 à l'aide de l'une des syntaxes suivantes:

• Utilisation de la syntaxe YARA : liée aux événements. Voici une représentation générique de cette syntaxe : $e.field = /regex/
• En utilisant la syntaxe YARA-L : en utilisant les paramètres suivants :
  • Champ auquel l'expression régulière est appliquée.
  • Expression régulière spécifiée sous forme de chaîne. Vous pouvez utiliser le modificateur nocase après les chaînes pour indiquer que la recherche doit ignorer les majuscules. Voici une représentation générique de cette syntaxe : re.regex($e.field, `regex`)

Tenez compte des points suivants lorsque vous définissez des expressions régulières dans YARA-L 2.0:

• Dans les deux cas, le prédicat est vrai si la chaîne contient une sous-chaîne correspondant à l'expression régulière fournie. Il n'est pas nécessaire d'ajouter .* au début ou à la fin de l'expression régulière.
• Pour correspondre exactement à la chaîne ou uniquement à un préfixe ou à un suffixe, incluez les caractères d'ancrage ^ (début) et $ (fin) dans l'expression régulière. Par exemple, /^full$/ correspond exactement à "full", tandis que /full/ peut correspondre à "fullest", "lawfull" et "joyfully".
• Si le champ UDM inclut des caractères de nouvelle ligne, regexp ne correspond qu'à la première ligne du champ UDM. Pour appliquer la mise en correspondance complète des champs UDM, ajoutez (?s) à l'expression régulière. Par exemple, remplacez /.*allUDM.*/ par /(?s).*allUDM.*/.

Capture d'expression régulière

Capture (extrait) les données d'une chaîne à l'aide du modèle d'expression régulière fourni dans l'argument.

re.capture(stringText, regex)

Cette fonction nécessite deux arguments:

• stringText: chaîne d'origine à rechercher.
• regex (Expression régulière) : expression régulière indiquant le modèle à rechercher.

L'expression régulière peut contenir zéro ou 1 groupe de capture entre parenthèses. Si l'expression régulière contient 0 groupe de capture, la fonction renvoie la première sous-chaîne correspondante. Si l'expression régulière contient 1 groupe de capture, elle renvoie la première sous-chaîne correspondante. La définition de deux groupes de capture ou plus renvoie une erreur de compilateur.

Dans cet exemple, si $e.principal.hostname contient "aaa1bbaa2", la valeur suivante serait True, car la fonction renvoie la première instance. Cet exemple ne comporte aucun groupe de capture.

"aaa1" = re.capture($e.principal.hostname, "a+[1-9]")

Dans cet e-mail, tout est placé après le symbole @ dans un e-mail. Si le champ $e.network.email.from est [e-mail], l'exemple renvoie google.com. Cet exemple contient un groupe de capture.

"google.com" = re.capture($e.network.email.from , "@(.*)")

Si l'expression régulière ne correspond à aucune sous-chaîne du texte, la fonction renvoie une chaîne vide. Vous pouvez omettre les événements qui ne se produisent pas en excluant la chaîne vide, ce qui est particulièrement important lorsque vous utilisez re.capture() avec une inégalité:

// 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 , "@(.*)")

Remplacement d'expression régulière

Effectue un remplacement d'expression régulière.

re.replace(stringText, replaceRegex, replacementText)

Cette fonction nécessite trois arguments:

• stringText: chaîne d'origine.
• replaceRegex: expression régulière indiquant le modèle à rechercher.
• remplacementText: texte à insérer dans chaque correspondance.

Renvoie une nouvelle chaîne dérivée de la chaîne d'origine stringText, où toutes les sous-chaînes correspondant au modèle de replaceRegex sont remplacées par la valeur de "replacementText". Vous pouvez utiliser des chiffres échappés par une barre oblique inverse (\1 à \9) dans "replacementText" pour insérer du texte correspondant au groupe entre parenthèses correspondant dans le modèle replaceRegex. Utilisez \0 pour faire référence à l'ensemble du texte associé.

La fonction remplace les correspondances qui ne se chevauchent pas et donne la priorité à la première occurrence trouvée. Par exemple, re.replace("banane", "ana" ou "111") renvoie la chaîne "b111na".

Cet exemple capture tout ce qui suit le symbole @ dans un e-mail, remplace com par org, puis renvoie le résultat. Notez l'utilisation de fonctions imbriquées.

"[e-mail]" = re.replace($e.network.email.from, "com", "org")

Cet exemple utilise des chiffres échappés par une barre oblique inverse dans l'argument replaceText pour référencer les correspondances avec le modèle 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"
                     )

Notez les cas suivants lorsque vous gérez des chaînes vides et re.replace():

Utiliser une chaîne vide en tant que 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")

Pour remplacer une chaîne vide, vous pouvez utiliser "^$" comme replaceRegex:

// In the function call below, if $e.principal.hostname contains the empty
// string, "", the result is: "none".
re.replace($e.principal.hostname, "^$", "none")

Fonctions de date

Chronicle est compatible avec les fonctions de date suivantes:

• timestamp.get_minute(unix_seconds [, time_zone])
• timestamp.get_hour(unix_seconds [, time_zone])
• timestamp.get_day_of_week(unix_seconds [, time_zone])
• timestamp.get_week(unix_seconds [, time_zone])
• timestamp.current_seconds()

Chronicle accepte les entiers négatifs comme argument unix_seconds. Les entiers négatifs représentent les temps antérieurs à l'époque Unix. Si vous fournissez un entier non valide, par exemple une valeur qui entraîne un débordement, la fonction renvoie "-1". Ce scénario est inhabituel.

Étant donné que YARA-L 2 n'accepte pas les littéraux entiers négatifs, veillez à rechercher cette condition à l'aide de l'opérateur inférieur ou supérieur à. Exemple :

0 > timestamp.get_hour(123)

Extraction de données temporelles

Renvoie un nombre entier compris entre 0 et 59.

timestamp.get_minute(unix_seconds [, time_zone])

La fonction suivante renvoie un entier compris entre 0 et 23, qui représente l'heure de la journée.

timestamp.get_hour(unix_seconds [, time_zone])

La fonction suivante renvoie un entier compris dans la plage [1, 7] représentant le jour de la semaine commençant par le dimanche. Par exemple : 1 = dimanche ; 2 = lundi.

timestamp.get_day_of_week(unix_seconds [, time_zone])

La fonction suivante renvoie un nombre entier compris entre 0 et 53 représentant la semaine de l'année. Les semaines commencent le dimanche. Les dates antérieures au premier dimanche de l'année correspondent à la semaine 0.

timestamp.get_week(unix_seconds [, time_zone])

Ces fonctions d'extraction temporelle ont les mêmes arguments.

• unix_seconds est un entier représentant le nombre de secondes écoulées depuis l'époque Unix, tel que $e.metadata.event_timestamp.seconds, ou un espace réservé contenant cette valeur.
• Le champ "time_zone" est facultatif. Il s'agit d'une chaîne représentant un fuseau horaire. En cas d'omission, la valeur par défaut est "GMT". Vous pouvez spécifier des fuseaux horaires à l'aide de littéraux de chaîne. Les options sont les suivantes :
  • Nom de la base de données TZ, par exemple "America/Los_Angeles". Pour en savoir plus, consultez la colonne "Nom de la base de données TZ" de cette page.
  • Décalage de fuseau horaire par rapport à UTC, au format (+|-)H[H][:M[M]] (par exemple, "-08:00").

Dans cet exemple, l'argument "time_zone" est omis. Il est donc défini par défaut sur "GMT".

$ts = $e.metadata.collected_timestamp.seconds

timestamp.get_hour($ts) = 15

Cet exemple utilise un littéral de chaîne pour définir le fuseau horaire.

$ts = $e.metadata.collected_timestamp.seconds

2 = timestamp.get_day_of_week($ts, "America/Los_Angeles")

Voici d'autres exemples de spécificateurs de fuseau horaire valides, que vous pouvez transmettre en tant que deuxième argument aux fonctions d'extraction de temps:

• "America/Los_Angeles" ou "-08:00". ("PST" n'est pas compatible)
• "America/New_York" ou "-05:00". ("EST" n'est pas compatible)
• "Europe/London"
• "UTC"
• "GMT"

Horodatage actuel

Renvoie un nombre entier représentant l'heure actuelle en secondes Unix. Cette valeur est à peu près égale à l'horodatage de détection et est basée sur le moment où la règle est exécutée.

timestamp.current_seconds()

L'exemple suivant renvoie la valeur "True" si le certificat a expiré depuis plus de 24 heures. Elle calcule la différence temporelle en soustrayant le nombre de secondes Unix actuel, puis en la comparant à l'aide d'un opérateur supérieur à.

86400 < timestamp.current_seconds() - $e.network.tls.certificate.not_after

Fonctions mathématiques

Valeur absolue

Renvoie la valeur absolue d'une expression entière.

math.abs(intExpression)

Cet exemple renvoie la valeur "True" si l'événement remonte à plus de cinq minutes de l'heure spécifiée (en secondes à partir de l'époque Unix), que l'événement se produise avant ou après l'heure spécifiée. Un appel à math.abs ne peut pas dépendre de plusieurs variables ou espaces réservés. Par exemple, vous ne pouvez pas remplacer la valeur temporelle codée en dur de 1643687343 dans l'exemple ci-dessous par $e2.metadata.event_timestamp.seconds.

300 < math.abs($e1.metadata.event_timestamp.seconds - 1643687343)

Fonctions Net

Recherche de sous-réseau IP

Renvoie la valeur "true" lorsque l'adresse IP donnée se trouve dans le sous-réseau spécifié.

net.ip_in_range_cidr(ipAddress, subnetworkRange)

Vous pouvez utiliser YARA-L pour rechercher des événements UDM parmi toutes les adresses IP d'un sous-réseau à l'aide de l'instruction net.ip_in_range_cidr(). Les protocoles IPv4 et IPv6 sont tous deux acceptés.

Pour effectuer une recherche dans une plage d'adresses IP, spécifiez un champ UDM IP et une plage de routage interdomaine sans classe (CIDR, Classless Inter-Domain Routing). YARA-L peut gérer à la fois les champs d'adresse IP au singulier et aux champs répétés.

Exemple IPv4:

net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")

Exemple IPv6:

net.ip_in_range_cidr($e.network.dhcp.yiaddr, "2001:db8::/32")

Pour consulter un exemple de règle utilisant l'instruction net.ip_in_range_cidr(), consultez l'exemple de règle. Événement unique dans une plage d'adresses IP

Fonction d'attribution d'espaces réservés

Vous pouvez attribuer le résultat d'un appel de fonction à un espace réservé dans la section events. Exemple :

$placeholder = strings.concat($e.principal.hostname, "my-string").

Vous pouvez ensuite utiliser les variables d'espace réservé dans les sections match, condition et outcome. Toutefois, l'attribution de fonctions aux espaces réservés présente deux limites:

1. Chaque espace réservé d'une fonction à l'espace réservé doit être attribué à une expression contenant un champ d'événement. Par exemple, les exemples suivants sont valides:

   $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)
   

   Toutefois, l'exemple ci-dessous n'est pas valide:

   $ph1 = strings.concat($e.principal.hostname, "foo")
   $ph2 = strings.concat($ph1, "bar") // $ph2 has NOT been assigned to an expression containing an event field.
   

2. L'appel de fonction doit dépendre d'un et un seul événement. Toutefois, plusieurs champs du même événement peuvent être utilisés dans les arguments d'appel de fonction. Par exemple:

   $ph = strings.concat($event.principal.hostname, "string2")

   $ph = strings.concat($event.principal.hostname, $event.src.hostname)

   En revanche, les éléments suivants ne sont pas valides:

   $ph = strings.concat("string1", "string2")

   $ph = strings.concat($event.principal.hostname, $anotherEvent.src.hostname)

Syntaxe des listes de référence

Pour en savoir plus sur le comportement des listes de référence et leur syntaxe, consultez cette page.

Vous pouvez utiliser des listes de référence dans les sections events ou outcome. Voici la syntaxe permettant d'utiliser différents types de listes de référence dans une règle:

// 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

Vous pouvez également utiliser l'opérateur not avec des listes de référence, comme indiqué ci-dessous : not $e.principal.hostname in regex %my_regex_list.

Pour des raisons de performances, le moteur de détection limite l'utilisation des listes de référence. Vous pouvez utiliser jusqu'à sept instructions in dans une règle et vous pouvez utiliser plusieurs types d'instructions in dans la même règle. 2 instructions in sur 7 au maximum peuvent utiliser les opérateurs spéciaux regex ou cidr.

L'opérateur nocase ne fonctionne pas avec les listes de référence. Placer nocase après un appel de liste de référence n'a aucun effet et n'est pas recommandé.

Syntaxe de la section Meta

La section Meta est composée de plusieurs lignes, où chaque ligne définit une paire clé-valeur. Une partie de clé doit être une chaîne sans guillemets et une partie de valeur doit être entre guillemets:

<key> = "<value>"

Voici un exemple de ligne de section meta valide : meta: author = "Chronicle" severity = "HIGH"

Syntaxe de la section "Événements"

Dans la section events, répertoriez les prédicats à spécifier:

• Que représente chaque correspondance ou variable d'espace réservé ?
• Expressions binaires simples comme conditions
• Expressions de fonction en tant que conditions
• Expressions de listes de références en tant que conditions
• Opérateurs logiques

Déclarations de variables

Pour les déclarations de variables, utilisez la syntaxe suivante:

• <EVENT_FIELD> = <VAR>
• <VAR> = <EVENT_FIELD>

Les deux sont équivalents, comme illustré dans les exemples suivants:

• $e.source.hostname = $hostname
• $userid = $e.principal.user.userid

Cette déclaration indique que cette variable représente le champ spécifié pour la variable d'événement. Lorsque le champ d'événement est répété, la variable de correspondance peut représenter n'importe quelle valeur du tableau. Il est également possible d'attribuer plusieurs champs d'événement à une seule variable correspondante ou à un espace réservé. Il s'agit d'une condition de jointure transitive.

Par exemple, cette agrégation :

• $e1.source.ip = $ip
• $e2.target.ip = $ip

Équivaut à:

• $e1.source.ip = $ip
• $e1.source.ip = $e2.target.ip

Lorsqu'une variable est utilisée, elle doit être déclarée via une déclaration de variable. Si une variable est utilisée sans déclaration, elle est considérée comme une erreur de compilation.

Expressions binaires simples comme conditions

Pour qu'une expression binaire simple puisse être utilisée comme condition, utilisez la syntaxe suivante:

• <EXPR> <OP> <EXPR>

L'expression peut être un champ d'événement, une variable, un littéral ou une expression de fonction.

Exemple :

• $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")
• "[e-mail]" = re.replace($e.network.email.from, "com", "org")

Si les deux côtés sont des littéraux, il s'agit d'une erreur de compilation.

Expressions de fonction en tant que conditions

Certaines expressions de fonction renvoient une valeur booléenne, qui peut être utilisée en tant que prédicat individuel dans la section events. Ces fonctions sont les suivantes:

• re.regex()
• net.ip_in_range_cidr()

Exemple :

• re.regex($e.principal.hostname, `.*\.google\.com`)
• net.ip_in_range_cidr($e.principal.ip, "192.0.2.0/24")

Expressions de listes de références en tant que conditions

Vous pouvez utiliser des listes de référence dans la section "Événements". Pour en savoir plus, consultez la section Listes de référence.

Opérateurs logiques

Vous pouvez utiliser les opérateurs logiques and et or dans la section events, comme indiqué dans les exemples suivants:

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

Par défaut, l'ordre de priorité est le plus élevé au plus bas : not, and, or.

Par exemple, "a or b and c" est évalué comme "a or (b and c)". Vous pouvez utiliser des parenthèses pour modifier la priorité si nécessaire.

Dans la section events, tous les prédicats sont considérés comme and par défaut.

Remarque:Le nombre de valeurs and et or que vous pouvez spécifier pour une seule règle est limité. Cette limite varie en fonction de la complexité de la règle et de la complexité des données dans votre compte Chronicle. Contactez votre représentant Chronicle pour en savoir plus sur les alternatives à ce type de règle.

Opérateurs pour les événements

Vous pouvez utiliser les opérateurs avec des types enumerated. Vous pouvez l'appliquer aux règles afin de simplifier et d'optimiser les performances (utilisez un opérateur au lieu de listes de référence).

Dans l'exemple suivant, "USER_UNCATEGORIZED" et "USER_RESOURCE_DELETION" correspondent à 15 000 et 15 014, afin que la règle recherche tous les événements répertoriés:

$e.metadata.event_type >= "USER_CATEGORIZED" and $e.metadata.event_type <= "USER_RESOURCE_DELETION"

Liste des événements:

• SUPPRESSION_DE_RESSOURCES_USER
• USER_RESOURCE_UPDATE_CONTENT
• USER_RESOURCE_UPDATE_PERMISSIONS
• STATISTIQUES UTILISATEUR
• USER_UNCATEGORIZED (USER_NON_CATÉGORISÉ)

Modificateurs

nocase

Lorsque vous avez une expression de comparaison entre des valeurs de chaîne ou une expression régulière, vous pouvez ajouter "nocase" à la fin de l'expression pour ignorer l'utilisation des majuscules.

• $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

Cette méthode ne peut pas être utilisée lorsqu'un type de champ est une valeur énumérée. Les exemples ci-dessous sont incorrects et généreront des erreurs de compilation:

• $e.metadata.event_type = "NETWORK_DNS" nocase
• $e.network.ip_protocol = "TCP" nocase

Champs répétés

tout, tout

Dans UDM et Entity, certains champs sont libellés comme répétés, ce qui indique qu'il s'agit de listes de valeurs ou d'autres types de messages. Dans YARA-L, chaque élément du champ répété est traité individuellement. Autrement dit, si le champ répété est utilisé dans la règle, nous évaluons la règle pour chaque élément du champ. Cela peut entraîner un comportement inattendu. Par exemple, si une règle contient à la fois $e.principal.ip = "1.2.3.4" et $e.principal.ip = "5.6.7.8" dans la section events, la règle ne génère jamais de correspondance, même si "1.2.3.4" et "5.6.7.8" se trouvent dans principal.ip.

Pour évaluer le champ répété dans son ensemble, vous pouvez utiliser les opérateurs any et all. Lorsque any est utilisé, le prédicat est considéré comme vrai si une valeur du champ répété remplit la condition. Lorsque all est utilisé, le prédicat est défini sur "true" si toutes les valeurs du champ répété remplissent la condition.

• any $e.target.ip = "127.0.0.1"
• all $e.target.ip != "127.0.0.1"
• re.regex(any $e.about.hostname, `server-[0-9]+`)
• net.ip_in_range_cidr(all $e.principal.ip, "10.0.0.0/8")

Les opérateurs any et all ne peuvent être utilisés qu'avec des champs répétés. En outre, ils ne peuvent pas être utilisés lors de l'attribution d'un champ répété à une variable d'espace réservé ou de la jointure avec un champ d'un autre événement.

Par exemple, any $e.principal.ip = $ip et any $e1.principal.ip = $e2.principal.ip ne sont pas une syntaxe valide. Pour établir une correspondance ou joindre un champ répété, utilisez $e.principal.ip = $ip. Il y aura une valeur de variable de correspondance ou une jointure pour chaque élément du champ répété.

Lorsque vous écrivez une condition avec any ou all, sachez que nier la condition avec not peut avoir la même signification que l'utilisation de l'opérateur inversé.

Exemple :

• not all $e.principal.ip = "192.168.12.16" vérifie si toutes les adresses IP ne correspondent pas à "192.168.12.16". Cela signifie que la règle vérifie si une adresse IP ne correspond pas à "192.168.12.16".
• all $e.principal.ip != "192.168.12.16" vérifie si toutes les adresses IP ne correspondent pas à "192.168.12.16", ce qui signifie que la règle vérifie qu'aucune adresse IP ne correspond à "192.168.12.16".

Remarque:Les opérateurs any et all ne sont pas encore acceptés dans l'expression de la liste de référence.

Exigences concernant la jointure de variables d'événements

Toutes les variables d'événement utilisées dans la règle doivent être jointes aux autres variables d'événement de l'une des manières suivantes:

• directement en comparant les champs d'événement des deux variables d'événement jointes, par exemple : $e1.field = $e2.field. L'expression ne doit pas inclure d'appels d'arithmétique ou de fonction.

• indirectement via une jointure transitive n'impliquant qu'un champ d'événement (voir la déclaration variable pour une définition de "jointure transitive"). L'expression ne doit pas inclure d'appels d'arithmétique ou de fonction.

Par exemple, en supposant que $e1, $e2 et $e3 sont utilisés dans la règle, les sections events suivantes sont valides.

events:
  $e1.principal.hostname = $e2.src.hostname // $e1 joins with $e2
  $e2.principal.ip = $e3.src.ip // $e2 joins with $e3

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.principal.hostname = $e2.src.hostname // $e1 joins with $e2

  // Function to event comparison is not a valid join condition for $e1 and $e2,
  // but the whole events section is valid because we have a valid join condition in the first line.
  re.capture($e1.src.hostname, ".*") = $e2.target.hostname

Voici des exemples de sections events non valides.

events:
  // Event to function comparison is an invalid join condition for $e1 and $e2.
  $e1.principal.hostname = re.capture($e2.principal.application, ".*")

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.ip = $ip

  // Function to placeholder comparison is an invalid transitive join condition.
  re.capture($e2.target.ip, ".*") = $ip

events:
  $e1.src.port = $port

  // Arithmetic to placeholder comparison is an invalid transitive join condition.
  $e2.principal.port + 800 = $port

Syntaxe de la section de correspondance

Dans la section match, répertoriez les variables de correspondance pour les événements de groupe avant de vérifier les conditions de correspondance. Ces champs sont renvoyés avec chaque correspondance.

• Spécifiez ce que chaque variable de correspondance représente dans la section events.
• Spécifiez la période à utiliser pour mettre en corrélation les événements après le mot clé over. Les événements en dehors de cette période sont ignorés.
• Utilisez la syntaxe suivante pour spécifier la période: <number><s/m/h/d> où s/m/h/d signifie respectivement les secondes, les minutes, les heures et les jours.
• La durée minimale que vous pouvez spécifier est d'une minute.
• Vous pouvez spécifier une durée maximale de 48 heures.

Voici un exemple de match valide:

$var1, $var2 over 5m

Cette instruction renvoie les valeurs $var1 et $var2 (définies dans la section events) lorsque la règle trouve une correspondance. Le temps spécifié est de 5 minutes. Les événements éloignés de plus de cinq minutes ne sont pas corrélés et sont donc ignorés par la règle.

Voici un autre exemple de match valide:

$user over 1h

Cette instruction renvoie $user lorsque la règle trouve une correspondance. Le délai spécifié est de 1 heure. Les événements espacés de plus d'une heure ne sont pas corrélés. La règle ne les considère pas comme une détection.

Voici un autre exemple de match valide :

$source_ip, $target_ip, $hostname over 2m

Cette instruction renvoie $source_ip, $target_ip et $hostname lorsque la règle trouve une correspondance. Le délai spécifié est de deux minutes. Les événements distants de plus de deux minutes ne sont pas corrélés. La règle ne les considère pas comme une détection.

Les exemples suivants illustrent des sections match non valides:

• var1, var2 over 5m // invalid variable name
• $user 1h // missing keyword

Fenêtre coulissante

Par défaut, les règles YARA-L 2.0 sont évaluées à l'aide de fenêtres de saut. Une plage de données d'événements d'entreprise est divisée en un ensemble de fenêtres de saut qui se chevauchent, chacune ayant une durée spécifiée dans la section match. Les événements sont ensuite corrélés dans chaque fenêtre de saut. Avec les fenêtres de saut, il est impossible de rechercher des événements qui se produisent dans un ordre spécifique (par exemple, e1 se produit jusqu'à deux minutes après e2). Une occurrence de l'événement e1 et une occurrence de l'événement e2 sont corrélées tant qu'elles se situent dans la fenêtre de saut.

Les règles peuvent également être évaluées à l'aide de fenêtres coulissantes. Avec les fenêtres glissantes, les fenêtres glissantes d'une durée spécifiée dans la section match sont générées au début ou à la fin par une variable d'événement de tableau de bord spécifiée. Les événements sont ensuite corrélés dans chaque fenêtre glissante. Cela permet de rechercher des événements qui se produisent dans un ordre spécifique (par exemple, e1 se produit dans les deux minutes suivant e2). Une occurrence de e1 et une occurrence de e2 sont corrélées si l'événement e1 se produit pendant la période de glissement après l'événement e2.

Spécifiez les fenêtres glissantes dans la section match d'une règle comme suit:

<match-var-1>, <match-var-2>, ... over <duration> before|after <pivot-event-var>

La variable d'événement de tableau croisé dynamique est la variable d'événement sur laquelle les fenêtres coulissantes sont basées. Si vous utilisez le mot clé before, des fenêtres glissantes sont générées et se terminent par chaque occurrence de l'événement de tableau croisé dynamique. Si le mot clé after est utilisé, des fenêtres glissantes sont générées à chaque occurrence de l'événement de tableau croisé dynamique.

Voici des exemples d'utilisations valides des fenêtres coulissantes:

• $var1, $var2 over 5m after $e1
• $user over 1h before $e2

Remarque : Il est connu que l'utilisation de fenêtres glissantes plutôt que de fenêtres de saut peut ralentir les performances. Google recommande de n'utiliser des fenêtres glissantes que pour des cas spécifiques, par exemple lorsqu'un ordre d'événement est absolument nécessaire ou lorsque la recherche d'événements est inexistante.

Syntaxe de la section de résultats

Dans la section outcome, vous pouvez définir jusqu'à 20 variables de résultat, avec des noms arbitraires. Ces résultats seront stockés dans les détections générées par la règle. Chaque détection peut avoir des valeurs différentes pour les résultats.

Le nom du résultat, $risk_score, est spécial. Vous pouvez éventuellement définir un résultat portant ce nom et, si vous le faites, il doit s'agir d'un type entier. Si le champ est renseigné, le risk_score s'affiche dans la vue Enterprise Insights pour les alertes issues de la détection de règles.

Types de données des variables de résultat

Chaque variable de résultat peut avoir un type de données différent, déterminé par l'expression utilisée pour la calculer. Nous acceptons les types de données de résultat suivants:

• integer
• string
• listes d'entiers
• listes de chaînes

Logique conditionnelle

Vous pouvez utiliser la logique conditionnelle pour calculer la valeur d'un résultat. Les conditions sont spécifiées à l'aide du modèle de syntaxe suivant:

if(BOOL_CLAUSE, THEN_CLAUSE)
if(BOOL_CLAUSE, THEN_CLAUSE, ELSE_CLAUSE)

Vous pouvez lire une expression conditionnelle comme "si BOOL_CLAUSE est vrai, puis renvoyer THEN_CLAUSE, sinon renvoyer ELSE_CLAUSE".

BOOL_CLAUSE doit renvoyer une valeur booléenne. Une expression BOOL_CLAUSE prend une forme semblable à celle des expressions de la section events. Par exemple:

• Noms de champs UDM avec opérateur de comparaison, par exemple:

  if($context.graph.entity.user.title = "Vendor", 100, 0)

• variable d'espace réservé définie dans la section events, par exemple:

  if($severity = "HIGH", 100, 0)

• fonctions renvoyant une valeur booléenne, par exemple:

  if(re.regex($e.network.email.from, .*altostrat\.com), 100, 0)

• effectuez une recherche dans une liste de référence, par exemple:

  if($u.principal.hostname in %my_reference_list_name, 100, 0)

THEN_CLAUSE et ELSE_CLAUSE doivent être du même type de données. Nous acceptons les nombres entiers et les chaînes.

Vous pouvez omettre la valeur ELSE_CLAUSE si le type de données est un entier. En cas d'omission, ELSE_CLAUSE prend la valeur 0. Exemple :

`if($e.field = "a", 5)` is equivalent to `if($e.field = "a", 5, 0)`

Vous devez indiquer la valeur ELSE_CLAUSE si le type de données est une chaîne.

Opérations mathématiques

Vous pouvez utiliser des opérations mathématiques pour calculer des résultats de type "entier". Nous prenons en charge l'addition et la soustraction (mais pas la multiplication, la division ou le modulo) comme opérateurs de niveau supérieur dans le calcul des résultats. Exemple :

outcome:
  $risk_score = max(100 + if($severity = "HIGH", 10, 5) - if($severity = "LOW", 20, 0))

Variables d'espace réservé dans les résultats

Lors du calcul des variables de résultat, vous pouvez utiliser les variables d'espace réservé définies dans la section des événements de votre règle. Dans cet exemple, supposons que $email_sent_bytes a été défini dans la section des événements de la règle:

Exemple d'événement unique:

// 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

Exemple pour plusieurs événements:

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

Agrégations

La section des résultats peut être utilisée dans les règles multi-événements (règles contenant une section de correspondance) et dans les règles à événement unique (règles ne contenant pas de section de correspondance). Les exigences concernant les agrégations sont les suivantes:

• Règles relatives aux événements multiples (avec section "Correspondance")

  • L'expression de calcul des résultats est évaluée sur tous les événements ayant généré une détection particulière.
  • L'expression doit être encapsulée dans une fonction d'agrégation.
    • Exemple : $max_email_size = max($e.network.sent_bytes)
    • Si l'expression contient un champ répété, l'agrégat agit sur tous les éléments du champ répété et sur tous les événements ayant généré la détection.

• Règles relatives à un seul événement (sans section de correspondance)

  • L'expression permettant de calculer les résultats est évaluée sur l'événement unique qui a généré une détection particulière.
  • Vous devez utiliser la fonction d'agrégation pour les expressions impliquant au moins un champ répété
    • Exemple : $suspicious_ips = array($e.principal.ip)
    • L'agrégation opère sur tous les éléments du champ répété
  • Impossible d'utiliser la fonction d'agrégation pour les expressions qui n'impliquent pas de champ répété.
    • Exemple : $threat_status = if($e.principal.file.size > 1024, "SEVERE", "MODERATE")

Vous pouvez utiliser les fonctions d'agrégation suivantes:

• max(): renvoie la valeur maximale sur toutes les valeurs possibles. Fonctionne uniquement avec des nombres entiers.
• min(): renvoie le minimum par rapport à toutes les valeurs possibles. Fonctionne uniquement avec des nombres entiers.
• sum() : renvoie la somme de toutes les valeurs possibles. Fonctionne uniquement avec des nombres entiers.
• count_distinct() collecte toutes les valeurs possibles, puis génère le nombre de valeurs possibles.
• count() se comporte comme count_distinct(), mais renvoie un nombre non distinct de valeurs possibles.
• array_distinct(): collecte toutes les valeurs possibles, puis génère une liste de ces valeurs. La liste des valeurs sera tronquée à 25 éléments aléatoires.
• array() se comporte comme array_distinct(), mais renvoie une liste de valeurs non distinctes. Elle tronque également la liste de valeurs à 25 éléments aléatoires.

La fonction d'agrégation est importante lorsqu'une règle inclut une section condition qui spécifie plusieurs événements, car la fonction d'agrégation s'appliquera à tous les événements ayant généré la détection.

Par exemple, si vos sections outcome et condition contiennent:

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

Étant donné que la section de condition nécessite qu'il y ait plusieurs valeurs event pour chaque détection, les fonctions d'agrégation fonctionnent sur plusieurs événements. Supposons que les événements suivants aient généré une détection:

event:
  // UDM event 1
  asset_id="asset-a"

event:
  // UDM event 2
  asset_id="asset-b"

event:
  // UDM event 3
  asset_id="asset-b"

Les valeurs de vos résultats seront alors les suivantes:

• $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"]

Points à retenir lorsque vous utilisez la section "Résultats" :

Autres remarques et restrictions:

• La section outcome ne peut pas référencer une nouvelle variable d'espace réservé qui n'était pas déjà définie dans la section events.
• La section outcome ne peut pas utiliser de variables d'événement qui n'ont pas été définies dans la section events.
• La section outcome peut utiliser un champ d'événement qui n'a pas été utilisé dans la section events, car la variable d'événement à laquelle appartient le champ d'événement était déjà définie dans la section events.
• La section outcome ne peut mettre en corrélation que les variables d'événements déjà corrélées dans la section events. Il existe des corrélations lorsque deux champs d'événement de variables d'événements différentes sont équivalents.

Vous trouverez un exemple dans la section sur les résultats de la page Présentation de YARA-L 2.0. Pour en savoir plus sur la détection des doublons dans la section des résultats, consultez Créer des analyses contextuelles.

Syntaxe de la section de condition

Dans la section condition, vous pouvez:

• spécifier une condition de correspondance pour les événements et les espaces réservés définis dans la section events ; Pour en savoir plus, consultez la section suivante, Conditions conditionnelles liées aux événements et aux espaces réservés.
• (Facultatif) Utilisez le mot clé and pour spécifier une condition de correspondance à l'aide des variables de résultat définies dans la section outcome. Pour en savoir plus, consultez la section Conditions conditionnelles de résultat ci-dessous.

Les formats de condition suivants sont valides:

condition:
  <event/placeholder conditionals>

condition:
  <event/placeholder conditionals> and <outcome conditionals>

Condition conditionnelles et événements

Répertoriez ici les prédicats de condition pour les événements et les variables d'espace réservé, associés au mot clé and ou or.

Remarque:N'utilisez pas le mot clé not dans les conditions d'événement et les espaces réservés conditionnels.

Les conditions suivantes sont des conditions de délimitation. Ils forcent l'existence de la variable d'événement associée, ce qui signifie qu'au moins une occurrence de l'événement doit apparaître dans toute détection.

• $var // equivalent to #var > 0
• #var > n // where n >= 0
• #var >= m // where m > 0

Les conditions suivantes ne sont pas liées. Elles autorisent l'absence de la variable d'événement associée. Il est donc possible qu'aucune occurrence de l'événement n'apparaisse dans une détection. Cela permet de créer des règles de non-existence, qui recherchent l'absence de variable au lieu de la présence d'une variable.

Remarque:Pour les règles inexistantes (règles contenant !$e ou #e = 0 dans la section condition), le moteur de détection ajoute un délai d'une heure à la latence attendue (en fonction de la fréquence d'exécution de la règle) pour autoriser l'arrivée des données tardives.

• !$var // equivalent to #var = 0
• #var >= 0
• #var < n // where n > 0
• #var <= m // where m >= 0

Dans l'exemple suivant, le caractère spécial # d'une variable (la variable d'événement ou la variable d'espace réservé) représente le nombre d'événements ou de valeurs distincts de cette variable.

$e and #port > 50 or #event1 > 2 or #event2 > 1 or #event3 > 0

L'exemple de non-existence suivant est également valide et prend la valeur True s'il existe plus de deux événements distincts de $event1 et aucun événement distinct de $event2.

#event1 > 2 and !$event2

Remarque : N'utilisez pas de variable match dans la section condition. Il s'agit d'une erreur sémantique, car les événements sont regroupés par la valeur de la variable match.

Remarque : Ne spécifiez pas que des conditions non liées dans toutes les variables event auxquelles une variable match est attribuée. Il s'agit d'une erreur sémantique. Pour qu'une valeur de variable match soit renvoyée, au moins un événement doit contenir la valeur.

Remarque:Si vous utilisez une fenêtre glissante, la variable d'événement de tableau croisé dynamique doit être impliquée dans au moins une condition de délimitation.

Voici des exemples de prédicats non valides:

• $e, #port > 50 // incorrect keyword usage
• $e or #port < 50 // or keyword not supported with non-bounding conditions
• not $e // not keyword is not allowed for event and placeholder conditions

Expressions conditionnelles de résultat

Indiquez les prédicats de condition pour les variables de résultat ici, associés au mot clé and ou or, ou précédés du mot clé not.

Spécifiez les conditions de résultat différemment selon le type de la variable de résultat:

• integer : comparez un littéral littéral avec les opérateurs =, >, >=, <, <=, !=. Exemple:

  $risk_score > 10

• chaîne : comparez un littéral de chaîne avec = ou !=. Exemple:

  $severity = "HIGH"

• liste d'entiers ou de tableaux : spécifiez une condition à l'aide de la fonction arrays.contains. Exemple:

  arrays.contains($event_ids, "id_1234")

Remarque : Si vous utilisez le mot clé or dans la sous-section <event/placeholder conditionnelles>, vous devez l'entourer de parenthèses. Par exemple, ce qui suit est valide: ($e1 or $e2) and $outcome > 0.

Classification des règles

Si vous spécifiez une condition sous forme de résultat dans une règle comportant une section de correspondance, la règle sera classée dans la catégorie multi-événements du quota de règles. Pour en savoir plus sur la classification d'événements unique et multiple, consultez les sections Règle relative à un seul événement et Règle relative à plusieurs événements.

Nombre (#) caractère

Le caractère # est un caractère spécial dans la section condition. Si elle est utilisée avant le nom d'un événement ou d'une variable d'espace réservé, elle représente le nombre d'événements ou de valeurs distincts qui remplissent toutes les conditions de la section events.

Valeur ($)

Le caractère $ est un autre caractère spécial de la section condition. Si elle est utilisée avant le nom d'une variable de résultat, elle représente la valeur de ce résultat.

S'il est utilisé avant un nom d'événement ou de variable d'espace réservé (par exemple, $event), il s'agit d'un raccourci pour #event > 0.

Syntaxe de la section "Options"

Dans la section options, vous pouvez spécifier les options de la règle. La syntaxe de la section options est semblable à celle de la section meta. Toutefois, la clé doit correspondre à l'un des noms d'options prédéfinis, et la valeur n'est pas limitée au type de chaîne.

Actuellement, la seule option disponible est allow_zero_values.

• allow_zero_value : si cette règle est définie sur "true", les correspondances générées par la règle peuvent être des valeurs de variables de correspondance nulles. Les champs d'événement qui ne sont pas renseignés reçoivent des valeurs nulles. Cette option est définie par défaut sur "False".

Remarque:Par défaut, Chronicle ne renvoie pas de valeur nulle en tant que valeurs de variable de correspondance.

Voici la ligne de section options valide:

• allow_zero_values = true

Vérification du type

Chronicle effectue une vérification du type par rapport à votre syntaxe YARA-L lorsque vous créez des règles dans l'interface. Les erreurs de vérification du type affichées vous aident à modifier la règle de manière à vous assurer qu'elle fonctionnera comme prévu.

Voici des exemples de prédicats non valides:

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