Existe-t-il un aide-mémoire YARA imprimable ?

Cette page est conçue comme une référence d’une page ; imprimez-la depuis votre navigateur. Chaque règle complète qu’elle contient compile avec YARA-X 1.20.

Quel est l’opérateur de division entière en YARA ?

YARA utilise la barre oblique inverse pour la division entière, par exemple filesize \ 2, et % pour le reste.

Existe-t-il un aide-mémoire YARA imprimable ?

Cette page est conçue comme une référence d’une page ; imprimez-la depuis votre navigateur. Chaque règle complète qu’elle contient compile avec YARA-X 1.20.

Quel est l’opérateur de division entière en YARA ?

YARA utilise la barre oblique inverse pour la division entière, par exemple filesize \ 2, et % pour le reste.

Aide-mémoire YARA : syntaxe, modificateurs

Une référence dense pour écrire des règles. Chaque règle complète ci-dessous compile avec YARA-X ; testez les vôtres dans l’éditeur.

Squelette de règle

import "pe"

rule PREFIX_Family_Detail : tag1 tag2
{
    meta:
        description = "Ce que détecte la règle"
        author = "vous"
        date = "2026-09-29"
        reference = "https://example.org/rapport"
    strings:
        $x1 = "very specific string" ascii wide
        $s1 = { 8B 45 ?? 33 C9 [2-4] E8 }
        $s2 = /config_[a-f0-9]{8}/
    condition:
        uint16(0) == 0x5A4D and filesize < 5MB and
        (1 of ($x*) or all of ($s*)) and
        pe.number_of_sections > 2
}

Seule condition est obligatoire. Ordre : meta, strings, condition. Modificateurs : private rule (non rapportée, utilisable par d’autres règles), global rule (doit être vraie pour que toute règle de l’espace de noms corresponde).

Chaînes

Type	Syntaxe	Exemple
Texte	`"…"`	`$a = "cmd.exe /c"`
Hexadécimal	`{ … }`	`$h = { 4D 5A ?? 00 }`
Regex	`/…/is`	`$r = /evil[0-9]{2}\.exe/`

Échappements texte : \" \\ \t \n \r \xNN.

Modificateurs

Modificateur	Texte	Hex	Regex	Rôle
`ascii`	oui	–	oui	Octets bruts (par défaut)
`wide`	oui	–	oui	UTF-16LE
`nocase`	oui	–	oui	Insensible à la casse
`fullword`	oui	–	oui	Délimité par des non-alphanumériques
`xor` / `xor(a-b)`	oui	–	–	Clés XOR d’un octet
`base64` / `base64wide`	oui	–	–	Dans des données base64 (3 octets min. avec YARA-X)
`private`	oui	oui	oui	Masqué dans les résultats

Syntaxe hexadécimale

Syntaxe	Signification
`??`	Octet quelconque
`A?` / `?A`	Joker sur un quartet
`[4]` / `[2-6]` / `[8-]`	Sauts
`( 01 02 \| 03 )`	Alternatives
`~00`	Tout octet sauf `00`

Opérateurs de condition

Catégorie	Opérateurs
Booléens	`and` `or` `not`
Comparaison	`==` `!=` `<` `<=` `>` `>=`
Arithmétique	`+` `-` `*` `\` (division entière) `%`
Bit à bit	`&` `\|` `^` `~` `<<` `>>`
Chaînes (valeurs de modules)	`contains` `icontains` `startswith` `istartswith` `endswith` `iendswith` `iequals` `matches`
Motifs	`$a` `#a` `@a[i]` `!a[i]` `$a at N` `$a in (A..B)`
Fichier	`filesize` `uint8/16/32(off)` `int8/16/32(off)` + variantes `be`
Définition	`defined expr`

Quantificateurs et boucles

Expression	Signification
`any of them` / `all of them` / `none of them`	Sur tous les motifs
`2 of ($s*)` / `50% of them`	Nombre ou pourcentage
`any of ($a, $b)`	Ensemble explicite
`for any i in (1..#a) : ( @a[i] < 100 )`	Boucle sur les occurrences
`for all of ($x*) : ( # > 2 )`	Boucle sur les motifs (`$`, `#`, `@` = courant)
`for any s in pe.sections : ( s.name == ".text" )`	Boucle sur un tableau de module
`with x = uint32(0x3C) : ( … )`	Variable locale (YARA-X uniquement)

Magic bytes

Format	Contrôle
PE (MZ)	`uint16(0) == 0x5A4D`
ELF	`uint32(0) == 0x464C457F`
Mach-O 64	`uint32(0) == 0xFEEDFACF`
PDF `%PDF`	`uint32(0) == 0x46445025`
ZIP / OOXML `PK\x03\x04`	`uint32(0) == 0x04034B50`
OLE `D0 CF 11 E0`	`uint32(0) == 0xE011CFD0`
Gzip	`uint16(0) == 0x8B1F`
Shebang `#!`	`uint16(0) == 0x2123`

Extraits de modules

import "pe"
import "math"
import "hash"

rule Module_Snippets
{
    condition:
        pe.is_pe and (
            pe.imports("kernel32.dll", "VirtualAlloc") or
            pe.exports("DllRegisterServer") or
            pe.imphash() == "00000000000000000000000000000000" or
            math.entropy(0, 4096) > 7.0 or
            hash.md5(0, 64) == "00000000000000000000000000000000"
        )
}

Ligne de commande YARA-X

Commande	Rôle
`yr scan rules.yar cible`	Scanner un fichier ou un dossier
`yr scan -s rules.yar cible`	Afficher aussi les motifs trouvés
`yr check rules.yar`	Compiler et signaler erreurs/avertissements
`yr fmt rules.yar`	Formater les règles
`yr compile rules.yar -o rules.yarc`	Enregistrer les règles compilées
`yr dump -m pe fichier.exe`	Voir ce qu’extrait un module

Performance : à faire, à éviter

À faire	À éviter
4 octets fixes consécutifs ou plus par motif	Chaînes de moins de 4 octets
Magic bytes et `filesize` en premier	Appels de modules avant les garde-fous
Jokers seulement sur les opérandes variables	Hex fait de `??` et de `00`
Littéraux d’ancrage dans les regex	`.*` initial, `+` non borné
Boucle sur `1..#a`	Boucle sur `0..filesize`
`nocase`/`xor` sur des chaînes longues	`xor`/`base64` sur des chaînes courtes

Pour les explications, lisez les guides syntaxe, chaînes, conditions, modules et performance ; vérifiez une règle avec le linter.