Écrire des règles YARA

1 Introduction

2 Anatomie d'une règle

Voici une règle complète pour un « MLAB demo loader » imaginaire. Chaque partie est commentée, et les paragraphes suivants détaillent chaque mot-clé. Les commentaires s'écrivent comme en C : // sur une ligne, /* */ sur plusieurs.

demo_loader.yar

import "pe"                                  // facultatif : charge un module (pe, elf, math, hash...)

rule MLAB_Demo_Loader : demo loader          // nom de la règle + tags facultatifs
{
    meta:                                    // contexte libre clé/valeur, jamais utilisé pour la détection
        author      = "mlab Academy"
        description = "Detects the fictional MLAB demo loader (training sample)"
        date        = "2026-10-21"
        reference   = "https://academy.mlab.sh/page/regles-yara"
        hash        = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
        tlp         = "CLEAR"

    strings:                                 // ce que l'on cherche
        $s1 = "mlab-demo-loader" ascii wide nocase    // chaîne texte + modificateurs
        $s2 = "/gate.php?id=" ascii
        $s3 = "MLAB_MUTEX_7f3a" ascii wide fullword
        $h1 = { 4D 4C 41 42 ?? ?? 00 [2-4] FF }        // chaîne hexa : ?? = octet quelconque, [2-4] = saut
        $r1 = /beacon_[0-9]{4}\.dat/                   // expression régulière
        $x1 = "S3cr3tC0nf1g" xor(0x01-0xff)           // XOR mono-octet, toutes les clés de 1 à 255

    condition:                               // logique booléenne qui décide du match
        uint16(0) == 0x5A4D                  // le fichier commence par « MZ » (PE Windows)
        and filesize < 2MB
        and pe.number_of_sections > 2
        and 2 of ($s*)                       // au moins deux des chaînes $s
        and ($h1 or $r1 or $x1)
}

L'en-tête : nom, tags, préfixes

