1. À propos de l'analyse statique
L'analyse statique consiste à examiner un programme ou un fichier sans l'exécuter. Cette technique est largement utilisée en cybersécurité, notamment pour effectuer une première étude d'un fichier inconnu ou potentiellement malveillant.
Contrairement à l'analyse dynamique, qui étudie les actions réalisées pendant l'exécution, l'analyse statique travaille directement sur le contenu et la structure du fichier.
L'analyste peut ainsi rechercher des empreintes cryptographiques, des chaînes de caractères, des métadonnées, des bibliothèques, des fonctions importées ou encore des portions de code susceptibles d'apporter des informations sur le fonctionnement du programme.
Objectifs de l'analyse statique
- identifier le type réel du fichier ;
- calculer ses empreintes cryptographiques ;
- examiner sa taille et ses métadonnées ;
- rechercher des chaînes de caractères intéressantes ;
- identifier les bibliothèques utilisées ;
- identifier certaines fonctions importées ;
- examiner la structure du fichier ;
- détecter certains signes d'obfuscation ou de compression ;
- étudier le code source lorsqu'il est disponible ;
- effectuer une première classification du fichier.
Analyse statique et analyse dynamique
| Analyse statique | Analyse dynamique |
|---|---|
| Le programme n'est pas exécuté | Le programme est exécuté |
| Analyse du contenu du fichier | Analyse du comportement |
| Recherche de chaînes | Observation des processus |
| Analyse des métadonnées | Observation des fichiers créés |
| Analyse du code possible | Observation des communications réseau |
| Première étape souvent privilégiée | Nécessite davantage de précautions |
Les deux méthodes sont complémentaires. Une investigation commence fréquemment par une analyse statique, puis se poursuit, si nécessaire, par une analyse dynamique réalisée dans un environnement contrôlé.
2. Identifier un fichier et calculer ses empreintes
Avant d'étudier le contenu d'un programme, il est important de recueillir quelques informations élémentaires : son nom, son extension, sa taille, son type et ses empreintes cryptographiques.
Ne pas se fier uniquement à l'extension
L'extension d'un fichier n'indique pas toujours avec certitude sa nature réelle. Un fichier peut avoir été renommé afin de masquer son véritable format. Les outils d'analyse peuvent donc examiner sa structure et sa signature de fichier, parfois appelée magic number.
Par exemple, de nombreux formats possèdent des octets caractéristiques au début du fichier. Cette information peut aider à déterminer son type sans avoir besoin de l'exécuter.
Afficher les premiers octets d'un fichier
Le programme Python suivant ouvre un fichier pédagogique en mode binaire et affiche ses premiers octets. Cette opération est purement statique : le contenu du fichier n'est jamais exécuté.
1 2 3 4 5 | nom_fichier = "echantillon.bin" with open(nom_fichier, "rb") as fichier: entete = fichier.read(16) print("Premiers octets :", entete) print("Hexadécimal :", entete.hex()) |
Sortie :
1 2 | Premiers octets : b'MZ\x90\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\x00\x00' Hexadécimal : 4d5a90000300000004000000ffff0000 |
Les octets MZ, correspondant aux valeurs hexadécimales 4D 5A, sont notamment associés à l'en-tête de fichiers exécutables de la famille PE sous Windows. Leur présence constitue un indice sur le format du fichier, mais une analyse plus complète reste nécessaire.
Calculer une empreinte SHA-256
Une étape importante consiste à calculer l'empreinte SHA-256 du fichier. Une empreinte permet d'identifier précisément son contenu et de comparer deux fichiers sans avoir à les exécuter.
1 2 3 4 5 6 7 8 9 10 | import hashlib nom_fichier = "echantillon.bin" sha256 = hashlib.sha256() with open(nom_fichier, "rb") as fichier: while True: bloc = fichier.read(4096) if not bloc: break sha256.update(bloc) print("SHA-256 :", sha256.hexdigest()) |
Sortie :
1 | SHA-256 : 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08 |
La valeur ci-dessus est illustrative. Si le contenu du fichier change, même légèrement, son empreinte SHA-256 change normalement également.
Calculer plusieurs empreintes
Il est parfois utile de disposer de plusieurs empreintes pour comparer un fichier à différentes bases de données ou à des rapports existants. L'exemple suivant calcule simultanément MD5, SHA-1 et SHA-256. Pour les nouveaux usages de sécurité, SHA-256 est préférable à MD5 et SHA-1, qui ne sont plus considérés comme résistants aux collisions.
1 2 3 4 5 6 7 | import hashlib nom_fichier = "echantillon.bin" with open(nom_fichier, "rb") as fichier: donnees = fichier.read() print("MD5 :", hashlib.md5(donnees).hexdigest()) print("SHA-1 :", hashlib.sha1(donnees).hexdigest()) print("SHA-256:", hashlib.sha256(donnees).hexdigest()) |
Sortie :
1 2 3 | MD5 : 098f6bcd4621d373cade4e832627b4f6 SHA-1 : a94a8fe5ccb19ba61c4c0873d391e987982fbbd3 SHA-256: 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08 |
3. Analyser les chaînes de caractères et les métadonnées
L'extraction des chaînes de caractères est une technique classique d'analyse statique. Même lorsqu'un programme est compilé, certaines informations textuelles peuvent rester visibles dans le fichier.
Informations pouvant apparaître dans les chaînes
- noms de fichiers ;
- chemins de répertoires ;
- messages affichés par le programme ;
- adresses URL ;
- noms de domaines ;
- adresses IP ;
- noms de bibliothèques ;
- messages d'erreur ;
- clés ou noms de configuration.
Extraire des chaînes ASCII
Le programme suivant illustre une extraction élémentaire de séquences de caractères ASCII imprimables dans un fichier. Il travaille uniquement sur les octets du fichier et ne l'exécute pas.
1 2 3 4 5 6 7 8 9 10 11 12 13 | nom_fichier = "echantillon.bin" with open(nom_fichier, "rb") as fichier: donnees = fichier.read() chaine = "" for octet in donnees: if 32 <= octet <= 126: chaine += chr(octet) else: if len(chaine) >= 4: print(chaine) chaine = "" if len(chaine) >= 4: print(chaine) |
Sortie :
1 2 3 4 | config.ini programme_demo https://example.invalid/api journal.log |
La présence d'une URL, d'un domaine ou d'un nom de fichier ne suffit pas pour conclure qu'un programme est malveillant. Ces informations constituent seulement des indices devant être interprétés avec les autres résultats de l'analyse.
Examiner les métadonnées
Les métadonnées peuvent apporter des informations supplémentaires sur un fichier. Python permet par exemple d'obtenir sa taille et certains horodatages fournis par le système de fichiers.
1 2 3 4 5 6 7 | import os from datetime import datetime nom_fichier = "echantillon.bin" infos = os.stat(nom_fichier) print("Taille :", infos.st_size, "octets") print("Dernière modification :", datetime.fromtimestamp(infos.st_mtime)) print("Dernier accès :", datetime.fromtimestamp(infos.st_atime)) |
Sortie :
1 2 3 | Taille : 32768 octets Dernière modification : 2026-10-31 10:25:42 Dernier accès : 2026-10-31 15:12:08 |
La signification et la disponibilité des différents horodatages dépendent du système d'exploitation et du système de fichiers. Ils doivent donc être interprétés avec prudence.
Rechercher des termes intéressants
Après l'extraction des chaînes, l'analyste peut rechercher certains termes afin de faciliter le tri des résultats. Le programme suivant travaille sur une liste fictive et recherche des mots associés au réseau et au système.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | chaines = [ "programme_demo", "config.ini", "https://example.invalid/api", "socket", "journal.log", "update" ] termes = ["http", "socket", "config", "update"] for chaine in chaines: for terme in termes: if terme.lower() in chaine.lower(): print("Chaîne intéressante :", chaine) break |
Sortie :
1 2 3 4 | Chaîne intéressante : config.ini Chaîne intéressante : https://example.invalid/api Chaîne intéressante : socket Chaîne intéressante : update |
4. Analyser la structure et le code d'un programme
L'analyse statique peut aller beaucoup plus loin que l'examen des chaînes et des empreintes. L'analyste peut étudier la structure du programme, les bibliothèques utilisées, les fonctions importées et, lorsque cela est nécessaire, le code assembleur obtenu par désassemblage.
Analyse des exécutables PE
Sous Windows, de nombreux programmes utilisent le format PE, pour Portable Executable. Un fichier PE possède une structure contenant différentes informations utiles à l'analyse.
L'analyste peut notamment examiner :
- les en-têtes PE ;
- l'architecture du programme ;
- les différentes sections ;
- le point d'entrée ;
- les bibliothèques importées ;
- les fonctions importées ;
- les ressources intégrées ;
- certaines informations relatives à la compilation.
Étudier les imports
Les imports peuvent fournir des indications sur les fonctionnalités susceptibles d'être utilisées par un programme. Un exécutable peut par exemple importer des fonctions relatives aux fichiers, au réseau, aux processus ou à l'interface graphique.
La présence d'une fonction particulière ne prouve cependant pas qu'elle sera utilisée de manière malveillante. Une fonction réseau est également utilisée par de très nombreux programmes légitimes.
Désassemblage
Lorsqu'un programme compilé doit être étudié en profondeur, un désassembleur peut convertir les instructions machine en représentation assembleur lisible par un analyste.
Cette technique permet notamment d'étudier les fonctions internes, les branchements, les appels et la logique générale du programme sans avoir besoin de l'exécuter.
Décompilation
Certains outils proposent également une décompilation. Ils tentent de reconstruire une représentation de plus haut niveau à partir du programme compilé. Le résultat n'est généralement pas identique au code source original, mais il peut être beaucoup plus facile à étudier que le langage assembleur.
Obfuscation et packing
Certains programmes utilisent des techniques d'obfuscation afin de rendre leur analyse plus difficile. Un programme peut également être compressé ou encapsulé à l'aide d'un packer.
Parmi les signes pouvant mériter une investigation supplémentaire figurent une quantité inhabituellement faible de chaînes lisibles, des noms de sections inhabituels ou une structure qui semble fortement transformée. Aucun de ces indices ne constitue toutefois, isolément, une preuve de malveillance.
5. Outils et méthodologie d'analyse statique
De nombreux outils peuvent assister l'analyste. Certains sont spécialisés dans l'identification du format, d'autres dans l'analyse des exécutables, le désassemblage ou la rétro-ingénierie.
Strings
Strings permet d'extraire les chaînes de caractères lisibles présentes dans un fichier binaire. Il constitue souvent l'un des premiers outils utilisés lors d'une analyse statique élémentaire.
Detect It Easy
Detect It Easy, souvent abrégé DIE, permet d'identifier différents formats de fichiers et peut fournir des informations sur des compilateurs, packers et autres caractéristiques du fichier étudié.
PEStudio
PEStudio est particulièrement utile pour examiner statiquement des exécutables Windows. Il permet d'inspecter différentes caractéristiques d'un fichier PE sans avoir besoin de l'exécuter.
Ghidra
Ghidra est une plateforme de rétro-ingénierie permettant notamment le désassemblage et la décompilation de programmes. Elle est adaptée aux analyses statiques plus approfondies.
IDA
IDA est un autre outil largement connu dans le domaine de la rétro-ingénierie et de l'analyse de programmes compilés. Il permet notamment d'examiner les instructions et les structures internes d'un programme.
YARA
YARA est utilisé pour rechercher et classifier des fichiers à partir de règles décrivant certaines caractéristiques. Les règles peuvent notamment s'appuyer sur des chaînes ou des motifs binaires.
Méthodologie générale
- Ne pas exécuter immédiatement le fichier inconnu.
- Conserver l'échantillon dans un environnement approprié.
- Calculer ses empreintes cryptographiques.
- Identifier son format réel.
- Examiner sa taille et ses métadonnées.
- Extraire les chaînes de caractères.
- Rechercher les URL, domaines et autres éléments pertinents.
- Examiner la structure du fichier.
- Étudier les bibliothèques et fonctions importées.
- Rechercher des indices de packing ou d'obfuscation.
- Utiliser un désassembleur ou un décompilateur si nécessaire.
- Documenter chaque observation.
- Comparer et corréler les résultats.
- Décider si une analyse dynamique complémentaire est nécessaire.
Produire un rapport synthétique
Les informations obtenues peuvent être regroupées dans un rapport d'analyse. L'exemple Python suivant montre comment présenter quelques résultats fictifs issus d'une analyse statique.
1 2 3 4 5 6 7 8 9 10 11 12 | rapport = { "Type": "PE Windows", "Architecture": "64 bits", "Taille": "32768 octets", "Chaînes extraites": 126, "Bibliothèques détectées": 5, "Analyse dynamique": "À déterminer" } print("RAPPORT D'ANALYSE STATIQUE") print("--------------------------") for element, valeur in rapport.items(): print(element, ":", valeur) |
Sortie :
1 2 3 4 5 6 7 8 | RAPPORT D'ANALYSE STATIQUE -------------------------- Type : PE Windows Architecture : 64 bits Taille : 32768 octets Chaînes extraites : 126 Bibliothèques détectées : 5 Analyse dynamique : À déterminer |
Dans une investigation réelle, le rapport peut également contenir les empreintes cryptographiques, les chaînes remarquables, les bibliothèques et fonctions importées, les sections du fichier et les conclusions pouvant être raisonnablement tirées des observations.
6. À retenir
L'analyse statique consiste à examiner un programme sans l'exécuter. Elle constitue une étape essentielle de l'analyse de fichiers inconnus et de l'étude de logiciels potentiellement malveillants.
Une première analyse peut identifier le type du fichier, sa taille, ses empreintes cryptographiques, ses métadonnées et les chaînes de caractères qu'il contient.
L'analyse peut ensuite être approfondie en examinant la structure du fichier, ses bibliothèques, ses fonctions importées et son code compilé.
Le désassemblage et la décompilation permettent d'étudier plus précisément le fonctionnement interne d'un programme. Des outils tels que Ghidra, IDA, PEStudio et Detect It Easy peuvent assister l'analyste dans ce travail.
L'analyse statique présente l'avantage de ne pas nécessiter l'exécution du programme étudié. Elle ne permet cependant pas toujours de connaître son comportement réel. Les techniques d'obfuscation, de packing ou certains comportements activés uniquement à l'exécution peuvent limiter les informations disponibles.
C'est pourquoi l'analyse statique et l'analyse dynamique sont généralement considérées comme complémentaires dans une investigation de sécurité.
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
