GUIDE TECHNIQUEOPEN SOURCE

Maîtriser YARA

Le guide complet pour créer des signatures de détection de malware, identifier des patterns malveillants et automatiser l'analyse de menaces

30 min de lecture
Niveau : Intermédiaire à Expert
4 exemples avancés

Qu'est-ce que YARA ?

YARA (Yet Another Ridiculous Acronym) est un outil open-source de référence dans le domaine de la cybersécurité, développé par Victor Alvarez chez VirusTotal. Il permet d'identifier et de classifier des fichiers malveillants en créant des descriptions basées sur des patterns textuels, binaires ou structurels.

Utilisé massivement en threat intelligence, malware analysiset incident response, YARA est l'outil de prédilection pour détecter des familles de malware, identifier des APTs et automatiser l'analyse de fichiers suspects.

Capacités principales

Que peut faire YARA ?

Détection de Malware

Identifiez des familles de malware basées sur leurs signatures uniques et patterns comportementaux

APT detectionRansomware familiesTrojansRootkits

Analyse de Fichiers

Scannez des fichiers pour identifier des patterns suspects, strings encodés et structures malveillantes

PE analysisDocument macrosScriptsArchives

Threat Hunting

Recherchez proactivement des menaces dans votre infrastructure avec des règles personnalisées

Memory scanningDisk forensicsNetwork capturesLogs analysis

Analyse de Processus

Examinez la mémoire des processus en cours d'exécution pour détecter des comportements malveillants

Process injectionCode cavesPacked malwareRootkit detection
Anatomie d'une règle

Structure d'une règle YARA

Comprenez les 3 composants essentiels d'une règle : meta, strings et condition

meta

Métadonnées descriptives de la règle

author

Nom de l'auteur de la règle

descriptionREQUIS

Description de la détection

date

Date de création

reference

URL de référence

hash

Hash du sample

version

Version de la règle

strings

Patterns à rechercher dans les fichiers

Text strings

$str = "text"

Chaînes ASCII/Unicode

Hex strings

$hex = { 4D 5A 90 }

Séquences d'octets

Regex

$re = /pattern/

Expressions régulières

Modifiers

nocase, wide, ascii

Options de matching

condition

Logique booléenne définissant quand la règle match

and, or, not

Opérateurs logiques

all of them

Tous les strings doivent matcher

any of them

Au moins un string doit matcher

filesize

Taille du fichier

uint16(0) == 0x5A4D

Lecture de valeurs

for..of

Boucles et quantificateurs

Exemple de base

