EmploLeaks

EmploLeaks ist ein OSINT-Tool (Open Source Intelligence) mit einer CLI-Oberfläche, das entwickelt wurde, um Informationen über Mitarbeiter eines Zielunternehmens zu ermitteln und zu korrelieren. Es ermöglicht, LinkedIn-Profile zu sammeln, potenzielle Unternehmens-E-Mails zu generieren, durchgesickerte Anmeldedaten in Leak-Datenbanken (intern ClickHouse) zu suchen, bekannte Sicherheitsverletzungen über HaveIBeenPwned zu überprüfen, die Infrastruktur des Unternehmens zu entdecken und Mitarbeiter in sozialen Netzwerken zu profilieren. Alle Informationen werden lokal in SQLite für die spätere Analyse gespeichert.

Funktionen

• Suche und Aufzählung von Mitarbeitern über LinkedIn (Scraping mit Sitzungs-Cookies)
• Automatische Generierung potenzieller Unternehmens-E-Mails mit anpassbaren Formaten
• Suche nach durchgesickerten Anmeldedaten in einer eigenen ClickHouse-Datenbank
• Überprüfung bekannter Sicherheitsverletzungen mit der HaveIBeenPwned-API
• Scannen von Geheimnissen in GitHub/GitLab-Repositories mit gitleaks
• Infrastruktur-Discovery: Subdomain-Enumeration mit assetfinder + SecurityTrails
• Profiling in sozialen Netzwerken: Suche per E-Mail (Holehe, ~120 Plattformen) und per Benutzername (Maigret, 500+ Plattformen)
• Telegram-Scraper (Userbot): eigenständiger Daemon, der sich genehmigten Telegram-Kanälen anschließt und automatisch Dateien mit Anmeldedaten herunterlädt
• 100% agentischer Leak-Parser: keine hartcodierten Regex. Ein KI-Agent schlägt ein Schema vor, validiert es mit einem Score anhand der Stichprobe, erhält Feedback mit Fehlerbeispielen und wiederholt den Vorgang, bis es konvergiert. Automatische Erkennung von UTF-16/UTF-8, ASCII-Art-Bannern, Ländercode-Präfixen, Stealer-Logs (Redline/Lumma/Raccoon) und beliebigen Formaten für E-Mail/Benutzer/URLs
• Lokale Speicherung aller Informationen in SQLite
• Generierung interaktiver HTML-Berichte mit Profilfotos
• Automatische Mitarbeiterklassifizierung nach Abteilung mittels KI (OpenAI, Ollama, etc.)
• Export der Ergebnisse als CSV
• Modulares Plugin-System (LinkedIn, GitHub, HIBP)
• Autospeicherung und automatisches Laden der Plugin-Konfiguration
• Administrative Web-App mit FastAPI + Next.js zur Sichtung der Ergebnisse

Projektstruktur```

emploleaks/ ├── emploleaks.py # Script principal (CLI interactiva con cmd2) ├── telegram_sync.py # Daemon userbot de Telegram (Telethon, standalone) ├── requirements.txt # Dependencias de Python ├── README.md ├── .gitignore ├── plugins/ │ ├── linkedin.py # Plugin de LinkedIn (scraping de empleados) │ ├── github.py # Plugin de GitHub (repos, stalk, secrets) │ └── hibp.py # Plugin de HaveIBeenPwned (brechas) ├── utils/ │ ├── logging_format.py # Configuración de logging con colores │ ├── ai_classifier.py # Clasificación de roles con IA (OpenAI/Ollama) │ ├── leak_parser.py # Parser de leaks 100% agéntico (loop de IA, sin regex) │ ├── email_lookup.py # Búsqueda de emails en redes sociales (Holehe) │ ├── profile_lookup.py # Búsqueda de usernames en redes sociales (Maigret) │ └── discovery.py # Enumeración de subdominios (assetfinder + SecurityTrails opcional) ├── clickhouse-docker/ # Docker Compose para levantar ClickHouse │ ├── docker-compose.yml │ └── config/ │ └── users.xml ├── leaks_data/ # Carpeta para archivos de leaks a importar (no en git) ├── config/ # Configuración (autogenerado) │ └── tokens.ini # Tokens y credenciales de plugins (no en git) ├── data/ # Base de datos local (autogenerado) │ └── emploleaks.db # SQLite con toda la información recopilada ├── webapp/ # Webapp administrativa │ ├── backend/ # FastAPI (Python) │ └── frontend/ # Next.js (React/TypeScript) └── logs/ # Archivos de log (autogenerado) └── log.txt

## Voraussetzungen

- Python 3.10+
- pip
- Internetverbindung
- **Optional:** Docker und Docker Compose (um ClickHouse lokal zu starten)
- **Optional:** [gitleaks](https://github.com/gitleaks/gitleaks) (zum Scannen von Geheimnissen in Repos)
- **Optional:** API-Schlüssel von [HaveIBeenPwned](https://haveibeenpwned.com/API/Key)
- LinkedIn-Sitzungscookies (`JSESSIONID` und `li_at`) für das LinkedIn-Plugin

## Installation

1. Repository klonen:```bash
git clone https://github.com/yourusername/emploleaks.git
cd emploleaks

