EmploLeaks

EmploLeaks è uno strumento di OSINT (Open Source Intelligence) con un'interfaccia CLI , progettato per scoprire e correlare informazioni sui dipendenti di un'azienda target. Permette di raccogliere profili LinkedIn, generare email aziendali potenziali, cercare credenziali filtrate in database di leak (ClickHouse internamente), verificare violazioni note tramite HaveIBeenPwned, scoprire l'infrastruttura dell'azienda e profilare i dipendenti sui social network. Tutte le informazioni vengono archiviate localmente in SQLite per analisi successive.

Caratteristiche

• Ricerca ed enumerazione dei dipendenti da LinkedIn (scraping con cookie di sessione)
• Generazione automatica di email aziendali potenziali con formati personalizzabili
• Ricerca di credenziali filtrate nel database ClickHouse proprietario
• Verifica di violazioni note con l'API di HaveIBeenPwned
• Scansione di segreti nei repository GitHub/GitLab con gitleaks
• Discovery dell'infrastruttura: enumerazione di sottodomini con assetfinder + SecurityTrails
• Profilazione sui social network: ricerca per email (Holehe, ~120 piattaforme) e per username (Maigret, 500+ piattaforme)
• Telegram scraper (userbot): demone standalone che si unisce a canali Telegram approvati e scarica automaticamente file di credenziali
• Parser di leak 100% agnostico: senza regex hardcodate. Un agente AI propone uno schema, valida con punteggio sul campione, riceve feedback con esempi di errori e riprova fino a convergere. Rileva automaticamente UTF-16/UTF-8, banner ASCII art, prefissi di codici paese, log di stealer (Redline/Lumma/Raccoon), formati arbitrari email/user/url
• Archiviazione locale di tutte le informazioni in SQLite
• Generazione di report HTML interattivi con foto del profilo
• Classificazione automatica dei dipendenti per reparto utilizzando AI (OpenAI, Ollama, ecc.)
• Esportazione dei risultati in CSV
• Sistema modulare di plugin (LinkedIn, GitHub, HIBP)
• Salvataggio automatico e caricamento automatico della configurazione dei plugin
• Webapp amministrativa con FastAPI + Next.js per triage dei risultati

Struttura del Progetto```

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

## Requisiti

- Python 3.10+
- pip
- Connessione a Internet
- **Opzionale:** Docker e Docker Compose (per avviare ClickHouse localmente)
- **Opzionale:** [gitleaks](https://github.com/gitleaks/gitleaks) (per scansione di segreti nei repository)
- **Opzionale:** Chiave API di [HaveIBeenPwned](https://haveibeenpwned.com/API/Key)
- Cookie di sessione di LinkedIn (`JSESSIONID` e `li_at`) per il plugin di LinkedIn

## Installazione

1. Clonare il repository:```bash
git clone https://github.com/yourusername/emploleaks.git
cd emploleaks

2. Installare le dipendenze:```bash pip install -r requirements.txt

3. (Opzionale) Avviare ClickHouse con Docker per il database delle fughe di dati:```bash
cd clickhouse-docker
docker compose up -d
cd ..

Uso

Eseguire lo strumento:```bash python emploleaks.py

Con modalità debug:```bash
python emploleaks.py -d

Comandi Generali

Gestione Aziende

Gestione Plugin

Connessione al Database di Leak (ClickHouse)

