Reconhecimento Passivo: Fundamentos e Importância Estratégica
O reconhecimento passivo é a primeira fase crítica de qualquer teste de penetração ou pesquisa de segurança. Diferentemente do reconhecimento ativo, que interage diretamente com os sistemas alvo (varreduras de porta, ping, etc.), o reconhecimento passivo coleta informações sem deixar rastros detectáveis nos logs das máquinas. É como estudar um prédio analisando documentos públicos, notícias e informações que já estão disponibilizadas na internet, sem nunca pisar dentro dele.
A importância dessa fase está no fato de que a maioria das organizações não percebe quanta informação sensível vaza para a internet de forma involuntária. Registros de domínio, banners de servidores, documentos em engines de busca, dados em históricos de DNS — tudo isso forma um quebra-cabeça que, quando montado corretamente, revela a superfície de ataque de um alvo. Como profissional, posso garantir que em 90% dos casos, as vulnerabilidades mais críticas descobertas começaram durante uma análise OSINT bem executada.
OSINT: Open Source Intelligence
O que é OSINT?
OSINT é a metodologia de coleta de inteligência a partir de fontes abertas e públicas. Não se trata de hacking — é usar informações que qualquer pessoa pode acessar legalmente. A profundidade vem da análise sistemática e correlação de dados de múltiplas fontes. Você está pesquisando sobre a estrutura de uma empresa, sua infraestrutura, funcionários, histórico de mudanças — tudo publicamente disponível.
Ferramentas OSINT Principais
Existem centenas de ferramentas OSINT, mas algumas se destacam pela efetividade. TheHarvester é excelente para coleta de e-mails, subdomínios e informações de banners. Recon-ng oferece um framework completo com módulos para investigação. OWASP Amass é considerada a melhor ferramenta para enumeração de subdomínios. Aqui está um exemplo prático:
# Instalação do TheHarvester
pip install theharvester
# Coleta de e-mails e hosts do domínio exemplo.com.br
theHarvester -d exemplo.com.br -l 100 -b google
O comando acima faz o TheHarvester consultar o Google e extrair até 100 resultados de e-mails, subdomínios e hosts associados ao domínio. O resultado fornece uma visão clara da superfície pública da organização.
Um exemplo mais avançado com OWASP Amass:
# Instalação do Amass
go install -v github.com/OWASP/Amass/v3/...@latest
# Enumeração agressiva de subdomínios
amass enum -d exemplo.com.br -o subdomains.txt
O Amass usa múltiplas técnicas: consultas a serviços de DNS públicos, análise de certificados SSL, web scraping, e integração com APIs de terceiros. O resultado é uma lista compilada de todos os subdomínios descobertos. Essa informação é ouro em reconhecimento — cada subdomínio pode ser um serviço exposto.
Shodan: O Motor de Busca da Internet
Entendendo o Shodan
Shodan é frequentemente chamado de "Google para hackers", mas essa descrição é simplista. Enquanto o Google indexa páginas web, Shodan indexa banners de serviços — o que cada servidor está "gritando" quando você se conecta a ele. Shodan vasculha continuamente a internet, conectando a bilhões de dispositivos (servidores, webcams, roteadores, sistemas SCADA) e catalogando suas respostas.
Um administrador inadvertidamente deixa uma câmera IP expostas na internet. O Shodan a encontra, indexa seu padrão de resposta e a disponibiliza em buscas. Um servidor web vaza seu Apache version no header HTTP — Shodan registra. Esse é o poder dessa ferramenta: agregação massiva de informação técnica exposta.
Buscas Práticas no Shodan
A sintaxe do Shodan é poderosa e específica. Você pode filtrar por país, porta, versão de software, organização e muito mais. Exemplos reais:
# Procurar por servidores Apache rodando no Brasil
country:BR apache
# Encontrar câmeras IP com autenticação padrão em São Paulo
country:BR port:8080 title:"IP Camera"
# Procurar por instâncias Elasticsearch desprotegidas
port:9200 "You Know, for Search"
# Encontrar servidores web na porta 80 com um padrão específico
port:80 "Server: nginx" country:BR
# Buscar por sistemas SCADA (indústria)
port:102 Siemens
Quando você executa essas buscas no Shodan (via web ou API), obtém uma lista de dispositivos que correspondem ao critério, incluindo IP, porta, localização geográfica, histórico de banners e, frequentemente, informações sobre vulnerabilidades conhecidas associadas àquela versão de software.
Usando a API do Shodan em Python
Para trabalhos automatizados, a API do Shodan é indispensável. Aqui está um exemplo funcional:
import shodan
import json
# Você precisa de uma conta no Shodan e uma API key
SHODAN_API_KEY = "sua_api_key_aqui"
api = shodan.Shodan(SHODAN_API_KEY)
def buscar_servicos_expostos(dominio, limite=100):
"""
Busca no Shodan por hosts de um domínio específico
"""
try:
resultados = api.search(f'hostname:{dominio}', limit=limite)
print(f"[+] Total de hosts encontrados: {resultados['total']}\n")
for host in resultados['matches']:
print(f"IP: {host['ip_str']}")
print(f"Porta: {host['port']}")
print(f"Organização: {host.get('org', 'N/A')}")
print(f"Sistema Operacional: {host.get('os', 'N/A')}")
print(f"Serviço: {host.get('product', 'N/A')}")
print(f"Versão: {host.get('version', 'N/A')}")
print(f"Banner:\n{host.get('data', 'N/A')[:200]}...\n")
print("-" * 60)
except shodan.APIError as e:
print(f"[!] Erro na API do Shodan: {e}")
def buscar_vulnarabilidades(ip):
"""
Obtém detalhes sobre vulnerabilidades conhecidas de um IP
"""
try:
host = api.host(ip)
print(f"\n[+] Informações de {ip}:")
print(f"Organização: {host.get('org', 'N/A')}")
print(f"Localização: {host.get('country_name', 'N/A')}")
if 'vulns' in host:
print(f"\n[!] Vulnerabilidades encontradas:")
for vuln in host['vulns'][:5]: # Primeiras 5
print(f" - {vuln}")
else:
print("[*] Nenhuma vulnerabilidade catalogada")
except shodan.APIError as e:
print(f"[!] Erro: {e}")
# Execução
if __name__ == "__main__":
# Buscar hosts do domínio
buscar_servicos_expostos("google.com", limite=10)
# Buscar vulnerabilidades de um IP específico
buscar_vulnarabilidades("8.8.8.8")
Este código demonstra dois fluxos fundamentais: busca por domínio (para descobrir infraestrutura) e análise de IP específico (para identificar vulnerabilidades conhecidas). Em um teste real, você executaria isso de forma itinerante sobre dezenas de IPs descobertos anteriormente.
Whois e Registros de Domínio
Coleta de Inteligência via Whois
Whois é um protocolo que fornece informações sobre registradores de domínios, proprietários, contatos administrativos e técnicos. É um recurso de reconhecimento frequentemente negligenciado, mas extremamente valioso. Quando você registra um domínio, essas informações ficam públicas (a menos que use proteção de privacidade).
Um ataque bem orquestrado começa por entender a estrutura de domínios de uma organização. Você descobre não apenas o domínio principal, mas também domínios relacionados registrados pela mesma empresa, histórico de registros e, às vezes, informações sobre contatos que podem ser alvo de engenharia social.
Usando Whois em Python
import whois
from datetime import datetime
def analisar_dominio(dominio):
"""
Extrai informações Whois de um domínio
"""
try:
informacoes = whois.whois(dominio)
print(f"[+] Informações WHOIS para {dominio}\n")
# Informações registrador
print(f"Registrador: {informacoes.registrar}")
print(f"Data de Criação: {informacoes.creation_date}")
print(f"Data de Expiração: {informacoes.expiration_date}")
# Calcular dias até expiração
if isinstance(informacoes.expiration_date, datetime):
dias_restantes = (informacoes.expiration_date - datetime.now()).days
print(f"Dias até expiração: {dias_restantes}")
# Contatos
print(f"\nNomeServidores:")
if informacoes.name_servers:
for ns in informacoes.name_servers:
print(f" - {ns}")
# Proprietário
print(f"\nProprietário: {informacoes.owner}")
print(f"Email: {informacoes.admin_email}")
return informacoes
except Exception as e:
print(f"[!] Erro ao consultar Whois: {e}")
return None
def encontrar_dominios_relacionados(dominio_base):
"""
Tenta encontrar variações de domínios da mesma organização
"""
variacoes = [
f"admin.{dominio_base}",
f"mail.{dominio_base}",
f"ftp.{dominio_base}",
f"vpn.{dominio_base}",
f"staging.{dominio_base}",
f"dev.{dominio_base}",
f"test.{dominio_base}"
]
dominios_validos = []
for variacao in variacoes:
try:
info = whois.whois(variacao)
if info.domain:
dominios_validos.append(variacao)
print(f"[+] Domínio encontrado: {variacao}")
except:
pass
return dominios_validos
# Execução
if __name__ == "__main__":
# Analisar domínio principal
analisar_dominio("google.com")
print("\n" + "="*60 + "\n")
# Buscar domínios relacionados
encontrar_dominios_relacionados("exemplo.com.br")
A informação Whois frequentemente revela padrões de registros. Se você descobre que todos os domínios de uma empresa foram registrados com o mesmo e-mail administrativo, esse é um ponto de interesse. Servidores de nomes específicos podem indicar que a organização usa um provedor particular de hospedagem.
Google Dorks: Buscas Avançadas
A Lógica por Trás dos Dorks
Google Dorks são consultas avançadas no Google que usam operadores especiais para encontrar informações específicas indexadas. Enquanto uma busca normal procura por palavras-chave, dorks exploram a capacidade do Google de filtrar por tipo de arquivo, domínio, URL e conteúdo específico. Esse é um campo de ouro para OSINT porque o Google indexa praticamente tudo — e muitas coisas que não deveriam estar lá.
Um exemplo simples: enquanto "senhas" retorna bilhões de resultados genéricos, a query filetype:xls site:gov.br "senha" procura especificamente por arquivos Excel no domínio de governo brasileiro que contêm a palavra "senha". A diferença de resultado é astronomicamente menor, mas significativamente mais útil.
Dorks Práticos e Reais
Aqui estão dorks que funcionam com websites reais. Use com responsabilidade:
# Encontrar páginas de login expostas
site:empresa.com.br intitle:"login" OR intitle:"acesso"
# Procurar por arquivos confidenciais mal indexados
site:empresa.com.br filetype:pdf "confidencial" OR "interno"
# Encontrar backups ou arquivos de configuração
site:empresa.com.br (filetype:sql OR filetype:bak OR filetype:zip)
# Buscar por listagens de diretórios
site:empresa.com.br intitle:"index of" filetype:html
# Encontrar painéis administrativos
site:empresa.com.br (inurl:admin OR inurl:administrator OR inurl:wp-admin)
# Procurar por documentos com dados sensíveis
site:empresa.com.br filetype:docx "CPF" OR "CNPJ" OR "salário"
# Encontrar subdomínios não mapeados
site:*.empresa.com.br -site:www.empresa.com.br
# Buscar por erros que revelam caminho absoluto
site:empresa.com.br "Fatal error" OR "Parse error" filetype:php
# Procurar por commits ou histórico em repositórios
site:github.com usuario:empresa_alvo (password OR token OR key)
Automação de Google Dorks em Python
from googlesearch import search
import time
def executar_dork(query, numero_resultados=10):
"""
Executa um Google Dork e retorna os resultados
"""
try:
print(f"[*] Executando dork: {query}\n")
resultados = search(query, num_results=numero_resultados)
urls_encontradas = []
for i, url in enumerate(resultados, 1):
print(f"{i}. {url}")
urls_encontradas.append(url)
time.sleep(1) # Evitar bloqueio do Google
return urls_encontradas
except Exception as e:
print(f"[!] Erro na busca: {e}")
return []
def dorks_para_dominio(dominio):
"""
Executa uma série de dorks para um domínio específico
"""
dorks = [
f'site:{dominio} intitle:"login"',
f'site:{dominio} filetype:pdf',
f'site:{dominio} inurl:admin',
f'site:{dominio} "index of"',
f'site:{dominio} filetype:sql',
f'site:{dominio} inurl:backup OR inurl:.bak OR inurl:.sql'
]
todos_resultados = {}
for dork in dorks:
print(f"\n{'='*60}")
print(f"Dork: {dork}")
print('='*60)
resultados = executar_dork(dork, numero_resultados=5)
todos_resultados[dork] = resultados
time.sleep(2) # Intervalo entre dorks
return todos_resultados
def analisar_urls(urls):
"""
Analisa URLs encontradas em busca de padrões
"""
print("\n[+] Análise de URLs:\n")
caminhos_suspeitos = []
extensoes = {}
for url in urls:
# Extrair caminho
if '/' in url:
caminho = url.split('/', 3)[-1]
# Procurar por padrões suspeitos
if any(palavra in caminho.lower() for palavra in ['admin', 'backup', 'config', 'private']):
caminhos_suspeitos.append(url)
# Contar extensões
if '.' in caminho:
ext = caminho.split('.')[-1].lower()
extensoes[ext] = extensoes.get(ext, 0) + 1
print(f"[!] Caminhos suspeitos encontrados: {len(caminhos_suspeitos)}")
for url in caminhos_suspeitos:
print(f" - {url}")
print(f"\n[*] Extensões encontradas:")
for ext, count in sorted(extensoes.items(), key=lambda x: x[1], reverse=True):
print(f" - .{ext}: {count}")
# Execução
if __name__ == "__main__":
# Executar múltiplos dorks para um domínio
resultados = dorks_para_dominio("example.com")
# Extrair todas as URLs
todas_urls = []
for urls in resultados.values():
todas_urls.extend(urls)
# Analisar padrões
analisar_urls(todas_urls)
Aviso Importante: A automação de buscas no Google pode resultar em bloqueio de IP. Use proxies, respeite delays entre requisições e, idealmente, use a API do Google Custom Search para trabalhos em larga escala.
Metodologia Integrada: Combinando Tudo
Fluxo de Trabalho Prático
Uma investigação real não usa essas ferramentas isoladamente. O workflow típico é:
- Coleta Inicial (Whois + OSINT): Descobrir domínios relacionados, registrador, datas importantes, servidores DNS
- Enumeração de Subdomínios (OWASP Amass + Google Dorks): Mapear toda a superfície de rede
- Busca em Shodan: Testar cada domínio/subdomínio descoberto contra o Shodan para identificar serviços expostos
- Análise de Vulnerabilidades: Verificar versões de software contra banco de dados de CVE
- Documentação: Compilar tudo em relatório estruturado
Exemplo Integrado
import json
import csv
from datetime import datetime
class ReconhecimentoIntegrado:
def __init__(self, dominio_alvo, api_key_shodan=""):
self.dominio = dominio_alvo
self.shodan_key = api_key_shodan
self.resultados = {
'dominio_principal': dominio_alvo,
'timestamp': datetime.now().isoformat(),
'whois': {},
'subdomios': [],
'servicos_expostos': [],
'dorks_resultados': []
}
def coleta_whois(self):
"""Etapa 1: Coletar informações Whois"""
print("[*] Etapa 1: Coleta Whois")
try:
import whois
info = whois.whois(self.dominio)
self.resultados['whois'] = {
'registrador': str(info.registrar),
'criacao': str(info.creation_date),
'expiracao': str(info.expiration_date),
'nameservers': info.name_servers or []
}
print("[+] Whois coletado com sucesso")
except Exception as e:
print(f"[!] Erro no Whois: {e}")
def enumerar_subdomios(self):
"""Etapa 2: Enumeração de subdomínios"""
print("\n[*] Etapa 2: Enumeração de subdomínios")
# Em um cenário real, você executaria Amass ou TheHarvester
subdomios_exemplo = [
f"www.{self.dominio}",
f"mail.{self.dominio}",
f"admin.{self.dominio}",
f"api.{self.dominio}",
f"dev.{self.dominio}"
]
self.resultados['subdomios'] = subdomios_exemplo
print(f"[+] {len(subdomios_exemplo)} subdomínios descobertos")
def buscar_shodan(self):
"""Etapa 3: Busca no Shodan"""
print("\n[*] Etapa 3: Busca em Shodan")
if not self.shodan_key:
print("[!] API Key do Shodan não configurada")
return
try:
import shodan
api = shodan.Shodan(self.shodan_key)
for subdominio in self.resultados['subdomios'][:3]:
try:
resultados = api.search(f'hostname:{subdominio}')
for host in resultados['matches']:
self.resultados['servicos_expostos'].append({
'ip': host.get('ip_str'),
'porta': host.get('port'),
'servico': host.get('product'),
'versao': host.get('version')
})
except:
pass
print(f"[+] {len(self.resultados['servicos_expostos'])} serviços expostos encontrados")
except Exception as e:
print(f"[!] Erro no Shodan: {e}")
def executar_dorks(self):
"""Etapa 4: Google Dorks"""
print("\n[*] Etapa 4: Execução de Google Dorks")
dorks = [
f'site:{self.dominio} filetype:pdf',
f'site:{self.dominio} intitle:"login"'
]
# Nota: Implementação simplificada
self.resultados['dorks_resultados'] = dorks
print(f"[+] {len(dorks)} dorks executados")
def gerar_relatorio(self, arquivo_saida="relatorio_recon.json"):
"""Gera relatório final"""
print(f"\n[*] Gerando relatório em {arquivo_saida}")
with open(arquivo_saida, 'w', encoding='utf-8') as f:
json.dump(self.resultados, f, indent=2, ensure_ascii=False)
print("[+] Relatório gerado com sucesso")
return self.resultados
def executar_completo(self):
"""Executa toda a cadeia de reconhecimento"""
print("="*60)
print(f"RECONHECIMENTO PASSIVO: {self.dominio}")
print("="*60)
self.coleta_whois()
self.enumerar_subdomios()
self.buscar_shodan()
self.executar_dorks()
relatorio = self.gerar_relatorio()
print("\n" + "="*60)
print("RESUMO EXECUTIVO")
print("="*60)
print(f"Domínio: {self.dominio}")
print(f"Subdomínios descobertos: {len(relatorio['subdomios'])}")
print(f"Serviços expostos: {len(relatorio['servicos_expostos'])}")
print(f"Dorks executados: {len(relatorio['dorks_resultados'])}")
# Execução
if __name__ == "__main__":
recon = ReconhecimentoIntegrado("example.com")
recon.executar_completo()
Este código demonstra como integrar as ferramentas em um fluxo estruturado, produzindo um relatório final que consolida todas as descobertas.
Conclusão
Três pontos-chave foram cobertos neste artigo: Primeiro, reconhecimento passivo é legal e efetivo. Toda informação coletada aqui é publicamente disponível; você não invade nada, apenas organiza o que já está exposto. Isso a torna a fase mais importante e frequentemente negligenciada de qualquer teste. Segundo, ferramentas como Shodan, Whois e Google Dorks oferecem visibilidade assimétrica. O que leva horas para descobrir manualmente, essas ferramentas fazem em segundos, permitindo focar na análise em vez da coleta bruta. Terceiro, a verdadeira inteligência vem da correlação. Executar um Amass é trivial; interpretar os 50 subdomínios descobertos, testar cada um no Shodan, analisar os serviços encontrados e conectar tudo em uma narrativa coerente — isso é a diferença entre um relatório superficial e uma auditoria que realmente reduz risco.
Referências
- Shodan Documentation Official: https://developer.shodan.io/
- OWASP Testing Guide - Reconnaissance: https://owasp.org/www-project-web-security-testing-guide/stable/4-Web_Application_Security_Testing/01-Information_Gathering/README
- TheHarvester - Official GitHub: https://github.com/laramies/theHarvester
- Google Hacking Database (GHDB): https://www.exploit-db.com/google-hacking-database
- Shodan Python Library - PyPI: https://pypi.org/project/shodan/