Modules YARA : pe, elf, dotnet, math, hash…

Les modules étendent le langage des conditions avec des analyseurs de formats et des fonctions utilitaires. Plutôt que de calculer des offsets dans un en-tête PE, on interroge pe.number_of_sections ou on vérifie qu’une DLL importe VirtualAllocEx. Ce guide couvre les modules les plus courants dans les règles publiques et ceux disponibles dans les outils de ce site.

Importer un module

Déclarez les modules en tête de fichier avec import. Un module n’analyse que les fichiers qu’il reconnaît : sur un fichier texte, pe.is_pe est simplement faux et la plupart des champs pe sont indéfinis, ce qui rend faux les expressions qui les utilisent.

import "pe"
import "math"

rule Module_Import_Example
{
    condition:
        pe.is_pe and math.entropy(0, filesize) > 7.2
}

La version WebAssembly de YARA-X utilisée par le scanner et l’éditeur inclut pe, elf, macho, dotnet, lnk, math, hash, time, console, string, dex, crx, cuckoo et vt. Le module magic n’y est pas disponible.

pe — exécutables Windows

Le module le plus utilisé. Champs et fonctions fréquents :

import "pe"

rule PE_Injection_Imports
{
    meta:
        description = "Petit PE important le trio classique d'injection distante"
    condition:
        uint16(0) == 0x5A4D and filesize < 2MB and
        pe.imports("kernel32.dll", "VirtualAllocEx") and
        pe.imports("kernel32.dll", "WriteProcessMemory") and
        pe.imports("kernel32.dll", "CreateRemoteThread")
}

rule PE_Odd_Section_Name
{
    condition:
        uint16(0) == 0x5A4D and
        for any s in pe.sections : ( s.name == ".detourd" or s.name == "UPX0" )
}

Le nom de DLL est comparé sans tenir compte de la casse. L’imphash se compare comme une chaîne en minuscules : pe.imphash() == "…".

elf et macho

elf expose l’en-tête, les sections, les segments et les symboles des exécutables Linux et Unix ; macho fait de même pour macOS, y compris les binaires universels (fat).

import "elf"

rule ELF_Small_x64_Executable
{
    condition:
        uint32(0) == 0x464C457F and
        elf.type == elf.ET_EXEC and
        elf.machine == elf.EM_X86_64 and
        filesize < 1MB
}

dotnet

Pour les assemblies .NET : nom et version de l’assembly, GUID, ressources, flux, références de types. Le GUID de module (dotnet.guids) et le nom d’assembly sont souvent stables d’une compilation à l’autre d’un même outil.

import "dotnet"

rule DotNet_Assembly_Name
{
    condition:
        dotnet.is_dotnet and dotnet.assembly.name == "SharpExample"
}

lnk

Analyse les raccourcis Windows : chemin cible, arguments, répertoire de travail, icône, identifiant machine. Utile contre les raccourcis de phishing qui lancent powershell ou mshta.

import "lnk"

rule LNK_Launches_Mshta
{
    condition:
        lnk.is_lnk and lnk.local_base_path contains "mshta"
}

math et hash

math.entropy(offset, taille) renvoie l’entropie de Shannon d’une plage (0 à 8) : au-delà d’environ 7,2, les données sont probablement compressées ou chiffrées. hash.md5/sha1/sha256(offset, taille) renvoient des chaînes hexadécimales en minuscules ; hash.crc32 renvoie un entier.

import "math"
import "hash"

rule Encrypted_Overlay_Or_Known_Blob
{
    condition:
        filesize < 5MB and (
            math.entropy(filesize - 4096, 4096) > 7.5 or
            hash.sha256(0, 1024) == "0000000000000000000000000000000000000000000000000000000000000000"
        )
}

Hacher ou mesurer l’entropie sur tout le fichier (0, filesize) coûte cher sur les gros fichiers. Protégez ces appels par filesize et des contrôles simples placés avant, comme expliqué dans le guide performance.

console, string et time

• console.log("texte", valeur) affiche des valeurs pendant l’évaluation — une aide au débogage des conditions complexes. À retirer avant partage.
• string.to_int("123") et string.length(…) aident à manipuler des valeurs extraites par d’autres modules.
• time.now() renvoie l’heure Unix courante, par exemple pour la comparer à pe.timestamp.

import "pe"
import "time"

rule PE_Timestamp_In_Future
{
    condition:
        pe.is_pe and pe.timestamp > time.now()
}

dex, crx, cuckoo et vt

dex analyse le bytecode Android DEX, crx les extensions Chrome. cuckoo lit un rapport de comportement de sandbox fourni avec le fichier, et vt expose les métadonnées VirusTotal dans Livehunt ; les deux nécessitent des données externes et n’ont de sens que sur les plateformes qui les fournissent. Le module vt est réservé à VirusTotal (voir YARA sur VirusTotal).

Différences YARA-X

Les noms de modules et la plupart des champs sont identiques à YARA 4.x ; la majorité des règles se portent sans changement. Quelques champs ont été renommés ou réorganisés, et YARA-X signale un champ inconnu comme une erreur de compilation au lieu de l’évaluer silencieusement à « indéfini ». En cas d’échec, yr dump -m pe echantillon.exe montre la structure exacte produite par YARA-X ; voir aussi le guide YARA-X vs YARA. Les pages de la bibliothèque indiquent si chaque règle compile avec YARA-X.

Module ou octets bruts ?

Un appel de module est expressif et robuste aux variations de structure, mais l’analyse a un coût. Pour un contrôle simple — « est-ce un PE ? » — uint16(0) == 0x5A4D est plus rapide et suffisant. Réservez les modules à ce que les octets expriment mal : imports, signatures, ressources, tables de sections. Le linter signale les règles qui appellent pe ou elf sans contrôle de magic bytes préalable.

Liste complète : modules YARA-X.