La connessione a ClickHouse viene configurata in config/tokens.ini:```ini [clickhouse] host = localhost port = 9000 user = default passwd = dbname = credentials_db

Se ClickHouse è configurato in `tokens.ini`, la connessione viene stabilita automaticamente all'avvio.

### Ricerca di Credenziali e Violazioni

| Comando | Descrizione |
|---------|-------------|
| `find_passwords <modo>` | Cerca credenziali in ClickHouse + [ProxyNova COMB](https://www.proxynova.com/tools/comb/) (3.2B credenziali). Modi: `find_all`, `only_usernames`, `only_emails` |
| `find_passwords <modo> --no-proxynova` | Cerca solo nel ClickHouse locale |
| `find_passwords <modo> --no-clickhouse` | Cerca solo in ProxyNova COMB (non richiede ClickHouse) |
| `find_passwords <modo> --email <email>` | Cerca credenziali per un'email specifica |
| `find_breaches` | Cerca violazioni in HIBP per tutte le email dell'azienda (richiede plugin `hibp` attivo) |

**ProxyNova COMB** è un database pubblico con 3.2 miliardi di credenziali violate (Combination Of Many Breaches). Non richiede API key e viene consultato automaticamente ad ogni ricerca. Usa `--no-proxynova` per disattivarlo.

### Discovery dell'Infrastruttura

| Comando | Descrizione |
|---------|-------------|
| `add_domain <dominio>` | Associa un dominio all'azienda selezionata (es: `add_domain faradaysec.com`) |
| `discover` | Esegue enumerazione dei sottodomini contro tutti i domini dell'azienda usando `assetfinder` (+ SecurityTrails opzionale), risolvendo DNS |
| `print --data domains` | Mostra i domini registrati e il numero di sottodomini trovati |
| `print --data subdomains` | Mostra tutti i sottodomini con il loro IP, fonte e data di scoperta |

Il modulo di Discovery delega l'enumerazione passiva a [`assetfinder`](https://github.com/tomnomnom/assetfinder), che internamente aggrega risultati da crt.sh, HackerTarget, BufferOver e altre fonti senza API key. Ci si aspetta il binario in `$PATH` (installazione: `go install github.com/tomnomnom/assetfinder@latest`).

Opzionalmente, se configuri una API key di SecurityTrails, i suoi sottodomini vengono uniti a quelli di assetfinder:```ini
[discovery]
# securitytrails_key = your_key_here

Profilazione sui Social Network

Holehe (email lookup): utilizza la tecnica 'forgot password' per determinare se un email è registrato su ogni piattaforma, senza allertare il proprietario. Le piattaforme sono configurate in tokens.ini:```ini [holehe] platforms = google, discord, github, instagram, twitter, spotify, ...

**Maigret** (username lookup): cerca se un username esiste su 500+ piattaforme di social media. Gli username vengono aggiunti manualmente da un dipendente tramite la webapp. Le piattaforme sono opzionalmente filtrate in `tokens.ini`:```ini
[maigret]
# platforms = instagram, twitter, facebook, tiktok, reddit, github

Visualizzazione e Esportazione

Configurazione IA e Classificazione

La classificazione tramite IA analizza i titoli/ruoli degli impiegati e li raggruppa per reparto (Engineering, Security, Sales, ecc.). I reparti vengono memorizzati su SQLite e sono visibili nel report HTML e nella webapp.

Provider supportati (qualsiasi API compatibile con OpenAI):

• Ollama (locale, di default): set_ai --endpoint http://localhost:11434/v1 --model llama3
• OpenAI: set_ai --endpoint https://api.openai.com/v1 --key sk-... --model gpt-4o-mini
• Qualsiasi altro compatibile: LM Studio, Together AI, ecc.

Telegram Scraper (Userbot)

Daemon standalone che utilizza un account personale di Telegram (via Telethon) per unirsi a canali/gruppi approvati, scaricare file .txt/.csv/.dat/.zip/.gz e lasciarli in leaks_data/telegram/<chat>/. Il successivo import import_leaks li ingerisce in ClickHouse usando il parser agentico. Disaccoppiato dal CLI — viene eseguito come processo separato, quindi può rimanere attivo 24/7 senza che il CLI sia aperto.

Setup iniziale (one-time):

1. Creare un'app su https://my.telegram.org/apps per ottenere api_id e api_hash.
2. Aggiungere al file 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. Login interattivo (ti chiede il tuo numero, codice via app, opzionalmente 2FA): ```bash python3.13 telegram_sync.py login
   root@kitploit:~

Sottocomandi:

Nuove tabelle in data/emploleaks.db:

Daemon in background:```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 di Leak 100% Agéntico

Il modulo `utils/leak_parser.py` utilizza **solo un agente di IA** per analizzare ogni file. Non ci sono regex hardcoded (sono state rimosse perché ogni nuovo formato introduceva bug sottili di estrazione).

**Pipeline dell'agente:**```
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 — validazione trasversale:

• Username: lunghezza 1-64, senza / : \ spazio, non inizia con http/android/ftp//.
• Password: lunghezza 1-256, senza /, massimo un :, senza spazi bianchi, non inizia con prefisso URL.

Determinismo: temperature=0 in tutte le chiamate + caching in memoria all'interno dello stesso run. Lo stesso file produce lo stesso schema tra run → import_leaks è idempotente.