2. Abhängigkeiten installieren:```bash pip install -r requirements.txt

3. (Optional) ClickHouse mit Docker für die Leaks-Datenbank starten:```bash
cd clickhouse-docker
docker compose up -d
cd ..

Verwendung

Das Tool ausführen:```bash python emploleaks.py

Mit Debug-Modus:```bash
python emploleaks.py -d

Allgemeine Befehle

Unternehmensverwaltung

Plugin-Verwaltung

Verbindung zur Leak-Datenbank (ClickHouse)

Die Verbindung zu ClickHouse wird in config/tokens.ini konfiguriert:```ini [clickhouse] host = localhost port = 9000 user = default passwd = dbname = credentials_db

Wenn ClickHouse in `tokens.ini` konfiguriert ist, wird die Verbindung beim Start automatisch hergestellt.

### Suche nach Anmeldedaten und Sicherheitslücken

| Befehl | Beschreibung |
|---------|-------------|
| `find_passwords <Modus>` | Sucht nach Anmeldedaten in ClickHouse + [ProxyNova COMB](https://www.proxynova.com/tools/comb/) (3,2 Mrd. Credentials). Modi: `find_all`, `only_usernames`, `only_emails` |
| `find_passwords <Modus> --no-proxynova` | Sucht nur in lokalem ClickHouse |
| `find_passwords <Modus> --no-clickhouse` | Sucht nur in ProxyNova COMB (benötigt kein ClickHouse) |
| `find_passwords <Modus> --email <email>` | Sucht nach Anmeldedaten für eine bestimmte E-Mail |
| `find_breaches` | Sucht nach Sicherheitsverletzungen in HIBP für alle E-Mails des Unternehmens (erfordert aktives Plugin `hibp`) |

**ProxyNova COMB** ist eine öffentliche Datenbank mit 3,2 Milliarden geleakten Anmeldedaten (Combination of Many Breaches). Es benötigt keinen API-Schlüssel und wird bei jeder Suche automatisch abgefragt. Verwende `--no-proxynova`, um es zu deaktivieren.

### Infrastruktur-Erkennung

| Befehl | Beschreibung |
|---------|-------------|
| `add_domain <Domäne>` | Ordnet der ausgewählten Organisation eine Domäne zu (z.B. `add_domain faradaysec.com`) |
| `discover` | Führt Subdomänen-Enumeration für alle Domänen der Organisation mit `assetfinder` (+ optional SecurityTrails) durch und löst DNS auf |
| `print --data domains` | Zeigt die registrierten Domänen und die Anzahl der gefundenen Subdomänen an |
| `print --data subdomains` | Zeigt alle Subdomänen mit ihrer IP, Quelle und dem Datum der Entdeckung |

Das Discovery-Modul delegiert die passive Enumeration an [`assetfinder`](https://github.com/tomnomnom/assetfinder), das intern Ergebnisse von crt.sh, HackerTarget, BufferOver und anderen Quellen ohne API-Schlüssel aggregiert. Das Binary wird in `$PATH` erwartet (Installation: `go install github.com/tomnomnom/assetfinder@latest`).

Optional: Wenn Sie einen API-Schlüssel von SecurityTrails konfigurieren, werden deren Subdomänen mit denen von assetfinder zusammengeführt:```ini
[discovery]
# securitytrails_key = your_key_here

Profiling in Sozialen Netzwerken