rule Malware_Example
{
    meta:
        author = "CTI Analyst"
        description = "Détecte un malware spécifique"
        date = "2025-10-29"
        reference = "https://example.com/analysis"
        hash = "abc123..."
        severity = "high"
        
    strings:
        $str1 = "malicious_string" nocase wide
        $str2 = "suspicious_function" ascii
        $hex1 = { 4D 5A 90 00 03 }  // PE header
        $regex1 = /https?:\/\/[a-z0-9]{8,}\.com/
        
    condition:
        uint16(0) == 0x5A4D and  // MZ signature
        filesize < 1MB and
        (
            all of ($str*) or
            (#hex1 > 2 and $regex1)
        )
}
Exemples avancés

Règles de détection avancées

Découvrez des exemples réels utilisés en production pour détecter des menaces sophistiquées

IntermédiaireWindows Malware

Détection de PE Malveillant

rule Suspicious_PE_File
{
    meta:
        author = "CTI Analyst"
        description = "Détecte PE avec sections suspectes"
        date = "2025-10-29"
        severity = "high"
        
    strings:
        $mz = "MZ"
        $pe = "PE\x00\x00"
        $suspicious1 = "WinExec" nocase
        $suspicious2 = "URLDownloadToFileA" nocase
        $suspicious3 = "ShellExecuteA" nocase
        
    condition:
        $mz at 0 and
        $pe and
        2 of ($suspicious*) and
        filesize < 500KB
}

💡 Explication

Cette règle détecte des fichiers PE Windows contenant des API suspectes utilisées pour l'exécution de code et le téléchargement de fichiers.

AvancéRansomware

Détection de ransomware

rule Ransomware_Generic
{
    meta:
        description = "Détection générique de ransomware"
        author = "Threat Intel Team"
        tlp = "white"
        
    strings:
        $ransom1 = "encrypted" nocase
        $ransom2 = "bitcoin" nocase
        $ransom3 = "decrypt" nocase
        $crypto1 = "CryptEncrypt"
        $crypto2 = "CryptGenKey"
        $file_ext1 = ".locked"
        $file_ext2 = ".encrypted"
        
    condition:
        uint16(0) == 0x5A4D and
        filesize < 2MB and
        (
            (2 of ($ransom*) and 1 of ($crypto*)) or
            (3 of ($ransom*) and any of ($file_ext*))
        )
}

💡 Explication

Règle pour identifier des ransomwares basée sur des strings caractéristiques et des fonctions cryptographiques.

ExpertCode Analysis

Détection d'obfuscation

rule Obfuscated_Code
{
    meta:
        description = "Détecte du code fortement obfusqué"
        
    strings:
        $base64_pattern = /[A-Za-z0-9+\/]{200,}/
        $high_entropy = { ( [A-F0-9]{2} ){100,} }
        
    condition:
        for any section in pe.sections : (
            section.name matches /^\.[a-z]{4,8}$/ and
            math.entropy(section.raw_data_offset, 
                        section.raw_data_size) > 7.0
        ) or
        #base64_pattern > 5 or
        #high_entropy > 3
}

💡 Explication

Détecte du code obfusqué en analysant l'entropie des sections PE et la présence de patterns encodés.

ExpertAdvanced Persistent Threat

Détection d'APT

import "pe"
import "hash"

rule APT_Backdoor_Custom
{
    meta:
        description = "Détecte un backdoor APT spécifique"
        threat_actor = "APT29"
        mitre_attack = "T1071.001"
        
    strings:
        $c2_pattern = /https?:\/\/[a-z0-9]{16}\.com\/[a-z]{4}/
        $mutex = "Global\\{8F6F0AC4-B9A1-45FD-A8CF-72F04E6BDE8F}"
        $pdb = /[A-Z]:\\Projects\\[a-z]+\\Release\\[a-z]+\.pdb/ nocase
        
    condition:
        uint16(0) == 0x5A4D and
        pe.number_of_sections > 3 and
        pe.timestamp > 1609459200 and // Après 2021
        (
            hash.md5(0, filesize) != 
            hash.md5(pe.sections[0].raw_data_offset, 
                    pe.sections[0].raw_data_size) and
            ($c2_pattern or $mutex or $pdb)
        )
}

💡 Explication

Règle avancée utilisant des modules pour détecter un backdoor APT avec analyse structurelle du PE.

Modules disponibles

Modules YARA pour analyses avancées

pe

Analyse des fichiers Portable Executable (Windows)

pe.machinepe.timestamppe.sectionspe.importspe.exportspe.resources
Exemple d'utilisation :
pe.number_of_sections > 5
elf

Analyse des fichiers ELF (Linux)

elf.typeelf.machineelf.sectionself.segments
Exemple d'utilisation :
elf.type == elf.ET_EXEC
math

Fonctions mathématiques et statistiques

math.entropymath.meanmath.deviationmath.monte_carlo_pi
Exemple d'utilisation :
math.entropy(0, filesize) > 7.5
hash

Calcul de hash cryptographiques

hash.md5hash.sha1hash.sha256hash.checksum32
Exemple d'utilisation :
hash.md5(0, filesize) == "abc123..."
Cas d'usage

Applications pratiques de YARA

Endpoint Detection

Scannez les endpoints pour détecter des malwares connus

YARA + EDR
osquery
Velociraptor

Network Forensics

Analysez le trafic réseau et les captures PCAP

Suricata + YARA
Zeek
NetworkMiner

Sandbox Analysis

Intégrez YARA dans vos sandboxes d'analyse

Cuckoo
CAPE
ANY.RUN

Threat Intelligence

Générez des IOCs et partagez des règles

MISP
OpenCTI
TheHive
Bonnes pratiques

Ce qu'il faut faire & éviter

À faire

Tester sur des datasets variés

Validez vos règles sur benign et malware samples

Utiliser des métadonnées complètes

Author, date, description, références

Optimiser les performances

Évitez les regex complexes, limitez les wildcards

Versionner vos règles

Utilisez Git pour tracker les modifications

Documenter la logique

Commentez les conditions complexes

Utiliser les modules YARA

pe, elf, math, hash pour analyses avancées

À éviter

Règles trop génériques

Évitez les faux positifs massifs

Strings trop courtes

Minimum 8-10 caractères pour éviter les matchs aléatoires

Ignorer les tests de performance

Testez sur de gros volumes de fichiers

Oublier les modifiers

nocase, wide, fullword selon le contexte

Négliger la maintenance

Mettez à jour régulièrement vos règles

Partager sans contexte

Ajoutez toujours des métadonnées et références

Installation

Installation sur différentes plateformes

Ubuntu/Debian

Mise à jour des paquets
sudo apt-get update
Installation de YARA
sudo apt-get install yara
Vérification de l'installation
yara --version

CentOS/RHEL

Activation EPEL
sudo yum install epel-release
Installation de YARA
sudo yum install yara
Vérification
yara --version

Windows

https://github.com/VirusTotal/yara/releases
Télécharger depuis GitHub releases
Dans C:\Program Files\YARA
Extraire yara64.exe
Variables d'environnement système
Ajouter au PATH

Python (yara-python)

Installation du binding Python
pip install yara-python
Import dans vos scripts
import yara
Utilisation programmatique
rules.match(data)
Ressources

Ressources complémentaires

Prêt à créer vos premières règles YARA ?

Mettez en pratique vos connaissances avec nos cas pratiques de détection de malware et d'analyse de menaces