EmploLeaks

EmploLeaks é uma ferramenta de OSINT (Open Source Intelligence) com uma interface CLI, projetada para descobrir e correlacionar informações sobre funcionários de uma empresa alvo. Permite coletar perfis do LinkedIn, gerar e-mails corporativos potenciais, buscar credenciais vazadas em bases de dados de leaks (ClickHouse internamente), verificar brechas conhecidas através do HaveIBeenPwned, descobrir infraestrutura da empresa e perfilhar funcionários em redes sociais. Toda a informação é armazenada localmente em SQLite para análise posterior.

Características

• Busca e enumeração de funcionários a partir do LinkedIn (scraping com cookies de sessão)
• Geração automática de e-mails corporativos potenciais com formatos personalizáveis
• Busca de credenciais vazadas em base de dados ClickHouse própria
• Verificação de brechas conhecidas com a API do HaveIBeenPwned
• Escaneamento de segredos em repositórios GitHub/GitLab com gitleaks
• Descoberta de infraestrutura: enumeração de subdomínios com assetfinder + SecurityTrails
• Perfilhamento em redes sociais: busca por e-mail (Holehe, ~120 plataformas) e por username (Maigret, 500+ plataformas)
• Telegram scraper (userbot): daemon standalone que se junta a canais aprovados do Telegram e baixa arquivos de credenciais automaticamente
• Parser de leaks 100% agêntico: sem regex hardcoded. Um agente IA propõe schema, valida com score sobre a amostra, recebe feedback com exemplos de erros, e tenta novamente até convergir. Auto-detecta UTF-16/UTF-8, banners ASCII art, country code prefixes, stealer logs (Redline/Lumma/Raccoon), formatos email/user/url arbitrários
• Armazenamento local de toda a informação em SQLite
• Geração de relatórios HTML interativos com fotos de perfil
• Classificação automática de funcionários por departamento usando IA (OpenAI, Ollama, etc.)
• Exportação de resultados para CSV
• Sistema modular de plugins (LinkedIn, GitHub, HIBP)
• Autossalvamento e carregamento automático de configuração de plugins
• Webapp administrativa com FastAPI + Next.js para triagem de resultados

Estrutura do Projeto```

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

## Requisitos

- Python 3.10+
- pip
- Conexão à Internet
- **Opcional:** Docker e Docker Compose (para executar o ClickHouse localmente)
- **Opcional:** [gitleaks](https://github.com/gitleaks/gitleaks) (para escaneamento de segredos em repositórios)
- **Opcional:** chave de API do [HaveIBeenPwned](https://haveibeenpwned.com/API/Key)
- Cookies de sessão do LinkedIn (`JSESSIONID` e `li_at`) para o plugin do LinkedIn

## Instalação

1. Clonar o repositório:```bash
git clone https://github.com/yourusername/emploleaks.git
cd emploleaks

2. Instalar dependências:```bash pip install -r requirements.txt

3. (Opcional) Iniciar o ClickHouse com Docker para o banco de dados de vazamentos:```bash
cd clickhouse-docker
docker compose up -d
cd ..

Uso

Executar a ferramenta:```bash python emploleaks.py

Com modo debug:```bash
python emploleaks.py -d

Comandos Gerais

Gestão de Empresas

Gestão de Plugins

Conexão ao Banco de Dados de Leaks (ClickHouse)

