← Tous les articles

Scanner la mémoire avec YARA dans le navigateur : balayage physique, VAD et attribution

8 min de lecture

YARA, c'est la manière dont la plupart des équipes codifient ce qu'elles savent déjà d'une menace. L'appliquer à une image mémoire est le moyen le plus rapide de répondre à « cette famille est-elle présente ? ». Mais la mémoire n'est pas un fichier : pas d'offset de départ unique, une séparation entre trames physiques et vues virtuelles par processus, et une chaîne peut chevaucher deux pages physiquement très éloignées. Voici comment ramparser gère tout cela, et ce qu'il ne fait volontairement pas.

Le moteur : YARA-X dans un Web Worker

ramparser embarque le build WebAssembly officiel de YARA-X (1.20.0), servi depuis l'origine du site, jamais depuis un CDN. Il tourne dans un Web Worker dédié qui détient les règles compilées : le scan ne bloque jamais la page et rien ne passe par le réseau.

Si le moteur plante en cours de scan (un problème connu du build navigateur 1.20 sous Chrome), le client relance un worker neuf, recompile les règles et rescanne ce bloc une fois.

Apporter vos propres règles

La vue YARA accepte les règles de trois façons : fichiers .yar / .yara ajoutés depuis le disque ou déposés sur la page, une zone de collage, et un petit jeu de règles intégré. Ce jeu est sous CC0 et écrit pour ces outils : deux règles de chasse génériques (une section de configuration rclone vers un stockage distant, et les « download cradles » PowerShell) et deux règles synthétiques pour le cas de démonstration fictif. Aucune règle tierce n'est fournie et rien n'est téléchargé à l'exécution. Pour un vrai dossier, chargez vos propres packs, par exemple des exports YARA Forge ou signature-base.

Chaque fichier est compilé dans son propre namespace (son nom de fichier) : deux packs peuvent donc réutiliser un même nom de règle. Un fichier en erreur est écarté, les autres compilent quand même. Chaque diagnostic indique le fichier, le code d'erreur YARA-X, la ligne et la colonne, avec le rapport complet à un clic. Après compilation, un tableau liste chaque règle avec ses tags, ses meta et ses chaînes : vous vérifiez ce qui est réellement chargé avant de scanner.

Une bizarrerie du moteur est contournée. YARA-X 1.18 à 1.21 déduplique les motifs identiques entre règles, et une garde d'en-tête sur une règle (uint16(0) == 0x5A4D and $a, filesize > N and $a) peut déteindre sur une autre règle qui partage $a et la faire échouer en silence. ramparser répartit ces règles dans des jeux compilés séparément, les scanne l'un après l'autre et fusionne les hits. Sans conflit, un seul jeu et une seule passe.

Cible 1 : le balayage physique

La première cible est tout l'espace d'adressage physique. ramparser demande au dump ses plages physiques, fusionne celles séparées par 1 Mio ou moins, et les fait passer dans le moteur par blocs de 32 Mio. Chaque bloc relit les 64 premiers Kio du suivant :

  • un match qui commence avant le recouvrement appartient au bloc courant ;
  • un match qui commence dans le recouvrement est laissé au bloc suivant.

Une chaîne à cheval sur une frontière de bloc est donc trouvée une fois, ni deux, ni zéro. La limite : un match de plus de 64 Kio qui franchit une frontière peut être manqué. YARA-X plafonne la longueur des matches bien en dessous.

Le balayage physique voit les pages libérées, le cache de fichiers et la mémoire noyau, ce qu'un scan par processus ne peut pas voir. Sa faiblesse, c'est le contexte : un offset physique ne dit pas à quel processus appartiennent les octets.

Attribuer les hits physiques aux processus

Sur les images Windows avec symboles noyau, ramparser comble ce manque avec une carte inverse des tables de pages. Il parcourt la moitié utilisateur des tables de pages de chaque processus et note, pour chaque trame physique, les couples (pid, adresse virtuelle) qui la mappent. Pour chaque hit, la trame est recherchée et l'offset dans la page ajouté : un match physique se résout en nom de processus, PID et adresse virtuelle utilisateur. Une trame de DLL partagée liste plusieurs propriétaires.