Holehe (E-Mail-Suche): verwendet die Technik des „Passwort vergessen“, um festzustellen, ob eine E-Mail auf jeder Plattform registriert ist, ohne den Besitzer zu alarmieren. Die Plattformen werden in tokens.ini konfiguriert:```ini [holehe] platforms = google, discord, github, instagram, twitter, spotify, ...

**Maigret** (Benutzersuche): sucht, ob ein Benutzername auf 500+ Social-Media-Plattformen existiert. Die Benutzernamen werden manuell von Mitarbeitern über die Web-App hinzugefügt. Die Plattformen werden optional in `tokens.ini` gefiltert:```ini
[maigret]
# platforms = instagram, twitter, facebook, tiktok, reddit, github

Anzeige und Export

KI-Konfiguration und Klassifizierung

Die KI-Klassifizierung analysiert die Titel/Rollen der Mitarbeiter und gruppiert sie nach Abteilungen (Engineering, Security, Sales usw.). Die Abteilungen werden in SQLite gespeichert und sind im HTML-Bericht sowie in der Webapp sichtbar.

Unterstützte Anbieter (jede mit OpenAI kompatible API):

• Ollama (lokal, Standard): set_ai --endpoint http://localhost:11434/v1 --model llama3
• OpenAI: set_ai --endpoint https://api.openai.com/v1 --key sk-... --model gpt-4o-mini
• Jeder andere kompatible Anbieter: LM Studio, Together AI usw.

Telegram Scraper (Userbot)

Eigenständiger Daemon, der ein persönliches Telegram-Konto (via Telethon) verwendet, um genehmigten Kanälen/Gruppen beizutreten, .txt/.csv/.dat/.zip/.gz-Dateien herunterzuladen und in leaks_data/telegram/<chat>/ abzulegen. Der anschließende import_leaks-Befehl nimmt sie mit dem agentischen Parser in ClickHouse auf. Vom CLI entkoppelt – läuft als separater Prozess, sodass er 24/7 aktiv sein kann, ohne dass das CLI geöffnet sein muss.

Erstmalige Einrichtung (einmalig):

1. App unter https://my.telegram.org/apps erstellen, um api_id und api_hash zu erhalten.
2. In config/tokens.ini hinzufügen: ```ini [telegram] api_id = 12345678 api_hash = abcd1234... session = config/telegram.session download_root = leaks_data/telegram allowed_extensions = txt, csv, dat, zip, gz default_backfill_limit = 10
   root@kitploit:~

3. Interaktiver Login (fragt nach Ihrer Nummer, App-Code, optional 2FA): ```bash python3.13 telegram_sync.py login
   root@kitploit:~

Subcomandos:

Neue Tabellen in data/emploleaks.db:

Daemon im Hintergrund:```bash nohup python3.13 telegram_sync.py run --watch >> logs/telegram.log 2>&1 & echo $! > /tmp/telegram_daemon.pid

Para parar:

kill $(cat /tmp/telegram_daemon.pid)

---

### 100% agentenbasierter Leak-Parser

Das Modul `utils/leak_parser.py` verwendet **ausschließlich einen KI-Agenten**, um jede Datei zu parsen. Es gibt keine hartcodierten Regex (sie wurden entfernt, weil jedes neue Format subtile Extraktionsfehler verursachte).

**Pipeline des Agentens:**```
1. Auto-detectar encoding (BOM sniffing): utf-8 / utf-8-sig / utf-16 / utf-32.
2. Sampling inteligente: tomar las primeras 80 líneas que parezcan credenciales
   (con separadores típicos, alfanumérico >50%) — skipea banners ASCII art.
3. La IA recibe 50 líneas + system prompt con familias comunes de formato y
   propone {separator, fields, skip_lines}.
4. Aplicamos el schema a la muestra SIN filtros → list of tuples.
5. Validamos con _is_clean_credential → score = % rows válidas.
6. Si score ≥ 0.8 y ≥ 5 rows → aplicar al archivo completo.
7. Si no → mandar al agente la (source_line ↔ extracción mala) en pares,
   más checklist de errores típicos. Goto 3.
8. Hasta 7 iteraciones. Si no converge a 0.8: fallback al mejor schema si
   alcanzó ≥ 0.7. Bajo eso → skip con warning (nunca ingerimos basura).

