Bug-Bounty-Recon mit KI — Subdomain-Enumeration und Scope-Analyse mit Claude Code

Der Ausgangspunkt

Ich jage Bug-Bounties seit etwa zweieinhalb Jahren, mit durchschnittlichem Erfolg. Ein paar hundert Euro pro Monat neben dem Hauptjob, nichts Weltbewegendes. Das Geld ist nicht das Interessante — das Lernen ist es. Du siehst reale Sicherheits-Setups von echten Firmen, du lernst wie aktuelle Stacks wirklich aussehen.

Der langweiligste Teil am Bug Bounty ist die Recon-Phase. Sobald das Programm breit genug gescoped ist, sitzt du zwei Stunden und machst Subdomain-Enumeration, klickst dich durch gefundene Assets, dokumentierst was interessant aussieht. Das ist genau der Teil wo KI als Copilot Sinn macht.

Hier ist meine aktuelle Pipeline.

Die Scope-Analyse — der erste KI-Schritt

Bug-Bounty-Programme haben oft lange Scope-Dokumente. HackerOne, Intigriti, YesWeHack — alle haben irgendwo eine seitenlange Liste davon, was im Scope ist, was out-of-scope, welche Angriffsklassen akzeptiert werden, welche nicht.

Das manuell zu lesen und die wichtigsten Punkte rauszuziehen kostet jedes Mal 15-20 Minuten. Mit Claude Code delegiere ich das:

# Pipe das Scope-Dokument in Claude Code
pbpaste | claude --prompt "Extrahiere aus diesem Bug-Bounty-Scope-Dokument:
1. Erlaubte Assets (Domains, IPs, Subdomains)
2. Explizit ausgeschlossene Assets
3. Akzeptierte Vulnerability-Klassen
4. NICHT akzeptierte Findings (mit Begründung)
5. Besonderheiten (z.B. 'keine DoS', 'keine Social Eng.')
Format als Markdown-Liste."

Zeit: ~40 Sekunden. Ich lese die fünf Abschnitte, mache einen Sanity-Check am Original, los gehts mit der Recon.

Subdomain-Enumeration — die klassische Pipeline

Ich nutze weiterhin amass und subfinder als Werkzeuge. KI ersetzt die nicht — aber sie orchestriert sauber.

# claude_recon.py — generiert von Claude Code auf meine Anforderung
import subprocess
import json
import asyncio

async def run_tool(cmd, output_file):
    """Wrapper mit Timeout und Error-Handling"""
    proc = await asyncio.create_subprocess_shell(
        cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
    )
    stdout, stderr = await asyncio.wait_for(
        proc.communicate(), timeout=1800
    )
    with open(output_file, "w") as f:
        f.write(stdout.decode())
    return proc.returncode

async def main(target):
    tasks = [
        run_tool(f"amass enum -d {target} -o amass.txt", "amass.log"),
        run_tool(f"subfinder -d {target} -o subfinder.txt -silent", "subfinder.log"),
        run_tool(f"assetfinder --subs-only {target} > assetfinder.txt", "assetfinder.log"),
    ]
    await asyncio.gather(*tasks)
    # Deduplizieren und sortieren
    subs = set()
    for f in ["amass.txt", "subfinder.txt", "assetfinder.txt"]:
        with open(f) as fh:
            subs.update(fh.read().strip().splitlines())
    with open("all_subdomains.txt", "w") as f:
        f.write("\n".join(sorted(subs)))
    return len(subs)

if __name__ == "__main__":
    import sys
    total = asyncio.run(main(sys.argv[1]))
    print(f"Total unique subdomains: {total}")

Drei Werkzeuge parallel. Dedup. Sortieren. Die Pipeline ist nicht mein Werk — ich habe Claude gesagt was ich will, er hat sie geschrieben, ich habe sie reviewt.

Typische Laufzeit für eine mittlere Firma: 8-15 Minuten parallel statt 30-45 Minuten sequenziell. Das ist schon der erste Gewinn.

Der interessante Teil — Live-Asset-Filtering

Nach der Enumeration hast du typisch 200-2000 Subdomains. Viele davon sind tot (DNS aber keine HTTP-Response), andere sind uninteressant (CDN-Endpunkte, Marketing-Landings), ein paar sind spannend.

httpx liefert Basis-Informationen zu jedem Host:

cat all_subdomains.txt | httpx -silent -title -tech-detect -status-code -o httpx_results.json -json

Jetzt der KI-Teil. Ich pipe das JSON durch Claude:

cat httpx_results.json | claude --prompt "Analysiere diese httpx-Outputs.
Gib mir eine priorisierte Liste der interessantesten Targets für Bug-Bounty-Hunting.
Berücksichtige:
- Ungewöhnliche Ports / Technologien
- Auth-Panels, Admin-Interfaces
- Alte Frameworks die bekannte CVEs haben
- Staging-/Dev-Instanzen
Gib mir Top 20 mit Begründung pro Eintrag."

