Python pour la Cybersécurité : Écrivez Votre Premier Script de Sécurité

TL;DR

Python est le langage de programmation le plus utilisé en cybersécurité, présent dans 72 % des projets de développement d'outils de sécurité et des flux d'automatisation SOC. Ce guide accompagne les débutants dans l'écriture de leurs premiers scripts de sécurité : un scanner de ports TCP, un analyseur de fichiers de logs et un vérificateur d'intégrité de fichiers par hachage. Aucune expérience préalable en programmation n'est requise, juste la volonté de taper du code et de l'exécuter.

Il était 18h14 un vendredi lorsque Marcus, un analyste SOC junior trois mois après son premier poste en sécurité, remarqua quelque chose d'inhabituel. Le tableau de bord du SIEM affichait 847 tentatives de connexion échouées contre le même compte utilisateur sur une fenêtre de 90 minutes. Des adresses IP sources différentes. Même cible. Une attaque de credential stuffing typique. Son collègue senior était déjà parti pour le week-end. Le runbook indiquait d'extraire toutes les IP sources, de les croiser avec les flux de renseignement sur les menaces et de bloquer les adresses malveillantes confirmées au niveau du pare-feu. Copier manuellement 847 entrées de log, extraire les IP une par une et vérifier chacune contre un flux de menaces prendrait des heures.

Marcus ouvrit un terminal et écrivit 23 lignes de Python. Le script analysa le fichier de log, extrait les adresses IP sources uniques, vérifia chacune auprès d'une API ouverte de renseignement sur les menaces et généra une liste de blocage des adresses malveillantes confirmées. Temps d'exécution total : 11 secondes. Ce qui aurait consommé toute sa soirée devint un problème résolu avant qu'il ne finisse son café.

Ce script n'était pas élégant. Il n'avait pas de gestion d'erreurs, pas de journalisation, pas d'arguments en ligne de commande. Il était fonctionnel, rapide et résolvait un problème réel. C'est à cela que ressemble Python pour la cybersécurité en pratique. Vous n'avez pas besoin d'être ingénieur logiciel. Vous devez être quelqu'un capable de traduire un problème de sécurité en code fonctionnel.

Pourquoi Python Domine la Cybersécurité

Python occupe une position unique dans le monde de la sécurité car il se situe à l'intersection de la simplicité et de la puissance. Le SANS Institute identifie Python comme le langage le plus recommandé pour les professionnels de la sécurité, soulignant que sa syntaxe lisible permet aux analystes d'écrire des outils fonctionnels sans années de formation en programmation.

Trois caractéristiques font de Python le choix par défaut. Premièrement, sa bibliothèque standard inclut des modules pour le réseau, la gestion de fichiers, la cryptographie et la communication HTTP. Vous pouvez construire un scanner de ports, analyser des fichiers de logs ou interagir avec des API web sans installer un seul paquet externe. Deuxièmement, Python fonctionne sur toutes les plateformes que les professionnels de la sécurité rencontrent : Linux, Windows, macOS et même les systèmes embarqués. Un script écrit sur votre ordinateur portable fonctionne de manière identique sur un serveur distant. Troisièmement, la communauté sécurité a développé des milliers de bibliothèques spécifiquement pour le travail offensif et défensif, de Scapy pour la fabrication de paquets à Volatility pour l'analyse forensique de la mémoire.

L'impact pratique est mesurable. Selon une enquête SANS 2025, les équipes SOC qui automatisent les tâches répétitives avec du scripting réduisent leur temps moyen de réponse (MTTR) jusqu'à 40 %. Lorsqu'une menace émerge à 2 heures du matin, la différence entre une réponse manuelle de 45 minutes et une réponse automatisée de 11 secondes est la différence entre le confinement et la brèche.

Configuration de Votre Environnement Python pour la Sécurité

Avant d'écrire du code, vous avez besoin d'une installation Python fonctionnelle et d'un éditeur de texte. Si vous utilisez Kali Linux ou toute distribution Linux moderne, Python 3 est déjà installé. Vérifiez-le en ouvrant un terminal et en tapant :

python3 --version

