EmploLeaks

EmploLeaks est un outil OSINT (Open Source Intelligence) avec une interface CLI, conçu pour découvrir et corréler des informations sur les employés d'une entreprise cible. Il permet de collecter des profils LinkedIn, générer des adresses e-mail professionnelles potentielles, rechercher des identifiants divulgués dans des bases de données de fuites (ClickHouse en interne), vérifier les violations connues via HaveIBeenPwned, découvrir l'infrastructure de l'entreprise et profiler les employés sur les réseaux sociaux. Toutes les informations sont stockées localement dans SQLite pour une analyse ultérieure.

Caractéristiques

• Recherche et énumération des employés depuis LinkedIn (scraping avec cookies de session)
• Génération automatique d'adresses e-mail professionnelles potentielles avec formats personnalisables
• Recherche d'identifiants divulgués dans une base de données ClickHouse personnelle
• Vérification des violations connues via l'API HaveIBeenPwned
• Analyse des secrets dans les dépôts GitHub/GitLab avec gitleaks
• Découverte d'infrastructure : énumération des sous-domaines avec assetfinder + SecurityTrails
• Profilage sur les réseaux sociaux : recherche par e-mail (Holehe, ~120 plateformes) et par nom d'utilisateur (Maigret, 500+ plateformes)
• Scraper Telegram (userbot) : démon autonome qui rejoint les canaux Telegram approuvés et télécharge automatiquement des fichiers d'identifiants
• Analyseur de fuites 100% agentique : sans expressions régulières codées en dur. Un agent IA propose un schéma, valide avec un score sur l'échantillon, reçoit des retours avec des exemples d'erreurs, et réessaie jusqu'à convergence. Auto-détecte UTF-16/UTF-8, bannières ASCII art, préfixes de codes de pays, stealer logs (Redline/Lumma/Raccoon), formats e-mail/utilisateur/URL arbitraires
• Stockage local de toutes les informations dans SQLite
• Génération de rapports HTML interactifs avec photos de profil
• Classification automatique des employés par département à l'aide de l'IA (OpenAI, Ollama, etc.)
• Exportation des résultats en CSV
• Système modulaire de plugins (LinkedIn, GitHub, HIBP)
• Sauvegarde et chargement automatiques de la configuration des plugins
• Application web administrative avec FastAPI + Next.js pour le tri des résultats

Structure du projet```

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

## Prérequis

- Python 3.10+
- pip
- Connexion Internet
- **Optionnel :** Docker et Docker Compose (pour lancer ClickHouse localement)
- **Optionnel :** [gitleaks](https://github.com/gitleaks/gitleaks) (pour le scan de secrets dans les dépôts)
- **Optionnel :** clé API de [HaveIBeenPwned](https://haveibeenpwned.com/API/Key)
- Cookies de session LinkedIn (`JSESSIONID` et `li_at`) pour le plugin LinkedIn

## Installation

1. Cloner le dépôt :```bash
git clone https://github.com/yourusername/emploleaks.git
cd emploleaks

2. Installer les dépendances:```bash pip install -r requirements.txt

3. (Optionnel) Lancer ClickHouse avec Docker pour la base de données de fuites :```bash
cd clickhouse-docker
docker compose up -d
cd ..

Utilisation

Exécuter l'outil :```bash python emploleaks.py

Avec le mode debug :```bash
python emploleaks.py -d

Commandes Générales

Gestion des Entreprises

Gestion des Plugins

Connexion à la Base de Données de Leaks (ClickHouse)

La connexion à ClickHouse se configure dans config/tokens.ini :```ini [clickhouse] host = localhost port = 9000 user = default passwd = dbname = credentials_db

Si ClickHouse est configuré dans `tokens.ini`, la connexion s'établit automatiquement au démarrage.

### Recherche d'Identifiants et de Violations de Données