Das Ergebnis ist eine sauber sortierte Shortlist. Ich muss nicht mehr manuell durch 1500 Zeilen JSON klicken. Die Einschätzung ist nicht immer richtig — aber sie ist ein sehr guter Startpunkt.

Nuclei-Templates selbst generieren

Der spannendste Teil der ganzen Pipeline. Nuclei ist ein Scanner der YAML-Templates nutzt um bestimmte Vulnerabilities zu suchen. Es gibt etwa 9000 öffentliche Templates. Die decken das meiste ab, aber oft will man was Spezifisches.

Ich finde bei der Recon ein interessantes Setup — Beispiel: eine Admin-Panel-Route die mit /admin/status GET-Request ohne Auth einen JSON-Dump liefert. Verdacht: ähnliche Routen gibt's mehrfach. Mit Claude Code generiere ich ein Template:

# admin-status-leak.yaml — generiert und reviewt
id: admin-status-leak

info:
  name: Admin Status Endpoint Information Disclosure
  author: dennis-flowki
  severity: medium
  description: Detects unauthenticated /admin/status endpoints returning JSON with sensitive info

http:
  - method: GET
    path:
      - "{{BaseURL}}/admin/status"
      - "{{BaseURL}}/admin/info"
      - "{{BaseURL}}/admin/health"
    matchers-condition: and
    matchers:
      - type: status
        status:
          - 200
      - type: word
        part: body
        words:
          - "\"database\""
          - "\"version\""
          - "\"hostname\""
        condition: or

Template-Build in unter einer Minute. Das gegen meine Subdomain-Liste laufen lassen: nuclei -l active_hosts.txt -t admin-status-leak.yaml. Ich hatte auf einem der Assets tatsächlich einen Treffer. Das war mein Bug.

Die Gesamt-Pipeline an einem realen Beispiel

An einem autorisierten HackerOne-Programm letzte Woche:

| Phase | Zeit | Output | |---|---|---| | Scope-Analyse | 1 min (KI) | Priorisierte Scope-Liste | | Subdomain-Enumeration | 12 min | 487 Subdomains | | Live-Check mit httpx | 4 min | 213 Live-Hosts | | KI-Priorisierung | 2 min | Top-20-Shortlist | | Manuelles Browsing | 35 min | 4 verdächtige Targets | | Custom Nuclei-Template | 3 min | 1 Template gebaut | | Nuclei-Scan | 2 min | 1 Hit | | Validation + PoC | 25 min | Vulnerability bestätigt | | Report schreiben | 20 min | HackerOne-Report |

Total: ~104 Minuten bis zum eingereichten Report.

Vor einem Jahr (ähnliches Programm, ohne KI-Assistent): etwa 4 Stunden für den gleichen Workflow. Die Ersparnis ist fast die Hälfte.

Payout: im mittleren dreistelligen Bereich. Nicht weltbewegend, aber 100 Prozent besser als 0.

Was funktioniert — und was nicht

Klar funktioniert:

• Pipeline-Orchestrierung (Parallelität, Error-Handling, Dedup)
• Output-Filterung und Priorisierung (aus viel Noise wenig Signal machen)
• Template-Generierung (Nuclei, Semgrep, auch Burp-Intruder-Lists)
• Report-Schreiben (Template plus Anpassung)

Bleibt bei dir:

• Die tatsächliche Lücke finden. KI sieht keine Web-App. Klicken, durchdenken, Gefühl für das Setup entwickeln — muss der Mensch.
• Validation und Exploitation. Nicht jede vermeintliche Lücke ist eine echte. Das Urteil ist deins.
• Das Anti-Drittfolgen-Denken. KI will gern noch eskalieren — "und jetzt probieren wir X". Du musst entscheiden ob X noch im Scope ist.

Rechtlicher Rahmen für Bug-Bounty-Recon

Kurzer aber wichtiger Absatz. Bug-Bounty-Recon ist in Deutschland nur dann erlaubt, wenn:

• Das Programm dich ausdrücklich in seinen Scope einschließt
• Du innerhalb des definierten Scopes bleibst (welche Domains, welche Subdomains)
• Du keine destruktive Testing-Techniken verwendest (wenn nicht explizit erlaubt)
• Du deine Finds nur über das Programm meldest, nicht öffentlich streust

Aktive Enumeration gegen Targets außerhalb deines Scopes ist in Deutschland strafbar. Auch wenn die Firma offiziell ein Programm hat — Subdomains die nicht im Scope sind sind nicht im Scope. Das ignoriere ich nicht, und du solltest es auch nicht.

Weiterlesen

Die komplette Pipeline als Python-Pakete und YAML-Templates kommt in der Zone "Hacking & Security" ins Community-Repo. Die Pentesting-Säule hat die weiteren Cluster-Artikel zum Thema. Für die Defender-Perspektive siehe Prompt-Injection-Defense — wenn du selbst LLM-Apps betreibst, sind die Recon-Techniken die gleichen die gegen dich gerichtet werden können.

Eigene Bug-Bounty-Erfahrungen, Pipelines, Setups? Im Discord Zone "Hacking & Security" läuft die Diskussion.