Limites de cette carte :

  • la moitié noyau est exclue volontairement (tous les processus la mappent à l'identique), donc un hit en mémoire noyau reste non attribué ;
  • un hit dans une page libérée ou de cache n'a pas de propriétaire et s'affiche « non attribué » ;
  • au plus 24 propriétaires sont conservés par trame, et seules les 2 000 premières trames touchées sont attribuées.

Cible 2 : les régions VAD par processus

La seconde cible reprend l'approche vadyarascan de Volatility. Pour chaque processus Windows, ramparser prend les régions de l'arbre _MMVAD du noyau, lit chacune via les tables de pages du processus, puis la scanne comme un flux. Les hits portent le PID, la plage VAD et sa protection, et l'adresse virtuelle de chaque match.

Plusieurs réglages gardent ce scan praticable :

  • Filtre de processus : tous, ou un seul PID.
  • Régions adossées à un fichier (images et fichiers mappés) : ignorées par défaut. Le code injecté et les charges dépaquetées vivent en mémoire privée, et ignorer les images évite de rescanner les mêmes DLL système dans chaque processus.
  • Plafond de taille par région : 16, 64 (par défaut), 256 ou 1024 Mio.
  • Régions paginées : les pages absentes de la RAM se lisent comme des zéros, et une région sans aucune page résidente est ignorée.

Le résumé du scan compte ce qui a été ignoré, et pourquoi.

CibleCe qui est luContexte du hit
Balayage physiquetoutes les plages physiques, blocs de 32 Mio + 64 Kio de recouvrementoffset physique, propriétaire via la carte inverse
Scan des VADles régions _MMVAD de chaque processusPID, plage VAD, protection, VA
yarascan (intégré)balayage de chaînes physique mis en cacheoffset physique, famille, contexte
vadyarascan (intégré)4 premiers Mio de chaque VAD, page par pagePID, début du VAD, famille

Les signatures de familles intégrées

Le jeu de plugins Windows comporte aussi deux scanners à la demande qui n'ont besoin d'aucune règle, yarascan et vadyarascan. Malgré leur nom, ce n'est pas du YARA : ils cherchent un catalogue fixe de chaînes littérales issues d'outils courants : Cobalt Strike (beacon.x64.dll, la chaîne de lancement %COMSPEC% /C %s), Metasploit, les commandes Mimikatz (sekurlsa::logonPasswords, lsadump::sam), Empire, Quasar, AsyncRAT, Remcos, et des fragments de notes de rançon Conti et LockBit.

yarascan parcourt la mémoire physique via le balayage de chaînes partagé. Ses hits rejoignent la liste des constats sous la forme « strings in memory », avec un avertissement : ils peuvent venir des signatures d'un antivirus et doivent être confirmés avec vadyarascan. Les familles peu discriminantes (formats génériques d'identifiants, nom du service PsExec) sont exclues des constats.

vadyarascan parcourt les VAD de chaque processus page par page, limité aux 4 premiers Mio de chaque région et à 2 048 régions par processus. Chaque trame physique n'est scannée qu'une fois : les hits d'une trame partagée sont mis en cache et crédités à chaque processus qui la mappe, et la fin de chaque page est accolée au début de la suivante pour qu'une chaîne à cheval sur deux pages soit quand même trouvée. Un hit devient un constat de sévérité haute (« Mimikatz signature in lsass.exe (pid 612) »), sauf un match isolé sur le seul nom de la famille, classé bas car il touche aussi des noms d'API (GdipBitmapLockBits contient « LockBit »).

Comment les hits apparaissent

Les résultats YARA-X sont regroupés par règle, avec ses tags et sa meta description. Chaque ligne indique où le match a été trouvé (physique, ou plage VAD et protection), l'offset, les processus propriétaires sous forme de liens vers la vue processus, et les octets trouvés en ASCII et en hexadécimal. La plage temporelle globale s'applique aussi : un match dont tous les processus propriétaires sont hors plage est masqué et compté.

Des plafonds gardent la vue lisible : 1 000 matches par motif dans le moteur, 1 000 par règle et par région scannée, 10 000 par règle sur la mémoire physique, et les 300 premières lignes affichées par règle. Les exports CSV et JSON contiennent tous les matches conservés, avec les meta de la règle, l'offset physique, le PID, le processus et la VA sur chaque ligne.

Limites à garder en tête

  • Les conditions voient un bloc ou une région, pas un fichier. filesize et uint16(0) s'appliquent au bloc ou à la région. Les règles sur en-tête PE fonctionnent dans le scan des VAD quand l'image commence la région, et seulement par hasard dans le balayage physique.
  • Le scan des VAD et l'attribution sont réservés à Windows et demandent le PDB du noyau. Sous Linux et macOS, le balayage physique fonctionne toujours.
  • Le débit est borné par le navigateur. Le résumé affiche les Mo/s ; un gros pack de règles coûte plus cher par octet que quelques règles ciblées.

Pour aller plus loin