_is_clean_credential — Querschnittsvalidierung:

• Benutzername: Länge 1-64, ohne / : \ Leerzeichen, beginnt nicht mit http/android/ftp//.
• Passwort: Länge 1-256, ohne /, maximal ein :, kein Leerzeichen, beginnt nicht mit URL-Präfix.

Determinismus: temperature=0 bei allen Aufrufen + In-Memory-Caching innerhalb eines Laufs. Dieselbe Datei erzeugt das gleiche Schema zwischen Läufen → import_leaks ist idempotent.

Typische Kosten: 1-3 API-Aufrufe pro Datei, ~$0.0001-$0.0005 mit gpt-4o-mini. Für 12 Dateien: ~$0.005 = ein halber Cent.

Administrative Web-App

Die Web-App ermöglicht:

• Dashboard mit Statistiken, wichtigen Erkenntnissen und Schnellaktionen
• Mitarbeiterverwaltung mit einklappbaren Abschnitten nach Abteilung und Drag & Drop
• Connected Accounts: Profile in sozialen Netzwerken anzeigen, nach E-Mail (Holehe) und nach Benutzername (Maigret) suchen
• Discovery: Domains verwalten, Subdomain-Enumeration durchführen, Ergebnisse mit IP und Quelle anzeigen
• Triage von Anmeldedaten und Geheimnissen (als verifiziert, funktioniert nicht, falsch positiv markieren)
• Bearbeiten von E-Mails und Benutzernamen pro Mitarbeiter (hinzufügen, ändern, löschen)
• KI-Klassifizierung über die Oberfläche

Plugins

LinkedIn

Ermöglicht die Suche nach Mitarbeitern eines Unternehmens auf LinkedIn mit Browser-Sitzungscookies und die Generierung potenzieller Firmen-E-Mails. Erfasst automatisch das Firmenlogo.

Optionen:

Verfügbare Befehle innerhalb des Plugins:

Verfügbare E-Mail-Formate:

• Standard: f_last (z.B. [email protected]) und f.last (z.B. [email protected])
• Benutzerdefiniert mit --email-format: verwendet Platzhalter {n} (Anfangsbuchstabe Vorname), {s} (Nachname), {name} (vollständiger Name), {l} (Anfangsbuchstabe Nachname)
  • Beispiel: --email-format {n}.{s} erzeugt [email protected]

Vollständiges Beispiel:``` emploleaks> add_company --name miempresa emploleaks> select_company --name miempresa emploleaks(miempresa)> use --plugin linkedin emploleaks(miempresa)(linkedin)> setopt JSESSIONID JSESSIONID: emploleaks(miempresa)(linkedin)> setopt li-at li-at: emploleaks(miempresa)(linkedin)> run impersonate emploleaks(miempresa)(linkedin)> run find miempresa miempresa.com --email-format {n}.{s}

### GitHub

Ermöglicht das Abrufen von Informationen aus GitHub-Profilen, das Auflisten von Repositorys und das Scannen von Geheimnissen in Repositorys mit gitleaks.

**Optionen:**

| Option | Beschreibung |
|--------|-------------|
| `token` | Persönlicher GitHub-Zugriffstoken |
| `blur` | Token bei der Anzeige verschleiern |
| `gitleaks_path` | Pfad zur gitleaks-Binärdatei (Standard: `gitleaks` im PATH) |
| `max_repo_size` | Maximale Repository-Größe in MB (Standard: `15`) |

**Im Plugin verfügbare Befehle:**

| Befehl | Beschreibung |
|---------|-------------|
| `run stalk <username>` | E-Mail eines GitHub-Kontos abrufen |
| `run get_repos <username>` | Öffentliche Repositorys eines Benutzers auflisten |
| `run find_secrets` | Geheimnisse in Repositorys von Mitarbeitern des Unternehmens scannen |
| `run find_secrets --download-all` | Gleiche Funktion, aber ohne Größenbeschränkung |

**Vollständiges Beispiel:**```
emploleaks(miempresa)> use --plugin github
emploleaks(miempresa)(github)> setopt token ghp_xxxxxxxxxxxx
emploleaks(miempresa)(github)> run find_secrets
emploleaks(miempresa)(github)> print --data secrets

HaveIBeenPwned (HIBP)