A conexão ao ClickHouse é configurada em config/tokens.ini:```ini [clickhouse] host = localhost port = 9000 user = default passwd = dbname = credentials_db

Se o ClickHouse estiver configurado em `tokens.ini`, a conexão é estabelecida automaticamente ao iniciar.

### Busca de Credenciais e Brechas

| Comando | Descrição |
|---------|-------------|
| `find_passwords <modo>` | Busca credenciais no ClickHouse + [ProxyNova COMB](https://www.proxynova.com/tools/comb/) (3.2B credenciais). Modos: `find_all`, `only_usernames`, `only_emails` |
| `find_passwords <modo> --no-proxynova` | Apenas busca no ClickHouse local |
| `find_passwords <modo> --no-clickhouse` | Apenas busca no ProxyNova COMB (não requer ClickHouse) |
| `find_passwords <modo> --email <email>` | Busca credenciais para um e-mail específico |
| `find_breaches` | Busca brechas no HIBP para todos os e-mails da empresa (requer plugin `hibp` ativo) |

**ProxyNova COMB** é uma base de dados pública com 3.2 bilhões de credenciais vazadas (Combination Of Many Breaches). Não requer chave de API e é consultada automaticamente a cada busca. Use `--no-proxynova` para desativá-la.

### Descoberta de Infraestrutura

| Comando | Descrição |
|---------|-------------|
| `add_domain <dominio>` | Associa um domínio à empresa selecionada (ex: `add_domain faradaysec.com`) |
| `discover` | Executa enumeração de subdomínios contra todos os domínios da empresa usando `assetfinder` (+ SecurityTrails opcional), resolvendo DNS |
| `print --data domains` | Mostra os domínios registrados e a quantidade de subdomínios encontrados |
| `print --data subdomains` | Mostra todos os subdomínios com seu IP, fonte e data de descoberta |

O módulo de Descoberta delega a enumeração passiva ao [`assetfinder`](https://github.com/tomnomnom/assetfinder), que internamente agrega resultados de crt.sh, HackerTarget, BufferOver e outras fontes sem chave de API. O binário deve estar no `$PATH` (instalação: `go install github.com/tomnomnom/assetfinder@latest`).

Opcionalmente, se você configurar uma chave de API do SecurityTrails, seus subdomínios são mesclados com os do assetfinder:```ini
[discovery]
# securitytrails_key = your_key_here

Perfilamento em Redes Sociais

Holehe (email lookup): utiliza a técnica de "forgot password" para determinar se um e-mail está registrado em cada plataforma, sem alertar o proprietário. As plataformas são configuradas em tokens.ini:```ini [holehe] platforms = google, discord, github, instagram, twitter, spotify, ...

**Maigret** (username lookup): procura se um username existe em 500+ plataformas de redes sociais. Os usernames são adicionados manualmente por funcionário a partir da webapp. As plataformas são opcionalmente filtradas em `tokens.ini`:```ini
[maigret]
# platforms = instagram, twitter, facebook, tiktok, reddit, github

Visualização e Exportação

Configuração de IA e Classificação

A classificação por IA analisa os títulos/funções dos funcionários e os agrupa por departamento (Engineering, Security, Sales, etc.). Os departamentos são persistidos no SQLite e ficam visíveis no relatório HTML e na webapp.

Provedores suportados (qualquer API compatível com OpenAI):

• Ollama (local, padrão): set_ai --endpoint http://localhost:11434/v1 --model llama3
• OpenAI: set_ai --endpoint https://api.openai.com/v1 --key sk-... --model gpt-4o-mini
• Qualquer outro compatível: LM Studio, Together AI, etc.

Telegram Scraper (Userbot)

Daemon standalone que usa uma conta pessoal do Telegram (via Telethon) para entrar em canais/grupos aprovados, baixar arquivos .txt/.csv/.dat/.zip/.gz e deixá-los em leaks_data/telegram/<chat>/. O import_leaks posterior os ingere no ClickHouse usando o parser agentivo. Decoupled do CLI — roda como processo separado, podendo ficar 24/7 sem a CLI estar aberta.

Setup inicial (one-time):

1. Criar app em https://my.telegram.org/apps para obter api_id e api_hash.
2. Adicionar ao 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 interativo (pede seu número, código por aplicativo, opcionalmente 2FA): ```bash python3.13 telegram_sync.py login
   root@kitploit:~

Subcomandos:

Tabelas novas em data/emploleaks.db:

Daemon em segundo plano:```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 Leaks 100% Agêntico

O módulo `utils/leak_parser.py` usa **exclusivamente um agente de IA** para processar cada arquivo. Não há regex hardcoded (elas foram eliminadas porque cada novo formato introduzia bugs sutis de extração).

**Pipeline do 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 — validação transversal:

• Username: comprimento 1-64, sem / : \ space, não começa com http/android/ftp//.
• Password: comprimento 1-256, sem /, máximo um :, sem whitespace, não começa com prefixo de URL.

Determinismo: temperature=0 em todas as chamadas + caching em memória dentro de uma mesma execução. O mesmo arquivo produz o mesmo schema entre execuções → import_leaks é idempotente.

Custo típico: 1-3 chamadas à API por arquivo, ~$0.0001-$0.0005 com gpt-4o-mini. Para 12 arquivos: ~$0.005 = meio centavo.

