Connexion
Comment les malwares se cachent des antivirus
Pour la majorité des utilisateurs, un antivirus scanne un fichier et détecte la présence de code malveillant grâce aux signatures de détection. Si cela fonctionne encore, aujourd’hui, la complexité des malwares fait que les antivirus doivent intégrer plusieurs défenses.
En effet, les techniques d’offuscation avancées utilisées par les trojans et autres malwares ont pour but de cacher le code malveillant, de retarder l’analyse par les antivirus ou les analystes, et de contourner les systèmes de détection.
Le but est donc de se cacher des antivirus pour échapper aux détections.
Dans ce guide, je passe en revue les méthodes et techniques utilisées par les logiciels malveillants pour se dissimuler ou tromper les antivirus.
Chiffrement et encodage
Pour masquer les éléments les plus révélateurs d’un malware, les attaquants chiffrent ou encodent massivement le code et les données embarquées. Les chaînes de texte en clair sont rarissimes dans les malwares modernes : adresses URL de C2, noms d’API Windows, chemins de fichiers… tout est souvent caché derrière des encodages ou un chiffrement custom.
Le but est de brouiller le code afin qu’aucune partie révélatrice d’un code malveillant ne soit pas facilement détectable.
Par exemple, un trojan comme Pikabot remplace les noms de fonctions et variables par des chaînes aléatoires ou codées, et chiffre ses chaînes de caractères sensibles (telles que les URLs de commande & contrôle) qui ne sont déchiffrées qu’au moment de leur utilisation. De même, les documents Office piégés (macros VBA) ou scripts malveillants insèrent des chaînes hexadécimales ou du Base64 à la place de commandes lisibles pour éviter les détections simples.
L’Encodage Base64 est une méthode très répandue d’obfuscation de commandes script. Par exemple, PowerShell permet d’exécuter un code encodé en Base64 via le paramètre -EncodedCommand.
Les malwares en abusent pour cacher des instructions malveillantes dans un long texte illisible. Plusieurs campagnes ont utilisé des commandes PowerShell encodées en base64 pour dissimuler les charges utiles. Un cas courant : un downloader lance PowerShell avec une commande encodée qui va à son tour télécharger et exécuter du code distant. Voici un exemple illustratif d’une commande PowerShell chiffrée en Base64.
Côté JavaScript, on retrouve des approches similaires. Le trojan Astaroth (vers 2019–2020, toujours actif en 2022) utilisait du code JScript obfusqué et aléatoire dans des fichiers XSL : son script malveillant construisait les chaînes de caractères critiques via String.fromCharCode au lieu de les écrire en clair, évitant ainsi d’exposer des mots-clés suspects (noms de processus, commandes). De plus, Astaroth employait une fonction de randomisation pour modifier légèrement son code à chaque exécution, si bien que la structure du script variait constamment, bien que sa finalité reste la même. Ces techniques combinées (génération dynamique de strings et permutation aléatoire) rendaient le JScript malveillant unique à chaque run, contournant les signatures et retardant l’analyse manuelle.
Au-delà de l’encodage, les malwares chiffrent leur charge utile binaire ou certaines portions de code avec des clés secrètes. Un schéma classique consiste à XORer chaque octet du shellcode ou de la DLL malveillante avec une clé d’un octet ou plus (parfois stockée dans le code, parfois dérivée de l’environnement du système infecté).
Le XOR est trivial à implémenter et a un effet de masquer tout motif en clair dans le binaire.
D’autres utilisent des algorithmes symétriques plus forts (RC4, AES) pour chiffrer leur payload, empêchant toute analyse statique tant que le malware n’a pas effectué la décryption en mémoire.
À lire : Virus PowerShell
En somme, chiffrement et encodage sont devenus la norme dans les malwares récents : les concepteurs ajoutent des couches de chiffrement sur les composants (configuration, charge finale, chaînes, etc.) pour que les défenses ne puissent y reconnaître ni motif ni signature tant que le malware n’est pas activement en train de s’exécuter.
Packers et Crypters
Les packers et crypters sont deux outils majeurs utilisés dans l’obfuscation des malwares, en particulier pour masquer le code binaire exécutable et ainsi tromper les antivirus.
Un crypter chiffre tout ou partie du code malveillant (souvent la « payload ») à l’aide d’un algorithme (XOR, AES, RC4, etc.) et l’encapsule dans un stub (petit programme) capable de le déchiffrer et de l’exécuter en mémoire.
L’obhectif est de rendre le fichier indétectable statiquement, car ce dernier ne contient aucune chaîne suspecte, pas de signature reconnaissable.
Un packer compresse ou chiffre un exécutable, puis le combine avec un stub qui le décompresse ou déchiffre au moment de l’exécution.
Son objectif est d’empêcher l’analyse statique et retarder la rétro-ingénierie.
Ils sont habituellement utilisés par les malwares pour se faire passer pour des logiciels légitimes (même hash modifié à chaque fois).
Les antivirus tentent de les “dépacker” ou de les détecter via heuristiques comportementales.
Fréquemment utilisés par les malwares pour se faire passer pour des logiciels légitimes (même hash modifié à chaque fois).
Notez qu’il existe des packers légitimes, par exemple, UPX (Ultimate Packer for eXecutables) est un packer open-source qui principalement vise à compresser les exécutables pour en réduire la taille. Il est très utilisé par les Setup des applications pour proposer exécutable auto-extractible.
PECompact est un packer commercial utilisé aussi pour les Setup, car il embarque une fonctionnalité d’offuscation pour protéger la logique métier.
Il est donc apprécié des concepteurs de malwares (notamment keyloggers, RATs) parce qu’il rend la rétro-ingénierie plus difficile ayant des fonctionnalités intégrées d’anti-debug.
Il s’agit souvent de version de PECompact modifiée.
Notez que dans l’écosystème des logiciels malveillants, certains groupes sont spécialisés dans la vante de crypters et packers, dit FUD (Fully Undetectable).
Code polymorphe
Un malware polymorphe génère du code différent à chaque infection ou exécution, tout en préservant sa logique malveillante d’origine. Cela se fait via un moteur polymorphique qui modifie certaines parties du programme (ex: clés de chiffrement, ordres des instructions, registres utilisés) de façon aléatoire ou variable.
Chaque instance du malware possède ainsi une signature unique, rendant la détection par empreintes statiques très difficile.
Un exemple classique est le ver Storm qui altérait son code à chaque nouvelle infection pour tromper l’antivirus.
Plus récemment, des trojans comme Pikabot intègrent ce polymorphisme : à chaque installation, Pikabot génère une nouvelle version de lui-même en modifiant ses routines critiques (par ex. les fonctions de chiffrement ou de connexion réseau) afin de produire des empreintes différentes à chaque fois.
Code métamorphe
Encore plus sophistiqués, les malwares métamorphes réécrivent intégralement tout ou partie de leur code à chaque propagation, sans même conserver de déchiffreur polymorphe fixe.
Le virus Win32/Simile et le célèbre virus Zmist (2000) illustrent ce concept extrême où le code était auto-réorganisé de manière quasi aléatoire. Dans les années 2020, peu de malwares grand public utilisent un métamorphisme complet (coûteux en ressources), mais on en retrouve des éléments. Par exemple, Pikabot est capable de transformer son propre code à la volée en mémoire : réordonner les instructions, modifier les flux de contrôle ou remplacer des algorithmes par des équivalents fonctionnels, rendant sa signature très mouvante. Ce bot intègre également des algorithmes de mutation de code qui réécrivent certaines parties à chaque exécution (inversions de conditions, boucles, etc.), pour qu’aucun échantillon n’est identique à un autre. De telles mutations dynamiques produisent un code statistiquement indétectable par des scanners basés sur des motifs fixes.
En résumé, polymorphisme et métamorphisme fournissent aux malwares un camouflage évolutif : chaque exemplaire devient une nouvelle créature inconnue des bases antivirales.
Injection en mémoire et attaques sans fichier
Le malware injecte du code dans des processus légitimes (ex: explorer.exe, svchost.exe) pour masquer son activité.
Cela est fortement utilisé notamment dans les trojans bancaires ou les RATs (Remote Access Trojans).
De plus, cela permet de contourner des protections firewall, car bien souvent, les processus légitimes de Windows ont des règles moins restrictives.
Mais, de plus en plus de malwares adoptent des attaques “fileless” (sans fichier), s’exécutant exclusivement en mémoire pour échapper aux scans de fichiers sur disque.
Plutôt que d’écrire un binaire malveillant identifiable sur le disque dur, ces malwares injectent leur code directement dans la mémoire d’un processus légitime du système. Cette technique permet de ne laisser que très peu de traces : pas de fichier malveillant à analyser, et un code malveillant qui “vit” au sein d’un processus approuvé, ce qui complique énormément la détection. Par exemple, PyLoose (2023) est un malware fileless écrit en Python qui a chargé directement un mineur de cryptomonnaie (XMRig) en mémoire sans jamais déposer d’exécutable sur le disque.
À lire :
Chargeurs multi-étapes et exécution de code à la volée
Plutôt que de livrer tout le code malveillant en une fois, les attaquants préfèrent désormais des infections en plusieurs étapes. Un loader (chargeur) initial relativement léger est déposé sur la machine victime ; son rôle est de préparer l’exécution de la charge finale (payload) qui reste chiffrée, distante ou fragmentée tant que le loader n’a pas fait son travail. Cela permet de contourner nombre de détections statiques, car le loader seul peut paraître anodin ou inconnu, tandis que la charge malveillante principale n’est dévoilée qu’au dernier moment, souvent uniquement en mémoire.
Le concept de “code à la volée” recouvre aussi l’utilisation de langages de script et du code auto-modifiant. Par exemple, de nombreux malware en PowerShell, JavaScript ou VBA génèrent ou téléchargent du code au moment de l’exécution plutôt que de l’inclure en dur. PowerShell est notoirement utilisé dans des attaques fileless : un document malveillant va lancer une commande PowerShell qui à son tour télécharge du code distant en mémoire et l’exécute immédiatement.
Pour éviter la détection, ce code PowerShell est fortement obfusqué (variables nommées aléatoirement, concaténations bizarres, encodage en base64 comme vu précédemment, etc.) afin de ne pas révéler en clair les URL ou les commandes dangereuses.
Par exemple : Trojan LNK, Trojan.VBS et Malware PowerShell : Exemple d’une campagne visant la France
Stéganographie
La stéganographie, dans le contexte des malwares, est l’art de cacher du code malveillant ou des données utiles à l’attaque à l’intérieur de fichiers apparemment inoffensifs, souvent des images, vidéos, audios ou même documents bureautiques. Contrairement au chiffrement (qui cache le sens), la stéganographie cache l’existence même des données.
L’objectif de l’attaquant est :
- Éviter la détection par antivirus (aucune charge utile visible dans les fichiers exécutables).
- Passer les firewalls et filtres réseau (un fichier JPG passe mieux qu’un EXE ou un .dll).
- Cacher des commandes (C2), des configurations, des chargeurs ou du code.
- Contourner la surveillance des réseaux et des hôtes.
Par exemple, des malwares reçoivent leurs instructions sous forme de fichiers « bénins » (même publiés publiquement sur Reddit, GitHub, Twitter…) : Cela sert à récupérer des URL, des configurations, ou des scripts obfusqués.
Le botnet extrait une chaîne cachée dans l’image (texte invisible, exécution conditionnelle).
Les macros peuvent charger des images ou documents qui contiennent du code caché.
Le script PowerShell lit un fichier image téléchargé, extrait des données binaires depuis des pixels ou des métadonnées, les déchiffre, puis les injecte en mémoire.
Cela rend la détection de malware difficile pour plusieurs raisons :
Invisible à l’œil nu et aux antivirus classiques.
- Les outils de sécurité traditionnels ne vérifient pas les images ligne par ligne pour y chercher du code.
- La charge utile est dissociée du malware, donc la détection du fichier malveillant ne permet pas de bloquer les commandes à venir.
- Combine souvent obfuscation + chiffrement + stéganographie pour maximiser la furtivité.
Conclusion
De 2020 à 2024, les techniques d’obfuscation des malwares ont atteint un niveau de complexité sans précédent. Polymorphisme et métamorphisme produisent des variantes inédites à la volée, le chiffrement omniprésent des codes et données cache les intentions malveillantes, l’injection furtive en mémoire permet d’opérer depuis l’ombre des processus légitimes, et des loaders multi-étapes sophistiqués déploient les charges utiles de façon conditionnelle et indétectable.
Du côté du défenseur, cela implique de multiplier les couches de protection (analyse comportementale, détection en mémoire, sandbox évasion-aware, etc.) et de constamment mettre à jour les outils d’analyse pour suivre l’évolution de ces menaces. En fin de compte, comprendre en profondeur ces techniques d’obfuscation avancées est indispensable pour anticiper les tactiques des malwares modernes et renforcer les mécanismes de détection et de réponse. Les professionnels cybersécurité doivent maintenir une veille continue sur ces ruses en constante mutation, car l’ingéniosité des attaquants ne cesse de repousser les limites de l’évasion.
Liens
- Les virus informatiques : fonctionnement et protections
- Comment les virus informatiques sont distribués
- Comment fonctionnent les trojans : les explications
- Trojan Stealer : le malware qui vole des données
- Les keylogger ou enregistreur de frappes clavier
- Trojan PowerShell
- Vers informatiques (worms) : description et fonctionnement
- Qu’est-ce que les spywares (logiciel espion) et comment les supprimer
- Les Trojans Banker
- Trojan RAT (Remote Access Tool)
- Les botnets : réseau de machines infectées
- Business malwares : le Pourquoi des infections informatiques
- Comment les virus informatiques sont distribués.
- La sécurité de son PC, c’est quoi ?
- Savoir si on a un virus sur son PC : 9 signes d’une infection par un malware
L’article Comment les malwares se cachent des antivirus est apparu en premier sur malekal.com.