Überprüft, ob die E-Mails des Unternehmens in bekannten Datenlecks auftauchen, unter Verwendung der HIBP-API.

Optionen:

Verfügbare Befehle innerhalb des Plugins:

Vollständiges Beispiel:``` emploleaks(miempresa)> use --plugin hibp emploleaks(miempresa)(hibp)> setopt apikey <tu_api_key> emploleaks(miempresa)(hibp)> find_breaches emploleaks(miempresa)(hibp)> print --data breaches

---

## Datenbank für Leaks (ClickHouse)

EmploLeaks kann sich mit einer eigenen ClickHouse-Datenbank verbinden, die geleakte Anmeldedaten enthält, um nach Passwörtern zu suchen, die mit den entdeckten E-Mails/Benutzernamen der Mitarbeiter verknüpft sind.

### ClickHouse mit Docker starten```bash
cd clickhouse-docker
docker compose up -d

Esto expone ClickHouse en:

• Puerto 9000 (protocolo nativo TCP)
• Puerto 8123 (interfaz HTTP)

La carpeta leaks_data/ se monta como volumen de solo lectura dentro del contenedor.

Importar credenciales

1. Colocá tus archivos de leaks (.txt, .csv, .dat, .zip, .gz) en la carpeta leaks_data/.
2. Ejecutá el comando de importación:``` emploleaks> import_leaks

Der Parser erkennt automatisch die gängigsten Formate:
- `email:password`
- `email:password:url`
- `email;password`
- `email|password`
- `url,email,password`

Für unbekannte Formate wird die konfigurierte KI (OpenAI/Ollama) verwendet, um eine Stichprobe der Datei zu analysieren und zu bestimmen, wie sie zu parsen ist. Verwende `--no-ai`, um die KI-Erkennung zu überspringen.

`.zip`- und `.gz`-Dateien werden vor dem Parsen automatisch entpackt.

### Anmeldedaten suchen```
emploleaks(miempresa)> find_passwords only_emails
emploleaks(miempresa)> find_passwords find_all
emploleaks(miempresa)> print --data passwords

Wenn ClickHouse in tokens.ini konfiguriert ist, erfolgt die Verbindung automatisch beim Start des Tools.

Struktur der Tabelle credentials in ClickHouse

Struktur der lokalen Datenbank (SQLite)

Typischer Workflow```

1. python emploleaks.py

Gestión de empresa

2. add_company --name target_corp
3. select_company --name target_corp

Scraping de LinkedIn (captura empleados + logo de empresa)

4. use --plugin linkedin
5. setopt JSESSIONID
6. setopt li-at
7. run impersonate
8. run find target_corp targetcorp.com --email-format {n}.{s}
9. print --data emails

Discovery de infraestructura

10. add_domain targetcorp.com
11. discover
12. print --data subdomains

Credenciales filtradas (ClickHouse se conecta automáticamente desde config)

13. find_passwords only_emails

Brechas conocidas

14. use --plugin hibp
15. setopt apikey <hibp_key>
16. find_breaches

Secretos en repositorios

17. use --plugin github
18. setopt token <github_token>
19. run find_secrets

Profiling en redes sociales (por email)

20. deactivate
21. lookup_emails

Profiling en redes sociales (por username, requiere cargar usernames en webapp)

22. lookup_profiles

Clasificación por departamento

23. classify

Reportes y exportación

24. print --data all --export
25. print --data all --html --ai

Webapp para triage interactivo

26. python emploleaks.py --webapp

Telegram scraper (proceso aparte, en otra terminal)

27. python3.13 telegram_sync.py login # one-time
28. python3.13 telegram_sync.py list_groups
29. python3.13 telegram_sync.py approve <chat_id> --limit 5
30. python3.13 telegram_sync.py run --watch # daemon en watch

Archivos van a leaks_data/telegram/... → re-ejecutar import_leaks los absorbe.

## Haftungsausschluss

Dieses Werkzeug ist ausschließlich für Bildungszwecke, Sicherheitsforschung und autorisierte Pentesting-Tests konzipiert. Die Verwendung dieses Werkzeugs für böswillige oder nicht autorisierte Aktivitäten ist strengstens untersagt. Die Benutzer sind dafür verantwortlich, alle Gesetze und Nutzungsbedingungen des Projekts einzuhalten.