Sur Windows ou macOS, téléchargez Python depuis python.org. Lors de l'installation sur Windows, cochez la case « Add Python to PATH ». Cette étape est cruciale. Sans elle, votre terminal ne reconnaîtra pas la commande python.

Pour écrire des scripts, n'importe quel éditeur de texte convient. VS Code avec l'extension Python fournit la coloration syntaxique, la détection d'erreurs et un terminal intégré. Les débutants réussissent souvent bien avec des éditeurs plus simples comme Nano sous Linux ou Notepad++ sous Windows. L'outil importe moins que l'habitude d'écrire réellement du code.

Créez un répertoire dédié pour vos scripts de sécurité :

mkdir ~/security-scripts
cd ~/security-scripts

Tous les scripts de ce guide fonctionnent avec la bibliothèque standard de Python. Aucune installation pip n'est nécessaire pour vos trois premiers projets.

Votre Premier Script : Scanner de Ports TCP

Le scan de ports est fondamental pour les tests d'intrusion et la reconnaissance réseau. Avant de pouvoir tester la sécurité d'un système, vous devez savoir quels services fonctionnent et quels ports sont ouverts. Bien que des outils comme Nmap gèrent cela de manière professionnelle, construire votre propre scanner vous apprend comment les connexions TCP fonctionnent réellement.

Une connexion TCP commence par un handshake en trois étapes. Votre machine envoie un paquet SYN, la cible répond avec SYN-ACK si le port est ouvert, et votre machine complète le handshake avec un ACK. Si le port est fermé, la cible envoie un paquet RST à la place. Le module socket de Python gère l'ensemble de ce processus.

import socket
import sys
from datetime import datetime