Le nom d'une règle est un identifiant (lettres, chiffres, tiret bas, 128 caractères au plus, sans chiffre en première position) unique dans son espace de noms. Une convention répandue est TYPE_Famille_Détail (MAL_ pour un malware, SUSP_ pour du suspect, HKTL_ pour un outil offensif). Les tags facultatifs placés après les deux-points servent à filtrer les résultats (yara -t loader). On peut préfixer une règle par private (elle ne remonte jamais de résultat elle-même mais peut servir à d'autres règles) ou par global (sa condition s'applique à toutes les règles du fichier).

meta : le contexte, pour les humains et les outils

Des paires clé/valeur (chaîne, entier ou booléen) qui ne servent jamais à la détection. Renseignez au minimum author, description, date et reference, ainsi que le hash d'un échantillon sur lequel la règle a été testée. Dans six mois, l'analyste qui traitera l'alerte vous dira merci.

strings : trois types de motifs

Les modificateurs s'écrivent après le motif et changent la façon dont il est recherché :

condition : la décision

La condition est une expression booléenne qui peut utiliser and, or, not, des comparaisons et de l'arithmétique. Un identifiant seul ($a) est vrai si la chaîne est trouvée. Chaque chaîne déclarée doit être utilisée dans la condition, sinon la règle ne compile pas.

3 Exemples guidés

On part d'une règle d'une ligne pour arriver à une règle réaliste. Tous les marqueurs sont inventés pour l'exercice : ces règles ne feront pas réagir votre antivirus sur cette page, et vous pouvez les reproduire sans risque en créant des fichiers de test contenant les mêmes chaînes.

Étape 1 : la plus petite règle utile

Une chaîne, une condition. Le bloc meta est facultatif ; seule la section condition est obligatoire.

demo_hello.yar

rule Demo_Hello_Marker
{
    strings:
        $marker = "MLAB-ACADEMY-TEST-MARKER"
    condition:
        $marker
}

Pour tester : printf 'xx MLAB-ACADEMY-TEST-MARKER yy' > sample.txt puis yara -s demo_hello.yar sample.txt. Vous devez voir le nom de la règle, le nom du fichier et l'offset de la correspondance.

Étape 2 : combiner des chaînes (PowerShell suspect)

Un mot-clé isolé comme DownloadString apparaît dans quantité de scripts d'administration légitimes. L'astuce consiste à exiger une combinaison : quelque chose qui télécharge et quelque chose qui exécute en mémoire, dans un petit fichier texte qui n'est pas un exécutable.

ps_cradle.yar

rule SUSP_PS_Download_Cradle
{
    meta:
        author      = "mlab Academy"
        description = "PowerShell script that downloads content and executes it in memory"
        date        = "2026-10-21"
        score       = 60

    strings:
        $dl1 = "Net.WebClient" ascii wide nocase
        $dl2 = "DownloadString" ascii wide nocase
        $dl3 = "Invoke-WebRequest" ascii wide nocase
        $ex1 = "Invoke-Expression" ascii wide nocase
        $ex2 = "IEX(" ascii wide nocase
        $ex3 = "IEX (" ascii wide nocase
        $b64 = "FromBase64String" ascii wide nocase

    condition:
        filesize < 200KB
        and uint16(0) != 0x5A4D
        and 1 of ($ex*)
        and (1 of ($dl*) or $b64)
}

$ yara -s ps_cradle.yar invoice_update.ps1
SUSP_PS_Download_Cradle invoice_update.ps1
0x11:$dl1: Net.WebClient
0x28:$dl2: DownloadString
0x1f:$ex3: IEX (

Remarquez le nommage $dl* / $ex* : regrouper les chaînes par rôle grâce à un préfixe rend des conditions comme 1 of ($ex*) courtes et lisibles. Le champ meta score est une convention utilisée par des scanners comme THOR et LOKI pour pondérer les résultats.

Étape 3 : une règle de famille avec contrôle du format et module

C'est la règle commentée de la section 2. Elle illustre la structure classique d'une règle de famille de malware : d'abord des contrôles structurels peu coûteux (en-tête MZ, taille, nombre de sections PE), puis un seuil de chaînes « faibles » (2 of ($s*)), puis au moins un indicateur « fort » (motif d'octets, regex ou chaîne masquée par XOR). Exiger plusieurs indices indépendants, c'est ce qui limite les faux positifs.

Étape 4 : règles privées, comptages, offsets et boucles

Une règle private sert de brique réutilisable. Ici, Is_PE vérifie à la fois l'en-tête MZ et la signature PE\0\0 située à l'offset indiqué en 0x3C. La règle principale exige ensuite un marqueur de configuration dans les 4 premiers Ko et au moins trois URL, toutes placées après ce marqueur.

demo_config.yar

private rule Is_PE
{
    condition:
        uint16(0) == 0x5A4D and uint32(uint32(0x3C)) == 0x00004550
}

rule MLAB_Demo_Config_Block
{
    meta:
        description = "Demo: string counts, offsets and loops"
    strings:
        $cfg = "[mlab-cfg]"
        $url = /https?:\/\/[a-z0-9.-]{4,64}\/[a-z]{3,10}\.php/ nocase
    condition:
        Is_PE
        and $cfg in (0..4096)
        and #url >= 3
        and for all i in (1..#url) : ( @url[i] > @cfg[1] )
}

Bonus : hash et entropie, sans aucune chaîne

Une règle peut se passer de section strings. Le module hash sait comparer un SHA-256 exact (ici celui d'un fichier vide, en guise d'exemple) et le module math repère les contenus compressés ou chiffrés, dont l'entropie approche 8 (voir aussi le rapport d'analyse de fichier). Le hash dans YARA est pratique mais lent (tout le fichier est haché) : pour de simples IOC de type hash, une recherche dans votre EDR ou sur mlab.sh va plus vite.

import "hash"
import "math"

rule MLAB_Demo_Exact_Hash_And_Entropy
{
    condition:
        filesize < 5MB
        and (
            hash.sha256(0, filesize) == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
            or math.entropy(0, filesize) >= 7.5
        )
}

4 Tests et outils

La ligne de commande yara

Installez-la avec votre gestionnaire de paquets (apt install yara, brew install yara) ou depuis les releases GitHub de VirusTotal/yara. Les commandes essentielles :

# 1. Vérifier qu'un fichier de règles compile (aucune sortie = OK)
$ yara -w demo_hello.yar /dev/null

# 2. Scanner un fichier et afficher les chaînes trouvées (-s)
$ yara -s demo_hello.yar sample.txt
Demo_Hello_Marker sample.txt
0x3:$marker: MLAB-ACADEMY-TEST-MARKER

# 3. Scanner un dossier récursivement (-r) en affichant le bloc meta (-m)
$ yara -r -m rules/ ./samples/

# 4. Compiler une fois avec yarac, puis scanner autant de fois que voulu avec -C
$ yarac rules.yar rules.yarc
$ yara -C rules.yarc ./samples/suspicious.bin

Le compilateur est votre premier relecteur. Voici de vrais messages qu'il affiche ; chacun pointe une erreur classique détaillée en section 5 :

error: rule "bad" in bad.yar(1): unreferenced string "$b"
warning: rule "slow" in slow.yar(1): string "$a" may slow down scanning
warning: rule "slow" in slow.yar(1): $r contains .*, .+ or .{x,} consider using .{,N}, .{1,N} or {x,N} with a reasonable value for N

YARA-X, la nouvelle génération

YARA-X est une réécriture complète de YARA en Rust par la même équipe, stable depuis sa version 1.0 sortie en 2025 et présentée comme l'avenir du projet (YARA 4.x ne reçoit désormais pour l'essentiel que des correctifs). Le langage de règles reste le même, à quelques rares incompatibilités près, les messages d'erreur sont bien plus clairs et les règles complexes s'exécutent plus vite. Toutes les règles de cette page compilent avec YARA 4.5 comme avec YARA-X.

# YARA-X : la réécriture de YARA en Rust par VirusTotal (commande : yr)
$ yr check rules/                    # vérifie que chaque fichier compile
$ yr fmt demo_loader.yar             # normalise l'indentation et la mise en forme
$ yr scan demo_loader.yar ./samples/ # scanne, avec le même langage de règles

Une routine de test qui fonctionne vraiment

5 Pièges courants

Les erreurs qui créent des faux positifs (ou des oublis)

Conseils de performance

YARA commence par extraire de chaque chaîne de courts atomes (4 octets au plus) qu'il recherche tous en une passe grâce à l'algorithme d'Aho-Corasick ; ce n'est qu'ensuite qu'il vérifie les chaînes complètes et évalue les conditions. Une règle aux atomes médiocres ralentit tous les scans, pas seulement le sien.

6 Aller plus loin

Les règles de la communauté

Inutile de repartir de zéro : lisez de bonnes règles pour en apprendre le style, puis réutilisez-les. Vérifiez toujours la licence avant de les intégrer à un produit commercial.

La place de YARA dans votre dispositif de détection

Les trois se complètent : un fichier détecté par YARA fournit des IOC (domaines de C2, hash) pour les règles réseau et logs, et associer chaque règle à sa technique MITRE ATT&CK dans le bloc meta permet de mesurer votre couverture. Pour comprendre ce que font réellement les familles que vous détectez, consultez les modules malware et familles de menaces.