- À propos du cheval de Troie
- Différences entre Trojan, virus, ver et ransomware
- Principaux types de chevaux de Troie
- Modes de distribution et ingénierie sociale
- Fonctionnement général et cycle d’infection
- Risques pour les systèmes et les utilisateurs
- Environnement de laboratoire Python
- Simulation Python : apparence et comportement
- Analyse statique de scripts Python
- Empreintes et contrôle d’intégrité
- Analyse des journaux et détection
- Prévention et protection contre les chevaux de Troie
- Réponse à un cheval de Troie suspecté
- Mini-projet Python : rapport de contrôle
- À retenir
Le cheval de Troie est l’une des catégories les plus connues de logiciels malveillants. Son principe est de présenter une apparence légitime afin de masquer des fonctions que l’utilisateur n’a pas autorisées. Ce tutoriel étudie les mécanismes, les risques, les indices de détection et les méthodes de protection, puis propose des exercices Python entièrement locaux et transparents.
1. À propos du cheval de Troie
Définition
Un cheval de Troie, ou Trojan, est un logiciel qui se présente comme une application utile ou légitime alors qu’il contient une fonction non annoncée et potentiellement malveillante. Contrairement à un virus, il ne se caractérise pas nécessairement par une capacité à se répliquer. Sa particularité réside dans la tromperie : l’utilisateur croit exécuter un programme répondant à un besoin, mais le programme effectue également des opérations qui ne correspondent pas à son intention.
Pourquoi ce nom ?
Le nom renvoie au récit du cheval de Troie : un objet apparemment inoffensif permet de dissimuler une menace. En informatique, l’analogie décrit la différence entre l’apparence d’un logiciel et son comportement réel. Il faut toutefois distinguer une fonctionnalité simplement mal documentée d’un véritable logiciel malveillant : le contexte, les autorisations et l’intention comptent.
Objectifs du cours
Ce cours explique les mécanismes de tromperie, les risques, les moyens de prévention et les méthodes d’analyse. La partie Python utilise exclusivement des simulations locales et des contrôles défensifs : elle ne met en œuvre ni espionnage, ni persistance cachée, ni connexion de commande à distance.
2. Différences entre Trojan, virus, ver et ransomware
Cheval de Troie
Un Trojan dépend généralement d’une présentation trompeuse ou d’un mécanisme de distribution qui pousse à l’exécuter. Il peut transporter des fonctions variées, mais le terme décrit d’abord le mode de dissimulation.
Virus et ver
Un virus est associé à la contamination d’autres fichiers ou programmes, tandis qu’un ver peut se propager automatiquement entre systèmes. Un même logiciel malveillant peut cumuler plusieurs caractéristiques ; ces catégories ne sont donc pas toujours exclusives.
Rançongiciel et logiciel espion
Un ransomware cherche à rendre des données ou des services indisponibles, souvent par chiffrement, afin d’exercer une pression sur la victime. Un spyware collecte des informations à l’insu de l’utilisateur. Ces fonctions peuvent être présentes dans un logiciel diffusé sous l’apparence d’un programme légitime.
3. Principaux types de chevaux de Troie
Trojan bancaire
Il vise les informations ou opérations financières. Les risques comprennent la fraude, la compromission de comptes et l’utilisation abusive de sessions authentifiées.
Trojan d’accès distant
Un RAT malveillant peut permettre à un adversaire de contrôler certaines fonctions d’un appareil sans consentement. Il se distingue d’un outil d’assistance distant légitime par l’absence d’autorisation et par la dissimulation de son activité.
Téléchargeur et logiciel espion
Un downloader cherche à récupérer d’autres composants, tandis qu’un logiciel espion vise la collecte clandestine de données. Ces comportements doivent être étudiés dans des environnements d’analyse isolés, et non reproduits sur des postes de production.
Faux utilitaires
Certains logiciels se font passer pour un convertisseur, un jeu, une mise à jour ou un outil de nettoyage. L’apparence convaincante d’une interface ne garantit jamais l’innocuité du code exécuté.
4. Modes de distribution et ingénierie sociale
Pièces jointes et téléchargements
Un logiciel malveillant peut être présenté dans un courriel trompeur, sur un faux site de téléchargement ou dans une archive présentée comme un document attendu. Les messages jouent parfois sur l’urgence, l’autorité ou la curiosité pour provoquer l’exécution.
Fausses mises à jour
Une prétendue mise à jour peut inciter l’utilisateur à installer un programme provenant d’une source non officielle. Il est préférable de vérifier la mise à jour directement depuis le logiciel ou le site de l’éditeur.
Risques liés aux logiciels piratés
Les exécutables modifiés et les activateurs non officiels présentent un risque particulier : ils demandent souvent des privilèges élevés et échappent aux mécanismes de distribution contrôlés.
5. Fonctionnement général et cycle d’infection
Exécution initiale
Le point de départ est l’exécution du programme par l’utilisateur ou par un mécanisme compromis. Le comportement peut commencer par une fonction visible destinée à rassurer, puis déclencher des actions non annoncées.
Activités non autorisées
Selon la famille du logiciel malveillant, des actions peuvent viser les fichiers, les paramètres de sécurité, les identifiants ou les communications réseau. Le cours n’implémente pas ces comportements : il les décrit pour faciliter leur reconnaissance.
Détection et intervention
La surveillance des processus, des fichiers et du réseau peut révéler des anomalies. Une réponse appropriée consiste à documenter les faits, isoler le système si nécessaire, préserver les éléments utiles et appliquer les procédures de réponse aux incidents.
6. Risques pour les systèmes et les utilisateurs
Confidentialité
Un Trojan peut exposer des informations personnelles, des documents professionnels ou des secrets d’authentification. La portée dépend des droits du processus et des protections du système.
Intégrité et disponibilité
Des modifications non autorisées peuvent altérer les fichiers, les configurations ou le fonctionnement des services. Certaines familles peuvent contribuer à des interruptions importantes.
Conséquences organisationnelles
Au-delà du poste infecté, les conséquences peuvent comprendre la perte de confiance, les coûts d’investigation, les obligations de notification et l’interruption des activités pédagogiques ou professionnelles.
7. Environnement de laboratoire Python
Prérequis
Les démonstrations utilisent Python 3 et sa bibliothèque standard. Elles peuvent être exécutées avec IDLE, VS Code, Spyder ou un terminal. Aucun accès administrateur, réseau ou logiciel de sécurité particulier n’est nécessaire.
Périmètre de sécurité
Les exemples créent, lorsqu’il le faut, des fichiers de démonstration dans le dossier courant. Ils n’accèdent pas aux données privées, ne modifient pas le démarrage du système et ne communiquent pas avec un serveur extérieur.
Méthode pédagogique
On sépare la simulation du mécanisme de tromperie des techniques réelles d’intrusion. Cette séparation permet de comprendre les signaux d’alerte tout en conservant des programmes faciles à auditer et à réutiliser en classe.
8. Simulation Python : apparence et comportement
Principe de la simulation
Le premier programme présente une application fictive de calculatrice. Il affiche la fonction attendue, puis un message pédagogique explicitement identifié comme une action supplémentaire. Il n’effectue aucune opération clandestine : son objectif est de faire comprendre pourquoi une interface correcte ne suffit pas à établir la confiance.
Audit des fonctionnalités
Le deuxième exemple compare les fonctions annoncées aux fonctions réellement déclarées dans un inventaire fictif. Il montre comment une différence entre documentation et comportement peut déclencher une revue de sécurité, sans supposer automatiquement une intention malveillante.
Exemple 1 : une fausse apparence, simulée sans danger
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 | def calculatrice(a, b): print('Résultat :', a + b) print('Simulation : une fonction non annoncée aurait pu exister') calculatrice(4, 7) |
Output :
1 2 | Résultat : 11 Simulation : une fonction non annoncée aurait pu exister |
Exemple 2 : comparer fonctions déclarées et observées
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 | annoncees = {'addition', 'soustraction'} observees = {'addition', 'soustraction', 'journalisation'} inattendues = sorted(observees - annoncees) print('Fonctions non annoncées :', inattendues) |
Output :
1 | Fonctions non annoncées : ['journalisation'] |
9. Analyse statique de scripts Python
Recherche de marqueurs
L’analyse statique consiste à examiner un fichier sans l’exécuter. Une recherche de chaînes peut attirer l’attention sur des appels réseau ou l’exécution de commandes, mais elle ne permet pas de conclure à elle seule qu’un programme est malveillant.
Interprétation prudente
Un programme d’administration légitime peut employer les mêmes bibliothèques qu’un logiciel dangereux. L’analyste doit donc examiner le contexte, les autorisations, les arguments et les effets réels avant de conclure.
Exemple 3 : rechercher des mots dans un script fictif
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 7 | source = '''import os print('Bonjour') ''' marqueurs = ['import os', 'import socket', 'subprocess'] for marqueur in marqueurs: if marqueur in source: print('À examiner :', marqueur) |
Output :
1 | À examiner : import os |
Exemple 4 : analyser un fichier avec ast sans l’exécuter
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 | import ast source = 'import math\nprint(math.sqrt(16))' arbre = ast.parse(source) imports = [noeud.names[0].name for noeud in arbre.body if isinstance(noeud, ast.Import)] print('Modules importés :', imports) |
Output :
1 | Modules importés : ['math'] |
10. Empreintes et contrôle d’intégrité
Utilité de SHA-256
Une empreinte SHA-256 est une valeur calculée à partir des octets d’un fichier. Une modification des octets change généralement cette valeur, ce qui permet de détecter une différence entre deux exemplaires.
Limites
Une empreinte identique indique que les contenus correspondent, mais ne prouve pas qu’un programme est sûr. Pour vérifier l’origine d’un logiciel, il faut également considérer la signature numérique, la provenance et la chaîne de distribution.
Exemple 5 : calculer une empreinte SHA-256
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 | import hashlib contenu = b'Programme de demonstration' empreinte = hashlib.sha256(contenu).hexdigest() print('Algorithme : SHA-256') print('Taille de l empreinte :', len(empreinte)) |
Output :
1 2 | Algorithme : SHA-256 Taille de l empreinte : 64 |
Exemple 6 : détecter une modification
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 | import hashlib def empreinte(donnees): return hashlib.sha256(donnees).hexdigest() reference = empreinte(b'Version 1') actuelle = empreinte(b'Version 2') print('Intégrité vérifiée :', reference == actuelle) |
Output :
1 | Intégrité vérifiée : False |
11. Analyse des journaux et détection
Journaux d’exécution
Les journaux permettent de relier un programme, un utilisateur, une machine et une chronologie. Les événements fictifs utilisés ici montrent comment rechercher des comportements inattendus sans surveiller un poste réel.
Corrélation
Une seule alerte ne suffit généralement pas. Plusieurs observations concordantes, telles qu’un lancement inhabituel et une modification de fichier, peuvent justifier une investigation, mais restent à confirmer.
Exemple 7 : compter les alertes par machine
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 7 | from collections import Counter journal = [('PC-01', 'alerte'), ('PC-02', 'normal'), ('PC-01', 'alerte'), ('PC-03', 'alerte')] compteur = Counter(machine for machine, etat in journal if etat == 'alerte') for machine, nombre in sorted(compteur.items()): print(machine, ':', nombre) |
Output :
1 2 | PC-01 : 2 PC-03 : 1 |
Exemple 8 : reconstituer une chronologie fictive
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 | evenements = [('10:10', 'Fichier modifié'), ('09:55', 'Application lancée'), ('10:02', 'Alerte déclenchée')] for heure, action in sorted(evenements): print(heure, '-', action) |
Output :
1 2 3 | 09:55 - Application lancée 10:02 - Alerte déclenchée 10:10 - Fichier modifié |
12. Prévention et protection contre les chevaux de Troie
Installation fiable
Télécharger les logiciels depuis des sources officielles, vérifier les signatures lorsqu’elles sont disponibles et éviter les exécutables reçus sans contexte réduit le risque de tromperie.
Moindre privilège et mises à jour
L’usage de comptes non administrateurs, les correctifs de sécurité, le filtrage des applications et la protection des terminaux limitent les possibilités d’action d’un logiciel non fiable.
Sauvegardes et sensibilisation
Des sauvegardes testées et isolées améliorent la résilience. La sensibilisation doit expliquer les faux installateurs, les pièces jointes inattendues et les demandes d’autorisation disproportionnées.
Exemple 9 : vérifier une liste de contrôle
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 | controles = {'source officielle': True, 'signature vérifiée': True, 'mise à jour': False} for nom, valide in controles.items(): print(nom, ':', 'OK' if valide else 'À vérifier') |
Output :
1 2 3 | source officielle : OK signature vérifiée : OK mise à jour : À vérifier |
13. Réponse à un cheval de Troie suspecté
Premières décisions
En cas de suspicion, il faut éviter de multiplier les manipulations sur le poste. Selon le contexte, le CERT ou l’équipe informatique peut recommander un isolement réseau et la conservation des journaux.
Investigation et remédiation
L’équipe recherche l’origine du programme, son périmètre d’exécution et les systèmes potentiellement affectés. Les mesures peuvent inclure la suppression contrôlée, la reconstruction du poste, la rotation des secrets et la restauration de données fiables.
Retour d’expérience
Après le traitement, l’organisation examine les causes : source de téléchargement, permissions, formation des utilisateurs, règles de détection et rapidité du signalement.
Exemple 10 : établir une priorité pédagogique
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 | observations = {'exécution inattendue': 3, 'fichier modifié': 2, 'source inconnue': 2} score = sum(observations.values()) print('Score de vigilance :', score) print('Examen recommandé :', score >= 5) |
Output :
1 2 | Score de vigilance : 7 Examen recommandé : True |
14. Mini-projet Python : rapport de contrôle
Objectif
Le mini-projet rassemble plusieurs vérifications défensives sur un fichier fictif : calcul d’empreinte, comparaison à une référence et recherche de marqueurs textuels. Il produit un rapport lisible et ne lance jamais le fichier examiné.
Limites du mini-projet
Il s’agit d’un exercice de sensibilisation, non d’un antivirus. Un véritable moteur de détection nécessite des signatures fiables, une analyse comportementale, des mises à jour et une gestion rigoureuse des faux positifs.
Exemple 11 : rapport local de vérification
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 7 8 | import hashlib nom = 'outil_demo.py' contenu = b'print(42)' reference = hashlib.sha256(contenu).hexdigest() controle = hashlib.sha256(contenu).hexdigest() print('Fichier :', nom) print('Intégrité :', 'OK' if reference == controle else 'Modifiée') print('Exécution du fichier : non') |
Output :
1 2 3 | Fichier : outil_demo.py Intégrité : OK Exécution du fichier : non |
Exemple 12 : produire un bilan de contrôle
Le programme suivant est une simulation défensive utilisant des données fictives. Il illustre une vérification simple que l’on peut réaliser dans un laboratoire Python. Le résultat affiché permet de comprendre immédiatement le rôle des instructions, sans exécuter de code inconnu ni accéder à des ressources externes.
1 2 3 4 5 6 7 8 | verifications = [('Provenance', True), ('Signature', False), ('Empreinte', True)] valides = sum(1 for _, etat in verifications if etat) print('Contrôles réussis :', valides, '/', len(verifications)) for nom, etat in verifications: if not etat: print('À examiner :', nom) |
Output :
1 2 | Contrôles réussis : 2 / 3 À examiner : Signature |
15. À retenir
Synthèse
Le cheval de Troie repose sur la différence entre l’apparence d’un logiciel et son comportement non autorisé. Il ne doit pas être confondu avec un virus ou un ver, même si plusieurs mécanismes peuvent coexister dans une même menace. La prévention repose sur la provenance des logiciels, le moindre privilège, les mises à jour et la vigilance des utilisateurs.
Apports de Python
Python permet de construire des démonstrations transparentes, d’examiner des fichiers sans les exécuter, de calculer des empreintes et d’analyser des journaux. Ces exercices renforcent les compétences de détection et d’investigation sans reproduire des fonctions malveillantes.
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/