def scan_port(target, port):
    """Attempt a TCP connection to a single port."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        result = sock.connect_ex((target, port))
        sock.close()
        return result == 0
    except socket.error:
        return False

def scan_target(target, start_port, end_port):
    """Scan a range of ports on the target host."""
    print(f"\nScanning {target}")
    print(f"Started at {datetime.now().strftime('%H:%M:%S')}")
    print("-" * 40)

    open_ports = []

    for port in range(start_port, end_port + 1):
        if scan_port(target, port):
            open_ports.append(port)
            try:
                service = socket.getservbyport(port)
            except OSError:
                service = "unknown"
            print(f"  Port {port}: OPEN ({service})")

    print(f"\nScan complete. {len(open_ports)} open port(s) found.")
    return open_ports

if __name__ == "__main__":
    target = input("Target IP or hostname: ")
    scan_target(target, 1, 1024)

Enregistrez ceci sous port_scanner.py et exécutez-le avec python3 port_scanner.py. Entrez 127.0.0.1 (votre propre machine) comme cible pour des tests sécurisés. Le script tente une connexion TCP sur chaque port de 1 à 1024, signale les ports ouverts avec leurs noms de service et vous indique combien il en a trouvé.

Ce scanner est volontairement simple. Les outils de production comme Nmap utilisent des raw sockets, le scan SYN et l'exécution multithread pour la vitesse. Mais ce script démontre le concept fondamental : un port est ouvert si une connexion TCP réussit. Comprendre cette base fait de vous un utilisateur plus efficace des outils professionnels.

Automatisation de l'Analyse de Logs Avec Python

Les analystes SOC passent une partie significative de leur journée à lire des logs. Les logs d'authentification, les logs d'accès aux serveurs web, les logs de pare-feu et les logs d'application contiennent tous des preuves d'attaques, de mauvaises configurations et d'anomalies. Réviser manuellement des milliers de lignes est lent et source d'erreurs. Python transforme cela en un processus structuré et reproductible.

Le script suivant analyse un fichier auth.log standard, extrait les tentatives de connexion SSH échouées, compte les tentatives par adresse IP source et signale les IP qui dépassent un seuil :

import re
from collections import Counter

def analyze_auth_log(filepath, threshold=10):
    """Parse auth.log for failed SSH attempts and flag suspicious IPs."""
    failed_pattern = re.compile(
        r"Failed password for (?:invalid user )?(\S+) from (\d+\.\d+\.\d+\.\d+)"
    )

    attempts = []
    usernames_targeted = {}

    with open(filepath, "r") as log_file:
        for line in log_file:
            match = failed_pattern.search(line)
            if match:
                username = match.group(1)
                ip_address = match.group(2)
                attempts.append(ip_address)

                if ip_address not in usernames_targeted:
                    usernames_targeted[ip_address] = set()
                usernames_targeted[ip_address].add(username)

    ip_counts = Counter(attempts)

    print(f"Total failed login attempts: {len(attempts)}")
    print(f"Unique source IPs: {len(ip_counts)}")
    print(f"\nIPs exceeding {threshold} failed attempts:")
    print("-" * 55)

    flagged = []
    for ip, count in ip_counts.most_common():
        if count >= threshold:
            users = usernames_targeted.get(ip, set())
            print(f"  {ip:18s}  {count:4d} attempts  {len(users)} usernames")
            flagged.append(ip)

    if flagged:
        print(f"\nBlocklist ({len(flagged)} IPs):")
        for ip in flagged:
            print(ip)

    return flagged

if __name__ == "__main__":
    flagged_ips = analyze_auth_log("/var/log/auth.log", threshold=10)

Le module re gère la correspondance de motifs avec les expressions régulières. La classe Counter de collections compte automatiquement les occurrences. Ensemble, ils transforment un mur de texte en renseignement actionnable : quelles IP attaquent, avec quelle agressivité et quels noms d'utilisateur sont ciblés.

Ce script révèle des schémas d'attaque que la révision manuelle manque. Une IP qui a essayé 200 noms d'utilisateur différents exécute une attaque par dictionnaire. Une IP qui a essayé le même nom d'utilisateur 500 fois fait du brute force sur un compte spécifique. La distinction est importante car chaque schéma nécessite une réponse différente.

Construction d'un Vérificateur d'Intégrité de Fichiers

La surveillance de l'intégrité des fichiers détecte les modifications non autorisées des fichiers système critiques. Lorsqu'un malware modifie un fichier de configuration, remplace un binaire ou installe une porte dérobée, le hachage cryptographique du fichier change. En comparant les hachages actuels avec des références connues, vous détectez les altérations qui pourraient autrement passer inaperçues.

La Publication Spéciale 800-53 du NIST classe la surveillance de l'intégrité des fichiers comme un contrôle de sécurité fondamental (SI-7). Le module hashlib de Python calcule les hachages en utilisant les mêmes algorithmes sur lesquels reposent les outils d'entreprise.

import hashlib
import os
import json
from datetime import datetime

def hash_file(filepath):
    """Calculate SHA-256 hash of a file."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                sha256.update(chunk)
        return sha256.hexdigest()
    except (PermissionError, FileNotFoundError) as e:
        return f"ERROR: {e}"

def create_baseline(directories, output_file="baseline.json"):
    """Create a hash baseline for files in specified directories."""
    baseline = {}
    file_count = 0

    for directory in directories:
        for root, dirs, files in os.walk(directory):
            for filename in files:
                filepath = os.path.join(root, filename)
                file_hash = hash_file(filepath)
                if not file_hash.startswith("ERROR"):
                    baseline[filepath] = {
                        "hash": file_hash,
                        "recorded_at": datetime.now().isoformat()
                    }
                    file_count += 1

    with open(output_file, "w") as f:
        json.dump(baseline, f, indent=2)

    print(f"Baseline created: {file_count} files recorded.")
    return baseline

def check_integrity(baseline_file="baseline.json"):
    """Compare current file hashes against the baseline."""
    with open(baseline_file, "r") as f:
        baseline = json.load(f)

    modified = []
    missing = []

    for filepath, record in baseline.items():
        if not os.path.exists(filepath):
            missing.append(filepath)
            continue

        current_hash = hash_file(filepath)
        if current_hash != record["hash"]:
            modified.append({
                "file": filepath,
                "expected": record["hash"][:16] + "...",
                "actual": current_hash[:16] + "..."
            })

    print(f"\nIntegrity Check Results")
    print(f"Files checked: {len(baseline)}")
    print(f"Modified: {len(modified)}")
    print(f"Missing: {len(missing)}")

    if modified:
        print(f"\nMODIFIED FILES:")
        for entry in modified:
            print(f"  {entry['file']}")
            print(f"    Expected: {entry['expected']}")
            print(f"    Actual:   {entry['actual']}")

    if missing:
        print(f"\nMISSING FILES:")
        for filepath in missing:
            print(f"  {filepath}")

    return modified, missing

