Automatisation Bug Bounty avec Python : Les Secrets de la Chasse

Automatisation Bug Bounty avec Python : Les Secrets de la Chasse aux Bugs

La chasse aux bugs recompensent deux choses : la couverture et la vitesse. Les hunters au sommet des classements ne sont pas forcément meilleurs pour trouver des vulnérabilités que les autres ils regardent simplement plus de cibles, plus vite, avec moins d'effort manuel. C'est là que Python entre en jeu. C'est le ruban adhésif du monde du bug bounty : assembler des outils de reconnaissance, parser leur sortie, filtrer le bruit, et faire ressortir les signaux qui mènent réellement à des récompenses.

Ce guide explique comment construire un véritable pipeline d'automatisation en Python, les patterns utilisés par les hunters expérimentés, et les erreurs qui maintiennent les débutants bloqués sur des rapports de faible sévérité.

Pourquoi Python Domine l'Automatisation Bug Bounty

La plupart des outils publics de bug bountysubfinder, httpx, nuclei, ffuf, gausont écrits en Go pour leur vitesse. Alors pourquoi Python par-dessus ?

Parce que le travail qui rapporte des bounties ne consiste pas à lancer des outils. C'est de les enchaîner, dédupliquer leur sortie, enrichir les résultats avec du contexte, et remarquer la seule réponse étrange parmi 50 000 que personne d'autre n'a regardée. Les bibliothèques Python requests, asyncio, httpx et BeautifulSoup rendent cette orchestration triviale, et son écosystème (pandas, sqlite3, regex) est imbattable pour découper des données en désordre.

Le modèle mental : les outils Go font le gros du travail, Python fait la réflexion.

Le Pipeline d'Automatisation Bug Bounty Essentiel

Tout setup d'automatisation sérieux suit grosso modo les mêmes cinq étapes :

1. Découverte d'actifs trouver les sous-domaines, IPs et endpoints appartenant à la cible

2. Probing de liveness déterminer ce qui est réellement accessible

3. Fingerprinting identifier les stacks techniques, frameworks et versions

4. Scan de vulnérabilités exécuter des checks templatés contre la surface d'attaque vivante

5. Notification et triage recevoir une alerte uniquement quand quelque chose d'intéressant apparaît

Construisons une version minimale de tout ça en Python.

Étape 1 : Énumération de Sous-Domaines

import subprocess
import json

def enumerate_subdomains(domain: str) -> set[str]:
    sources = [
        ["subfinder", "-d", domain, "-silent"],
        ["assetfinder", "--subs-only", domain],
    ]
    subdomains = set()
    for cmd in sources:
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
            subdomains.update(line.strip() for line in result.stdout.splitlines() if line.strip())
        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
            print(f"[!] {cmd[0]} a échoué : {e}")
    return subdomains

Le secret ici n'est pas le code c'est de lancer ça selon un planning. De nouveaux sous-domaines apparaissent constamment. Un cron job qui compare les résultats d'aujourd'hui à ceux d'hier fait remonter une nouvelle surface d'attaque avant que quiconque ne la voie.

Étape 2 : Probing de Liveness Asynchrone

C'est là où asyncio de Python fait gagner des heures. Au lieu de tester 10 000 hôtes un par un, vous les lancez en parallèle :

import asyncio
import httpx

async def probe(client: httpx.AsyncClient, url: str) -> dict | None:
    try:
        r = await client.get(url, timeout=10, follow_redirects=True)
        return {
            "url": str(r.url),
            "status": r.status_code,
            "title": extract_title(r.text),
            "server": r.headers.get("server", ""),
            "length": len(r.content),
        }
    except Exception:
        return None

async def probe_all(hosts: list[str]) -> list[dict]:
    limits = httpx.Limits(max_connections=50)
    async with httpx.AsyncClient(limits=limits, verify=False) as client:
        tasks = [probe(client, f"https://{h}") for h in hosts]
        results = await asyncio.gather(*tasks)
    return [r for r in results if r]

Cinquante connexions concurrentes vont traverser 10 000 hôtes en quelques minutes. Restez courtois ne martelez pas des cibles uniques avec des centaines de threads.

Étape 3 : Le Diffing Intelligent Le Vrai Secret

La plupart des débutants lancent leur pipeline, regardent les résultats, et se sentent submergés. Les pros ne regardent jamais la sortie complète. Ils regardent les différences.

import sqlite3
from datetime import datetime

def store_and_diff(results: list[dict], db_path: str = "recon.db") -> list[dict]:
    conn = sqlite3.connect(db_path)
    conn.execute("""CREATE TABLE IF NOT EXISTS hosts (
        url TEXT PRIMARY KEY, status INT, title TEXT,
        server TEXT, length INT, first_seen TEXT, last_seen TEXT
    )""")
    new_findings = []
    now = datetime.utcnow().isoformat()
    for r in results:
        existing = conn.execute("SELECT * FROM hosts WHERE url=?", (r["url"],)).fetchone()
        if not existing:
            new_findings.append(r)
            conn.execute("""INSERT INTO hosts VALUES (?,?,?,?,?,?,?)""",
                (r["url"], r["status"], r["title"], r["server"], r["length"], now, now))
        else:
            # Détecter les changements significatifs : code statut, delta de taille, titre
            if existing[1] != r["status"] or abs(existing[4] - r["length"]) > 500:
                new_findings.append({**r, "_changed": True})
            conn.execute("UPDATE hosts SET last_seen=? WHERE url=?", (now, r["url"]))
    conn.commit()
    return new_findings

C'est le plus grand multiplicateur de force de toute l'automatisation bug bounty. Vous ne chassez pas des vulnérabilités vous chassez des changements qui signalent de nouvelles vulnérabilités. Un nouveau sous-domaine, un code statut qui passe de 403 à 200, une longueur de réponse qui bondit de 50 Ko ce sont les signaux qui valent la peine d'être investigués.

Étape 4 : Scan de Vulnérabilités Ciblé

Ne bombardez pas tous les hôtes avec tous les checks. Utilisez les données de fingerprinting pour scanner intelligemment :

def select_nuclei_templates(host: dict) -> list[str]:
    templates = ["cves/", "exposures/"]
    server = host.get("server", "").lower()
    if "nginx" in server: templates.append("technologies/nginx/")
    if "apache" in server: templates.append("technologies/apache/")
    if host.get("status") == 401: templates.append("default-logins/")
    return templates

Lancer 5 000 templates ciblés est meilleur que 50 000 génériques à la fois pour la qualité du signal et la rapidité des résultats.

Étape 5 : Notifications Push

L'automatisation est inutile s'il faut vérifier manuellement. Branchez ça sur Discord, Telegram ou Slack :

import httpx

def notify(webhook: str, findings: list[dict]):
    if not findings: return
    msg = f"🎯 {len(findings)} nouveaux résultats :\n" + "\n".join(
        f"• [{f['status']}] {f['url']}" for f in findings[:10]
    )
    httpx.post(webhook, json={"content": msg})

Le setup de rêve : vous vous réveillez, regardez votre téléphone, voyez trois nouveaux endpoints signalés pendant la nuit, et vous allez les investiguer le café à la main.