| Commande | Description |
|---------|-------------|
| `find_passwords <modo>` | Recherche des identifiants dans ClickHouse + [ProxyNova COMB](https://www.proxynova.com/tools/comb/) (3,2 milliards d'identifiants). Modes : `find_all`, `only_usernames`, `only_emails` |
| `find_passwords <modo> --no-proxynova` | Recherche uniquement dans ClickHouse local |
| `find_passwords <modo> --no-clickhouse` | Recherche uniquement dans ProxyNova COMB (ne nécessite pas ClickHouse) |
| `find_passwords <modo> --email <email>` | Recherche des identifiants pour un email spécifique |
| `find_breaches` | Recherche les violations de données dans HIBP pour tous les emails de l'entreprise (nécessite le plugin `hibp` actif) |

**ProxyNova COMB** est une base de données publique contenant 3,2 milliards d'identifiants divulgués (Combination Of Many Breaches). Elle ne nécessite pas de clé API et est interrogée automatiquement à chaque recherche. Utilisez `--no-proxynova` pour la désactiver.

### Découverte d'Infrastructure

| Commande | Description |
|---------|-------------|
| `add_domain <dominio>` | Associe un domaine à l'entreprise sélectionnée (ex : `add_domain faradaysec.com`) |
| `discover` | Exécute l'énumération des sous-domaines pour tous les domaines de l'entreprise à l'aide de `assetfinder` (+ SecurityTrails optionnel), avec résolution DNS |
| `print --data domains` | Affiche les domaines enregistrés et le nombre de sous-domaines trouvés |
| `print --data subdomains` | Affiche tous les sous-domaines avec leur IP, leur source et la date de découverte |

Le module de découverte délègue l'énumération passive à [`assetfinder`](https://github.com/tomnomnom/assetfinder), qui agrège en interne les résultats de crt.sh, HackerTarget, BufferOver et d'autres sources sans clé API. Le binaire doit être dans `$PATH` (installation : `go install github.com/tomnomnom/assetfinder@latest`).

Optionnellement, si vous configurez une clé API SecurityTrails, ses sous-domaines sont fusionnés avec ceux d'assetfinder :```ini
[discovery]
# securitytrails_key = your_key_here

Profilage sur les réseaux sociaux

Holehe (recherche d'e-mail) : utilise la technique du 'mot de passe oublié' pour déterminer si un e-mail est enregistré sur chaque plateforme, sans alerter le propriétaire. Les plateformes sont configurées dans tokens.ini :```ini [holehe] platforms = google, discord, github, instagram, twitter, spotify, ...

**Maigret** (recherche de nom d'utilisateur) : cherche si un nom d'utilisateur existe sur plus de 500 plateformes de réseaux sociaux. Les noms d'utilisateur sont ajoutés manuellement par un employé depuis l'application web. Les plateformes sont optionnellement filtrées dans `tokens.ini`:```ini
[maigret]
# platforms = instagram, twitter, facebook, tiktok, reddit, github

Visualisation et exportation

Configuration de l'IA et classification

La classification par IA analyse les titres/rôles des employés et les regroupe par département (Engineering, Security, Sales, etc.). Les départements sont persistés dans SQLite et visibles dans le rapport HTML et dans l'application web.

Fournisseurs pris en charge (toute API compatible OpenAI) :

• Ollama (local, par défaut) : set_ai --endpoint http://localhost:11434/v1 --model llama3
• OpenAI : set_ai --endpoint https://api.openai.com/v1 --key sk-... --model gpt-4o-mini
• Tout autre compatible : LM Studio, Together AI, etc.

Telegram Scraper (Userbot)

Daemon autonome qui utilise un compte Telegram personnel (via Telethon) pour rejoindre des canaux/groupes approuvés, télécharger des fichiers .txt/.csv/.dat/.zip/.gz et les déposer dans leaks_data/telegram/<chat>/. Le import_leaks ultérieur les ingère dans ClickHouse en utilisant le parser agentique. Découplé du CLI — il s'exécute comme un processus séparé, il peut donc fonctionner 24h/24 sans que le CLI soit ouvert.

Configuration initiale (one-time) :

1. Créer une application sur https://my.telegram.org/apps pour obtenir api_id et api_hash.
2. Ajouter dans config/tokens.ini : ```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. Connexion interactive (vous demande votre numéro, code par application, éventuellement 2FA) : ```bash python3.13 telegram_sync.py login
   root@kitploit:~

Sous-commandes :

Nouvelles tables dans data/emploleaks.db :

Démon en arrière-plan :```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)

### Parser de Fuites 100% Agentique

Le module `utils/leak_parser.py` utilise **uniquement un agent d'IA** pour parser chaque fichier. Il n'y a pas de regex codées en dur (elles ont été supprimées car chaque nouveau format introduisait des bugs subtils d'extraction).

**Pipeline de l'agent:**```
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 — validation transversale :

• Username : longueur 1-64, sans / : \ espace, ne commence pas par http/android/ftp//.
• Password : longueur 1-256, sans /, maximum un :, sans espace, ne commence pas par préfixe URL.

Déterminisme : temperature=0 dans tous les appels + mise en cache en mémoire dans un même run. Le même fichier produit le même schéma entre les runs → import_leaks est idempotent.

Coût typique : 1-3 appels API par fichier, ~$0.0001-$0.0005 avec gpt-4o-mini. Pour 12 fichiers : ~$0.005 = un demi-centime.

Application Web d'Administration

L'application web permet :

• Tableau de bord avec statistiques, découvertes clés et actions rapides
• Gestion des employés avec sections repliables par département et glisser-déposer
• Connected Accounts : visualiser les profils sur les réseaux sociaux, rechercher par email (Holehe) et par nom d'utilisateur (Maigret)
• Discovery : gérer les domaines, exécuter l'énumération des sous-domaines, voir les résultats avec IP et source
• Tri des identifiants et secrets (marquer comme vérifié, ne fonctionne pas, faux positif)
• Édition des emails et noms d'utilisateur par employé (ajouter, modifier, supprimer)
• Classification avec IA depuis l'interface

Plugins

LinkedIn

Permet de rechercher des employés d'une entreprise sur LinkedIn en utilisant les cookies de session du navigateur, et de générer des emails professionnels potentiels. Capture automatiquement le logo de l'entreprise.

Options :

Commandes disponibles dans le plugin :

Formats d'email disponibles :

• Par défaut : f_last (ex : [email protected]) et f.last (ex : [email protected])
• Personnalisé avec --email-format : utilise des espaces réservés {n} (initiale du prénom), {s} (nom de famille), {name} (nom complet), {l} (initiale du nom)
  • Exemple : --email-format {n}.{s} génère [email protected]

Exemple complet :``` 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

Permet d'obtenir des informations sur les profils GitHub, de lister les dépôts et de scanner les secrets dans les dépôts avec gitleaks.

**Options :**

| Option | Description |
|--------|-------------|
| `token` | Jeton d'accès personnel GitHub |
| `blur` | Offusquer le jeton lors de l'affichage |
| `gitleaks_path` | Chemin vers le binaire gitleaks (par défaut : `gitleaks` dans PATH) |
| `max_repo_size` | Taille maximale du dépôt à analyser en Mo (par défaut : `15`) |

**Commandes disponibles dans le plugin :**

| Commande | Description |
|---------|-------------|
| `run stalk <username>` | Obtenir l'email d'un compte GitHub |
| `run get_repos <username>` | Lister les dépôts publics d'un utilisateur |
| `run find_secrets` | Scanner les secrets dans les dépôts des employés de l'entreprise |
| `run find_secrets --download-all` | Identique mais sans limite de taille |

**Exemple complet :**```
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)

Vérifie si les e-mails de l'entreprise apparaissent dans des fuites connues en utilisant l'API de HIBP.

Options :

Commandes disponibles dans le plugin :

Exemple complet :``` emploleaks(miempresa)> use --plugin hibp emploleaks(miempresa)(hibp)> setopt apikey <tu_api_key> emploleaks(miempresa)(hibp)> find_breaches emploleaks(miempresa)(hibp)> print --data breaches

## Base de données de fuites (ClickHouse)

EmploLeaks peut se connecter à sa propre base de données ClickHouse contenant des identifiants divulgués pour rechercher des mots de passe associés aux e-mails/noms d'utilisateur des employés découverts.

### Lancer ClickHouse avec Docker```bash
cd clickhouse-docker
docker compose up -d

Cela expose ClickHouse sur :

• Port 9000 (protocole natif TCP)
• Port 8123 (interface HTTP)

Le dossier leaks_data/ est monté en tant que volume en lecture seule dans le conteneur.

Importer les identifiants

1. Placez vos fichiers de fuites (.txt, .csv, .dat, .zip, .gz) dans le dossier leaks_data/.
2. Exécutez la commande d'importation :``` emploleaks> import_leaks

Le parser détecte automatiquement les formats les plus courants :
- `email:password`
- `email:password:url`
- `email;password`
- `email|password`
- `url,email,password`

Pour les formats inconnus, utilise l'IA configurée (OpenAI/Ollama) pour analyser un échantillon du fichier et déterminer comment le parser. Utilisez `--no-ai` pour omettre la détection par IA.

Les fichiers `.zip` et `.gz` sont décompressés automatiquement avant d'être parsés.

### Rechercher des identifiants```
emploleaks(miempresa)> find_passwords only_emails
emploleaks(miempresa)> find_passwords find_all
emploleaks(miempresa)> print --data passwords

Si ClickHouse est configuré dans tokens.ini, la connexion est automatique au démarrage de l'outil.

Structure de la table credentials dans ClickHouse

Structure de la Base de Données Locale (SQLite)

Flux de Travail Typique```

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.

## Disclaimer

Cet outil est conçu uniquement à des fins éducatives, de recherche en sécurité et de tests de pentesting autorisés. L'utilisation de cet outil pour des activités malveillantes ou non autorisées est strictement interdite. Les utilisateurs sont responsables du respect de toutes les lois et conditions de service du projet.