Syntaxe YARA : anatomie d’une règle

Une règle YARA est un petit programme déclaratif. Une fois ses cinq briques connues — l’en-tête, meta, strings, condition et les imports — vous pouvez lire presque n’importe quelle règle publique. Chaque exemple de ce guide compile avec YARA-X ; collez-les dans l’éditeur en ligne.

L’en-tête de règle

Chaque règle commence par le mot-clé rule suivi d’un identifiant :

rule MAL_Example_Stealer : windows stealer
{
    condition:
        false
}

• Identifiant : lettres, chiffres et underscores, sans chiffre initial, 128 caractères au plus, et jamais un mot-clé (rule, and, them, filesize…). Il est sensible à la casse. Les jeux publics suivent souvent la convention PREFIXE_Famille_Detail décrite dans les conventions.
• Tags : mots optionnels après deux-points. Ils n’influencent pas la correspondance ; les scanners s’en servent pour filtrer ou étiqueter les résultats.
• Corps : tout ce qui est entre accolades.

La section meta

meta contient la documentation sous forme de paires clé/valeur. Les valeurs sont des chaînes, des entiers ou des booléens. Une clé peut se répéter — beaucoup de règles listent plusieurs hash.

rule Meta_Example
{
    meta:
        description = "Montre les trois types de valeurs meta"
        author = "yararules.org"
        date = "2026-09-29"
        score = 70
        experimental = true
    condition:
        true
}

Les valeurs meta ne sont pas utilisables dans la condition, mais elles accompagnent chaque correspondance : les scanners les affichent, et la Detection Rule License demande que le champ author reste visible dans les résultats.

La section strings

Les motifs se déclarent sous la forme $identifiant = valeur, suivie éventuellement de modificateurs. Il en existe trois sortes : chaînes de texte entre guillemets, chaînes hexadécimales entre accolades, expressions régulières entre barres obliques.

rule Strings_Example
{
    strings:
        $text = "cmd.exe /c" ascii wide nocase
        $hex = { 4D 5A 90 00 ?? 00 00 00 }
        $re = /https?:\/\/[a-z0-9.\-]{4,64}\/gate\.php/
    condition:
        any of them
}

Des préfixes communs permettent de former des ensembles ($x1, $x2 → $x*). Un $ seul déclare une chaîne anonyme. Le guide des chaînes couvre échappements et modificateurs. Toute chaîne déclarée doit être utilisée par la condition, directement ou via un ensemble comme them — sinon YARA signale une erreur.

La section condition

La condition est une expression booléenne. Elle peut référencer des motifs ($a), des comptages (#a), des positions (@a[1]), des propriétés du fichier (filesize), des entiers lus dans les données (uint16(0)), des champs de modules (pe.number_of_sections) et d’autres règles. Voir le guide des conditions.

Imports et modules

Les modules étendent la condition avec des formats de fichiers analysés et des fonctions utilitaires. Ils s’importent en tête de fichier :

import "pe"

rule PE_Small_Dll
{
    condition:
        pe.is_pe and pe.is_dll() and filesize < 200KB
}

La version WebAssembly de YARA-X utilisée ici prend en charge pe, elf, macho, dotnet, lnk, math, hash, time, console, string, dex, crx, cuckoo et vt. Voir le guide des modules.

Commentaires

YARA accepte les commentaires // sur une ligne et /* … */ en bloc, partout où un espace est permis. Réservez-les au raisonnement ; tout ce qu’un scanner doit afficher va dans meta.

Règles private et global

Deux modificateurs changent le comportement d’une règle :

• private rule : la règle est évaluée et peut être référencée par d’autres, mais n’est jamais rapportée seule. Idéal pour des briques partagées comme « petit fichier PE ».
• global rule : la règle agit comme un filtre ; si elle est fausse, aucune autre règle du même espace de noms ne peut correspondre. À utiliser avec parcimonie, car elle masque silencieusement tout le reste.

private rule Is_Small_PE
{
    condition:
        uint16(0) == 0x5A4D and filesize < 3MB
}

rule MAL_Example_Uses_Helper
{
    strings:
        $a = "EvilConfigMarker" ascii
    condition:
        Is_Small_PE and $a
}

Une règle ne peut en référencer une autre que si celle-ci est déclarée avant.

Espaces de noms et includes

Quand plusieurs fichiers sont compilés ensemble, chacun peut avoir son espace de noms, ce qui permet à deux jeux de règles de réutiliser un même nom. La directive include "autre.yar" insère un autre fichier à la compilation ; sa prise en charge dépend de l’outil (la ligne de commande résout les chemins relatifs, les outils navigateur de ce site compilent plutôt chaque fichier séparément).

Variables externes

Une règle peut lire des valeurs fournies au moment du scan au lieu de les coder en dur. La variable est définie à la compilation ou au scan (par exemple yara -d env=prod rules.yar cible avec YARA 4, ou --define avec la ligne de commande YARA-X) puis utilisée comme n’importe quel identifiant dans la condition. Un même fichier de règles peut ainsi s’adapter à plusieurs environnements sans modification.

Erreurs de syntaxe fréquentes

YARA-X signale chaque erreur avec un code, un message et la ligne et colonne exactes. Les plus courantes : une chaîne non déclarée dans la condition, une chaîne déclarée mais inutilisée, une section condition: manquante, une séquence d’échappement invalide.

rule Broken_Example
{
    strings:
        $a = "one"
        $b = "two"
    condition:
        $a and $c    // does not compile: $c n'est pas déclaré, $b est inutilisé
}

Collez cette règle dans l’éditeur pour voir YARA-X pointer $c. Pour les problèmes de style et de performance qui ne sont pas des erreurs, utilisez le linter.

En résumé

Une règle, c’est un en-tête, une documentation optionnelle, des motifs optionnels et une condition obligatoire — dans cet ordre. Apprenez ensuite à choisir des motifs spécifiques et rapides dans les chaînes YARA, et gardez l’aide-mémoire sous la main.

Références : Anatomy of a rule (YARA-X) · Writing YARA rules (Read the Docs).