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
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.
Que peut faire YARA ?
Détection de Malware
Identifiez des familles de malware basées sur leurs signatures uniques et patterns comportementaux
Analyse de Fichiers
Scannez des fichiers pour identifier des patterns suspects, strings encodés et structures malveillantes
Threat Hunting
Recherchez proactivement des menaces dans votre infrastructure avec des règles personnalisées
Analyse de Processus
Examinez la mémoire des processus en cours d'exécution pour détecter des comportements malveillants
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
Nom de l'auteur de la règle
Description de la détection
Date de création
URL de référence
Hash du sample
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, asciiOptions de matching
condition
Logique booléenne définissant quand la règle match
and, or, notOpérateurs logiques
all of themTous les strings doivent matcher
any of themAu moins un string doit matcher
filesizeTaille du fichier
uint16(0) == 0x5A4DLecture de valeurs
for..ofBoucles 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)
)
}Règles de détection avancées
Découvrez des exemples réels utilisés en production pour détecter des menaces sophistiquées
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.
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.
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.
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 YARA pour analyses avancées
peAnalyse des fichiers Portable Executable (Windows)
pe.machinepe.timestamppe.sectionspe.importspe.exportspe.resourcespe.number_of_sections > 5elfAnalyse des fichiers ELF (Linux)
elf.typeelf.machineelf.sectionself.segmentself.type == elf.ET_EXECmathFonctions mathématiques et statistiques
math.entropymath.meanmath.deviationmath.monte_carlo_pimath.entropy(0, filesize) > 7.5hashCalcul de hash cryptographiques
hash.md5hash.sha1hash.sha256hash.checksum32hash.md5(0, filesize) == "abc123..."Applications pratiques de YARA
Endpoint Detection
Scannez les endpoints pour détecter des malwares connus
Network Forensics
Analysez le trafic réseau et les captures PCAP
Sandbox Analysis
Intégrez YARA dans vos sandboxes d'analyse
Threat Intelligence
Générez des IOCs et partagez des règles
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 sur différentes plateformes
Ubuntu/Debian
sudo apt-get update
sudo apt-get install yara
yara --version
CentOS/RHEL
sudo yum install epel-release
sudo yum install yara
yara --version
Windows
Télécharger depuis GitHub releases
Extraire yara64.exe
Ajouter au PATH
Python (yara-python)
pip install yara-python
import yara
rules.match(data)
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