Costo tipico: 1-3 chiamate all'API per file, ~$0.0001-$0.0005 con gpt-4o-mini. Per 12 file: ~$0.005 = mezzo centesimo.

Webapp Amministrativa

La webapp permette:

• Dashboard con statistiche, risultati chiave e azioni rapide
• Gestione dipendenti con sezioni collassabili per reparto e drag & drop
• Connected Accounts: visualizzare profili sui social network, cercare per email (Holehe) e per username (Maigret)
• Discovery: gestire domini, eseguire enumerazione di sottodomini, vedere risultati con IP e fonte
• Triage di credenziali e segreti (marcare come verificato, non funzionante, falso positivo)
• Modifica di email e username per dipendente (aggiungere, modificare, eliminare)
• Classificazione con IA dall'interfaccia

Plugins

LinkedIn

Permette di cercare dipendenti di un'azienda su LinkedIn utilizzando cookie di sessione del browser, e generare email aziendali potenziali. Cattura automaticamente il logo dell'azienda.

Opzioni:

Comandi disponibili all'interno del plugin:

Formati email disponibili:

• Predefinito: f_last (es: [email protected]) e f.last (es: [email protected])
• Personalizzato con --email-format: usa placeholder {n} (iniziale nome), {s} (cognome), {name} (nome completo), {l} (iniziale cognome)
  • Esempio: --email-format {n}.{s} genera [email protected]

Esempio completo:``` 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

Permette di ottenere informazioni dai profili GitHub, elencare repository e scansionare segreti nei repository con gitleaks.

**Opzioni:**

| Opzione | Descrizione |
|---------|-------------|
| `token` | Token di accesso personale di GitHub |
| `blur` | Offuscare il token quando visualizzato |
| `gitleaks_path` | Percorso al binario di gitleaks (default: `gitleaks` in PATH) |
| `max_repo_size` | Dimensione massima del repo da analizzare in MB (default: `15`) |

**Comandi disponibili all'interno del plugin:**

| Comando | Descrizione |
|---------|-------------|
| `run stalk <username>` | Ottenere email di un account GitHub |
| `run get_repos <username>` | Elencare repository pubblici di un utente |
| `run find_secrets` | Scansionare segreti nei repo dei dipendenti dell'azienda |
| `run find_secrets --download-all` | Uguale ma senza limite di dimensione |

**Esempio completo:**```
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)

Verifica se le email dell'azienda appaiono in breach noti utilizzando l'API di HIBP.

Opzioni:

Comandi disponibili all'interno del plugin:

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

---

## Database di Leaks (ClickHouse)

EmploLeaks può connettersi a un database ClickHouse proprio con credenziali trapelate per cercare password associate agli email/username dei dipendenti scoperti.

### Avviare ClickHouse con Docker```bash
cd clickhouse-docker
docker compose up -d

Espone ClickHouse su:

• Porta 9000 (protocollo nativo TCP)
• Porta 8123 (interfaccia HTTP)

La cartella leaks_data/ viene montata come volume di sola lettura all'interno del contenitore.

Importare le credenziali

1. Inserisci i tuoi file di leak (.txt, .csv, .dat, .zip, .gz) nella cartella leaks_data/.
2. Esegui il comando di importazione:``` emploleaks> import_leaks

Il parser rileva automaticamente i formati più comuni:
- `email:password`
- `email:password:url`
- `email;password`
- `email|password`
- `url,email,password`

Per formati sconosciuti, utilizza l'IA configurata (OpenAI/Ollama) per analizzare un campione del file e determinare come analizzarlo. Usa `--no-ai` per omettere il rilevamento con IA.

I file `.zip` e `.gz` vengono decompressi automaticamente prima dell'analisi.

### Cerca credenziali```
emploleaks(miempresa)> find_passwords only_emails
emploleaks(miempresa)> find_passwords find_all
emploleaks(miempresa)> print --data passwords

Si ClickHouse è configurato in tokens.ini, la connessione è automatica all'avvio dello strumento.

Struttura della tabella credentials in ClickHouse

Struttura del Database Locale (SQLite)

Flusso di Lavoro Tipico```

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

Questo strumento è progettato esclusivamente per scopi educativi, di ricerca sulla sicurezza e test di pentesting autorizzati. L'uso di questo strumento per attività maliziose o non autorizzate è strettamente proibito. Gli utenti sono responsabili del rispetto di tutte le leggi e dei termini di servizio del progetto.