if __name__ == "__main__":
    import sys

    if len(sys.argv) > 1 and sys.argv[1] == "check":
        check_integrity()
    else:
        dirs_to_monitor = ["/etc/ssh", "/etc/cron.d"]
        create_baseline(dirs_to_monitor)
        print("Run with 'check' argument to verify integrity.")

Exécutez python3 integrity_checker.py pour créer une référence, puis python3 integrity_checker.py check pour vérifier les fichiers. Toute modification, même un changement d'un seul octet, produit un hachage complètement différent. C'est le même principe qui alimente des outils comme OSSEC et Tripwire.

Le script lit les fichiers par blocs de 8192 octets, ce qui signifie qu'il gère des fichiers de n'importe quelle taille sans les charger entièrement en mémoire. Il stocke les références en JSON, les rendant lisibles par l'humain et faciles à intégrer avec d'autres outils.

Où Python S'inscrit dans Votre Carrière en Sécurité

Python n'est pas un substitut à la compréhension des concepts de sécurité. C'est un amplificateur. Savoir comment fonctionne une attaque par brute force a de la valeur. Écrire un script qui en détecte une en temps réel, extrait les indicateurs de compromission et génère une liste de blocage est un différenciateur de carrière.

Pour les aspirants analystes SOC, Python automatise les tâches répétitives qui consomment le temps d'investigation : analyser les logs, enrichir les IOC avec du renseignement sur les menaces, générer des rapports et corréler les événements entre les sources de données. Pour les testeurs d'intrusion, Python permet le développement d'exploits personnalisés, la génération de payloads et l'automatisation post-exploitation. Pour les ingénieurs sécurité, les scripts Python intègrent les outils, automatisent le déploiement et appliquent les politiques.

La progression à suivre est claire. Maîtrisez les scripts de la bibliothèque standard de ce guide. Puis explorez les bibliothèques externes : requests pour l'interaction API, scapy pour la manipulation de paquets, paramiko pour l'automatisation SSH. Construisez des outils qui résolvent des problèmes rencontrés dans votre propre lab ou travail. Contribuez à des projets de sécurité open source. Chaque script que vous écrivez développe à la fois la compétence et un portfolio qui démontre vos capacités aux employeurs.

Que Construire Ensuite

Une fois les trois scripts de ce guide fonctionnels, développez-les. Ajoutez le multithreading au scanner de ports pour qu'il termine en secondes au lieu de minutes. Faites en sorte que l'analyseur de logs accepte des arguments en ligne de commande pour fonctionner avec différents formats de log. Planifiez l'exécution du vérificateur d'intégrité toutes les heures avec cron et l'envoi d'alertes par e-mail lorsque des modifications sont détectées.

Puis abordez de nouveaux projets. Écrivez un script qui interroge l'API VirusTotal pour vérifier les hachages de fichiers contre des signatures de malware connues. Construisez une boîte à outils simple de réponse aux incidents qui collecte les informations système, les connexions actives, les processus en cours d'exécution et les modifications récentes de fichiers dans un seul rapport. Créez un analyseur de robustesse de mots de passe qui vérifie les mots de passe contre des listes de mots courants et calcule l'entropie.

Chaque script que vous construisez renforce deux compétences simultanément : la programmation Python et la pensée sécurité. Vous apprenez à penser comme un défenseur et comme un attaquant, ce qui est exactement ce que les employeurs recherchent. L'analyste junior qui a automatisé 847 entrées de log un vendredi soir est devenu la personne de référence de l'équipe pour l'automatisation en six mois. Non pas parce qu'il était le meilleur programmeur, mais parce qu'il était l'analyste capable de traduire les problèmes de sécurité en solutions fonctionnelles.

Commencez avec le scanner de ports. Exécutez-le contre votre propre machine. Lisez la sortie. Comprenez ce que signifie chaque port ouvert. C'est le premier pas de la théorie à la pratique, et Python est le pont qui vous y mène.