Webapp Administrativa

A webapp permite:

• Dashboard com estatísticas, descobertas principais e ações rápidas
• Gestão de funcionários com seções colapsáveis por departamento e drag & drop
• Connected Accounts: visualizar perfis em redes sociais, buscar por email (Holehe) e por username (Maigret)
• Discovery: gerenciar domínios, executar enumeração de subdomínios, ver resultados com IP e origem
• Triagem de credenciais e segredos (marcar como verificado, não funciona, falso positivo)
• Edição de emails e usernames por funcionário (adicionar, modificar, excluir)
• Classificação com IA a partir da interface

Plugins

LinkedIn

Permite buscar funcionários de uma empresa no LinkedIn usando cookies de sessão do navegador, e gerar e-mails corporativos potenciais. Captura automaticamente o logotipo da empresa.

Opções:

Comandos disponíveis dentro do plugin:

Formatos de e-mail disponíveis:

• Padrão: f_last (ex: [email protected]) e f.last (ex: [email protected])
• Personalizado com --email-format: usa placeholders {n} (inicial nome), {s} (sobrenome), {name} (nome completo), {l} (inicial sobrenome)
  • Exemplo: --email-format {n}.{s} gera [email protected]

Exemplo 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

Permite obter informações de perfis do GitHub, listar repositórios e escanear segredos em repositórios com gitleaks.

**Opções:**

| Opção | Descrição |
|--------|-------------|
| `token` | Token de acesso pessoal do GitHub |
| `blur` | Ofuscar o token ao exibi-lo |
| `gitleaks_path` | Caminho para o binário do gitleaks (padrão: `gitleaks` no PATH) |
| `max_repo_size` | Tamanho máximo do repo para analisar em MB (padrão: `15`) |

**Comandos disponíveis dentro do plugin:**

| Comando | Descrição |
|---------|-------------|
| `run stalk <username>` | Obter email de uma conta GitHub |
| `run get_repos <username>` | Listar repositórios públicos de um usuário |
| `run find_secrets` | Escanear segredos em repositórios de funcionários da empresa |
| `run find_secrets --download-all` | Igual, mas sem limite de tamanho |

**Exemplo 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 os emails da empresa aparecem em brechas conhecidas usando a API do HIBP.

Opções:

Comandos disponíveis dentro do plugin:

Exemplo 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

---

## Base de Dados de Vazamentos (ClickHouse)

EmploLeaks pode conectar-se a um banco de dados ClickHouse próprio com credenciais vazadas para buscar senhas associadas aos e-mails/nomes de usuário dos funcionários descobertos.

### Iniciar ClickHouse com Docker```bash
cd clickhouse-docker
docker compose up -d

Isso expõe o ClickHouse em:

• Porta 9000 (protocolo nativo TCP)
• Porta 8123 (interface HTTP)

A pasta leaks_data/ é montada como volume somente leitura dentro do contêiner.

Importar credenciais

1. Coloque seus arquivos de vazamentos (.txt, .csv, .dat, .zip, .gz) na pasta leaks_data/.
2. Execute o comando de importação:``` emploleaks> import_leaks

O parser detecta automaticamente os formatos mais comuns:
- `email:password`
- `email:password:url`
- `email;password`
- `email|password`
- `url,email,password`

Para formatos desconhecidos, utiliza a IA configurada (OpenAI/Ollama) para analisar uma amostra do arquivo e determinar como analisá-lo. Use `--no-ai` para omitir a detecção com IA.

Arquivos `.zip` e `.gz` são descompactados automaticamente antes da análise.

### Buscar credenciais```
emploleaks(miempresa)> find_passwords only_emails
emploleaks(miempresa)> find_passwords find_all
emploleaks(miempresa)> print --data passwords

Se o ClickHouse estiver configurado no tokens.ini, a conexão é automática ao iniciar a ferramenta.

Estrutura da tabela credentials no ClickHouse

Estrutura do Banco de Dados Local (SQLite)

Fluxo de Trabalho Típico```

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.

## Aviso Legal

Esta ferramenta foi projetada exclusivamente para fins educacionais, de pesquisa em segurança e testes de pentest autorizados. O uso desta ferramenta para atividades maliciosas ou não autorizadas é estritamente proibido. Os usuários são responsáveis por cumprir todas as leis e termos de serviço do projeto.