PRISM — Plataforma de Inteligência de Código Aberto

junho 21, 2026

PRISM — Plataforma de Inteligência de Código Aberto

Plataforma OSINT auto-hospedada com mais de 22 módulos, pontuação OPSEC, resumo de IA e painel web em tempo real.

Analise qualquer domínio, IP, e-mail, telefone ou nome de usuário — obtenha WHOIS, DNS, informações sobre ameaças, dados de violações de segurança, pesquisa de nome de usuário, servidores espelho na dark web, pontuação de OPSEC, gráficos de entidades e relatórios em HTML/PDF em segundos.

Demonstração ao vivo · Início rápido do Docker · Arquitetura · Segurança · Changelog · Perguntas frequentes

Se você achar o PRISM útil, considere dar uma ⭐ — isso ajuda outras pessoas a descobrirem o projeto e motiva o seu desenvolvimento futuro.

Índice

Por que PRISM? • Visão geral • Por que PRISM em vez de alternativas? • Casos de uso • Recursos • Demonstração • Início rápido • Configuração • API • Estrutura do projeto • Executando testes • CI/CD • Roteiro • Histórico de estrelas • Aviso legal • Apoie o projeto • Contribuindo • Licença

Por que PRISM?

Mais de 22 módulos — WHOIS, DNS, crt.sh, Wayback Machine, Shodan, VirusTotal, AbuseIPDB, Censys , Dark Web (Ahmia + DarkSearch) , reputação de e-mail, verificação SMTP, pesquisa de violações de segurança, Blackbird (mais de 50 sites), Maigret (mais de 3000 sites), Telegram, HLR de telefone, cabeçalhos de e-mail, metadados de arquivos e muito mais.
Análise com inteligência artificial — resumo executivo automatizado, avaliação de riscos e chat interativo de perguntas e respostas via LLM (OpenRouter / Nvidia Nemotron)
Painel de controle em tempo real — progresso da digitalização baseado em WebSocket com barra de progresso em nível de módulo (5/8 · 62%) , gráfico interativo de relacionamento de entidades, mapa Leaflet GeoIP com múltiplos marcadores
Pontuação OPSEC — pontuação agregada de risco de exposição de 0 a 100, abrangendo exposição de dados, identidade, infraestrutura e segurança da web.
Relatórios em HTML, PDF, CSV e Markdown — exporte os resultados completos da verificação como HTML, PDF, CSV ou Markdown (com reconhecimento de idioma: EN/RU/DE/FR/ES)
Interface multilíngue — inglês, russo, alemão, francês e espanhol integrados (i18n + detecção automática)
CLI independente — execute verificações sem interface gráfica viapython cli.py scan example.com --json
Histórico e comparação de digitalizações — navegue por digitalizações anteriores, carregue resultados e compare duas digitalizações lado a lado.
Webhooks de retorno — receba notificações quando a varredura for concluída com payloads assinados com HMAC (protegidos contra SSRF), formatadores para Slack/Discord.
Autenticação reforçada — chaves de API somente no cabeçalho ( X-API-Key/ Bearer), sem segredos na string de consulta, CORS estrito, isolamento de varredura por principal.
Nenhuma chave de API obrigatória — 14 dos 22 módulos funcionam sem nenhuma chave.
Implantação com um único comando — docker compose up --builde você já está executando.
Totalmente de código aberto — licença MIT, arquitetura de módulos extensível, fácil de contribuir.

Visão geral

O PRISM agrega dados de mais de 20 fontes de inteligência externas para construir um perfil abrangente de qualquer alvo — domínio, endereço IP, e-mail, número de telefone ou nome de usuário em redes sociais. Todos os dados são apresentados em um painel em tempo real com gráficos de relacionamento, um mapa GeoIP, relatórios exportáveis em HTML/PDF e uma pontuação automática de exposição à segurança operacional (OPSEC).

Pilha:

Backend — Python 3.10+, FastAPI, asyncio, WebSocket, Pydantic, slowapi (limitação de taxa), xhtml2pdf (PDF)
Frontend — Next.js 14 (App Router), React, TypeScript, Tailwind CSS, Leaflet (mapas)
IA — OpenRouter (Nvidia Nemotron) ou Groq (Llama-3) para resumo e bate-papo
Infraestrutura — Docker, docker-compose, GitHub Actions CI/CD
Testes — pytest, 123 casos de teste com monkeypatching, simulação de rede, cobertura de SSRF/autenticação

Arquitetura (alto nível)

Por que escolher o PRISM em vez de outras alternativas?

Capacidade	PRISMA	SpiderFoot CE	o ceifador	Recon-ng	Maltego CE
Painel de controle web moderno	✅ Next.js 14	⚠️legado	❌ Somente CLI	❌ Somente CLI	✅ área de trabalho
Progresso da digitalização em tempo real (WS)	✅	❌	❌	❌	❌
Resumo com inteligência artificial + chat	✅ Mestrado em Direito	❌	❌	❌	❌
Pontuação OPSEC (0–100)	✅	❌	❌	❌	❌
Gráfico de entidades (interativo)	✅	✅	❌	❌	✅
Mapa GeoIP (múltiplos marcadores)	✅ Folheto	⚠️básico	❌	❌	⚠️
Exportação de relatório HTML + PDF	✅ EN/RU/DE/FR/ES	⚠️HTML	❌	⚠️	⚠️
Interface de usuário multilíngue	✅ EN/RU/DE/FR/ES	❌	❌	❌	❌
Tecla zero integrada	✅ 14/22 módulos	⚠️	⚠️	⚠️	❌
Retornos de chamada do Webhook (assinados)	✅	❌	❌	❌	❌
Implantação do Docker com um único comando	✅	⚠️	❌	⚠️	❌
Licença MIT	✅	❌ GPLv2	✅	✅ GPLv3	❌

Casos de uso

Reconhecimento de recompensas por bugs — inicie uma única varredura e obtenha subdomínios (crt.sh + Censys), portas abertas (Shodan), caminhos sensíveis do Wayback Machine e descobertas priorizadas por IA.
Investigação de phishing — da identificação de um domínio ou e-mail suspeito à análise de ameaças, exposição a violações de segurança, autenticação de e-mail (SPF/DKIM/DMARC) e registros históricos.
Monitoramento de marca e falsificação — varreduras baseadas em webhooks para detectar novos subdomínios semelhantes, menções na dark web e credenciais expostas.
Treinamento de conscientização em segurança — atribua aos funcionários sua própria pontuação OPSEC em e-mail, telefone e nome de usuário para que eles visualizem a exposição em uma escala de 0 a 100.
OSINT acadêmico/educacional — uma referência auto-hospedada e licenciada pelo MIT para o ensino de reconhecimento passivo, geolocalização e fluxos de trabalho de inteligência de ameaças.

Características

Módulo	Descrição	Chave de API
QUEM É	Registro de domínio, registrador, datas	—
DNS	Registros A, MX, NS, TXT, CNAME e SOA	—
Transparência do Certificado	Descoberta de subdomínios via crt.sh	—
Máquina do Tempo	Instantâneos históricos, padrões de URL sensíveis	—
GeoIP	Geolocalização de IP, ASN, fuso horário	ipinfo.io
Shodan	Portas abertas, serviços, CVEs conhecidos	Shodan
Censys	Serviços de hospedagem, ASN, certificado → descoberta de subdomínio	Censys
VirusTotal	Reputação de domínio/IP, detecção de malware	VirusTotal
AbuseIPDB	pontuação de confiança em abuso de IP	AbuseIPDB
Verificador da Dark Web	Espelhos .onion via Ahmia + DarkSearch	—
Analisador de Sites	Tecnologias utilizadas, e-mails, links para redes sociais, metadados	—
Reputação de e-mail	Representante de e-mail baseado em DNS (MX, SPF, DMARC, verificação descartável)	—
Verificação SMTP	Verificação da existência da caixa de correio via handshake SMTP	—
Verificação de violação	Consulta de vazamento de e-mail/credenciais	Pesquisa de vazamentos
Melro	Presença do nome de usuário em mais de 50 plataformas (assíncrona)	—
Maigret	Busca avançada de nomes de usuário em mais de 3000 sites.	—
Pesquisa no Telegram	Consulta de nome de usuário/ID via API de bot + extração de dados	Telegrama
Telefone / HLR	Validação de número, operadora, país, pesquisa reversa	Verificar números
Cabeçalhos de e-mail	Análise de SPF/DKIM/DMARC, saltos de roteamento, detecção de spoofing	—
Metadados do arquivo	EXIF, coordenadas GPS, propriedades PDF/DOCX	—
Pontuação OPSEC	Pontuação de risco de exposição agregada de 0 a 100	—
Grafo de Entidades	Visualização interativa de relações entre nós	—
Relatório HTML/PDF	Relatório estilizado e independente (HTML + xhtml2pdf), localizado em EN/RU/DE/FR/ES	—
Resumo de IA	Resumo das descobertas em linguagem natural via LLM	OpenRouter / Groq
Retornos de chamada do Webhook	POST assinado por HMAC após a conclusão da verificação (protegido por SSRF)	—

Vitrine

Mais capturas de tela (domínio / IP / e-mail / telefone / nome de usuário / ferramentas independentes)

Início rápido

Experimente em 60 segundos (sem configuração, sem chaves de API)

Execute uma demonstração independente pré-carregada com exemplos de varreduras — sem necessidade de chaves de API ou consultas externas:

git clone https://github.com/NovaCode37/Prism-platform.git
cd Prism-platform
docker compose -f docker-compose.demo.yml up --build

Acesse http://localhost:8080 — a interface do Next.js e o backend FastAPI são servidos pelo mesmo contêiner. Três exemplos de varreduras (um domínio, um IP e um nome de usuário) já estão disponíveis em Varreduras Recentes , mostrando o painel, a pontuação de OPSEC, o gráfico de entidades, o mapa e o relatório em HTML/PDF.

A demonstração é executada anonimamente ( ALLOW_ANON_API=true) em :8080. Para uma configuração autenticada no estilo de produção, use as configurações Docker / Manual abaixo.

Docker (recomendado)

git clone https://github.com/NovaCode37/Prism-platform.git
cd Prism-platform
cp .env.example .env        # local/demo defaults to anonymous access; edit for production keys
docker compose up --build

Abra http://localhost:8080 . O Docker compila a exportação estática do Next.js e a serve a partir do FastAPI juntamente com /api/*, /ws/*, e /healthz.

O exemplo .envfoi projetado para ser fácil de executar ALLOW_ANON_API=truee não requer nenhuma chave de API. Antes de expor o PRISM além da sua máquina, mude para o modo de chave de API, conforme mostrado em Chaves de API e modo anônimo .

Manual

# 1. Backend
git clone https://github.com/NovaCode37/Prism-platform.git
cd Prism-platform
pip install -r requirements.txt
cp .env.example .env
python -m uvicorn web.app:app --host 0.0.0.0 --port 8080 --reload --no-proxy-headers

# 2. Frontend (in a separate terminal, from repo root)
cd frontend
npm install
# create .env.local for the separate dev server:
#   NEXT_PUBLIC_API_URL=http://localhost:8080
#   NEXT_PUBLIC_BASE_PATH=
#   NEXT_PUBLIC_API_KEY=<only when ALLOW_ANON_API=false>
npm run dev

Abra http://localhost:3000 .

Ao executar apenas uvicorna partir do código-fonte, o FastAPI serve as páginas `<head>` /api/*, /ws/*`<body>` e ` /healthz<body>`. A página raiz /precisa de uma exportação Next.js compilada em `<head> frontend/out`; em um checkout novo sem essa compilação, ele retorna `<body>` {"detail":"Frontend build not found"}. Use `<body>` npm run devcomo mostrado acima ou execute `fastAPI` npm run buildantes de servir a interface de usuário no estilo de contêiner único a partir do FastAPI.

Para experimentação local, .env.exampleutilize ALLOW_ANON_API=true. Para qualquer implantação compartilhada ou pública, defina ALLOW_ANON_API=false, configure API_KEYSe forneça à interface do usuário uma chave aceita.

Configuração

O PRISM é configurado por meio de variáveis de ambiente ( .env). As chaves de provedor externo são opcionais — os módulos que precisam de uma chave de provedor ausente são ignorados normalmente.

Chaves de API e modo anônimo

O PRISM possui dois modos de acesso à API. O /healthzendpoint é sempre não autenticado para verificações de integridade de contêineres e proxies reversos; os endpoints de aplicativos sob [ /api/*inserir nomes /ws/*de endpoints aqui] seguem o modo descrito abaixo.

O modo anônimo local/demo destina-se a um laptop, uma máquina virtual de teste privada ou o arquivo de demonstração do Compose. Qualquer pessoa que consiga acessar o servidor HTTP pode iniciar varreduras e usar as ferramentas.

ALLOW_ANON_API=true
API_KEYS=
API_KEY=
PRISM_UI_API_KEY=

O modo de chave de API é o recomendado para implantações compartilhadas, com proxy reverso ou voltadas para a internet. API_KEYSÉ preferível porque suporta múltiplas chaves aceitas; API_KEYé mantido como uma opção legada de chave única. Cada chave aceita é mapeada para sua própria entidade, portanto, o histórico de varredura é isolado por chave.

ALLOW_ANON_API=false
API_KEYS=replace-with-a-long-random-ui-key
API_KEY=
PRISM_UI_API_KEY=replace-with-the-same-long-random-ui-key

Os clientes se autenticam com `<username>` X-API-Key: <key>ou `<username>` Authorization: Bearer <key>. Quando o Docker serve a interface do Next.js a partir do FastAPI, defina PRISM_UI_API_KEYuma chave que também esteja presente em `<username>` API_KEYSpara que o navegador possa chamar a API. Esse valor é injetado na configuração pública do frontend, portanto, trate-o como uma chave de interface visível para o navegador, não como um segredo privado do servidor. Para usuários adicionais ou automação, adicione mais entradas separadas por vírgulas em `<username>` API_KEYS. Se você executar `<username>` npm run devseparadamente, coloque o mesmo tipo de chave de interface frontend/.env.localque em `<username>` NEXT_PUBLIC_API_KEY.

Erros comuns de autenticação:

Erro	Significado	Consertar
`HTTP 503: API auth is not configured on server.`	Não `API_KEYS`/ `API_KEY`foram carregados e `ALLOW_ANON_API`não é `true`.	Configure `ALLOW_ANON_API=true`para o modo anônimo local ou configure `API_KEYS`e reinicie.
`HTTP 401: Invalid or missing API key.`	O servidor tem as chaves configuradas, mas a solicitação não enviou uma chave correspondente.	Defina `PRISM_UI_API_KEY`/ `NEXT_PUBLIC_API_KEY`ou envie `X-API-Key`/ `Authorization: Bearer`.

Após a alteração .envpara o Docker, recrie o contêiner para que o backend e a configuração da interface do usuário em tempo de execução reconheçam os novos valores:

docker compose up -d --force-recreate

Autenticação e rede principais

Variável	Propósito
`API_KEYS`	Chaves de API aceitas, separadas por vírgulas; preferencial para o modo de chave de API.
`API_KEY`	Chave de API única aceita; opção legada
`ALLOW_ANON_API`	`true`Permitir acesso à API sem autenticação; somente local/demo
`PRISM_DEMO_MODE`	`true`Exibir o aviso de demonstração pública na interface do usuário.
`ALLOWED_ORIGINS`	Origens CORS separadas por vírgula; vazio/não definido = sem origem cruzada
`PRISM_BASE_PATH`	Prefixo do caminho da API pública/WS quando montado em um subdiretório, por exemplo`/prism`
`PRISM_UI_API_KEY`	Chave de interface do usuário do navegador público injetada na interface do usuário servida pelo Docker
`PRISM_FRONTEND_DIR`	Caminho opcional para exportação estática do Next.js (padrão `frontend/out`)
`NEXT_PUBLIC_API_URL`	Origem da API externa opcional para configurações de compilação/tempo de execução do frontend.
`NEXT_PUBLIC_BASE_PATH`	Prefixo de recurso de tempo de compilação do Next.js para implantações de subdiretório
`TRUST_PROXY_HEADERS`	`true`confiar nos cabeçalhos encaminhados dos proxies reversos configurados
`FORWARDED_ALLOW_IPS`	Endereços IP de proxy separados por vírgula podem definir `X-Forwarded-*`cabeçalhos.
`TRUSTED_HOSTS`	Valores opcionais separados por vírgula permitidos `Host`para o backend
`HEALTHCHECK_HOST`	Substituição opcional do cabeçalho Host para verificações de integridade do Docker.
`MAX_UPLOAD_MB`	Tamanho máximo de upload para ferramentas baseadas em arquivos (padrão `20`)
`MAX_STORED_SCANS`	Limite de varredura na memória antes do modo somente disco (padrão `200`)
`CACHE_TTL_HOURS`	Tempo de vida (TTL) do cache por módulo (padrão `24`)
`WEBHOOK_SECRET`	Se configurado, assina os retornos de chamada do webhook com`X-Prism-Secret`
`DISABLE_DOCS`	`true`para desativar `/docs`, `/redoc`, `/openapi.json`em produção

Proxy reverso

A topologia Docker suportada é um único contêiner: o FastAPI serve a interface do usuário Next.js exportada, além de /api/*, /ws/*, e /healthzna mesma origem pública. Mantenha NEXT_PUBLIC_API_URLvazio para implantações na mesma origem. Para implantações em subdiretório, defina PRISM_BASE_PATHem tempo de execução e crie a imagem com o mesmo NEXT_PUBLIC_BASE_PATH.

Implantação raiz ( https://prism.example.com):

PRISM_BASE_PATH=
TRUST_PROXY_HEADERS=true
FORWARDED_ALLOW_IPS=172.18.0.1
TRUSTED_HOSTS=prism.example.com
NEXT_PUBLIC_API_URL=
NEXT_PUBLIC_BASE_PATH=

Implantação de subcaminho ( https://example.com/prism), com a remoção do proxy /prismantes do encaminhamento para o backend:

PRISM_BASE_PATH=/prism
TRUST_PROXY_HEADERS=true
FORWARDED_ALLOW_IPS=172.18.0.1
TRUSTED_HOSTS=example.com
NEXT_PUBLIC_API_URL=
NEXT_PUBLIC_BASE_PATH=/prism

Após a alteração NEXT_PUBLIC_BASE_PATH, reconstrua a imagem, pois os caminhos dos recursos do Next.js são fixos no momento da compilação:

NEXT_PUBLIC_BASE_PATH=/prism docker compose build
docker compose up

Proxy nginx mínimo para um único contêiner:

location / {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

location /api/ {
    proxy_pass http://127.0.0.1:8080/api/;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

location /ws/ {
    proxy_pass http://127.0.0.1:8080/ws/;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

Para /prism, proxy /prism/, /prism/api/, e /prism/ws/para o contêiner, removendo o prefixo. O painel HTML legado do FastAPI foi removido.

Exemplo de Caddy minimalista:

prism.example.com {
    reverse_proxy 127.0.0.1:8080
}

Chaves de provedor externo

Variável	Serviço	Nível gratuito
`NUMVERIFY_API_KEY`	Validação do telefone e operadora	100 requisições/mês
`IPINFO_API_KEY`	Localização GeoIP	Salário mínimo de 50 mil por mês.
`VIRUSTOTAL_API_KEY`	Inteligência de ameaças	500 requisições/dia
`ABUSEIPDB_API_KEY`	pontuação de abuso de IP	1000 requisições/dia
`SHODAN_API_KEY`	Varredura de portas + pesquisa de CVE	Nível gratuito
`CENSYS_API_ID`+`CENSYS_API_SECRET`	Busca de host e certificado	250 requisições/mês
`OPENROUTER_API_KEY`	Resumo de IA (Nvidia Nemotron)	Nível gratuito
`GROQ_API_KEY`	Recurso de IA (instantâneo Llama-3)	Nível gratuito
`TELEGRAM_BOT_TOKEN`	Pesquisa de usuários do Telegram	Livre
`LEAK_LOOKUP_API_KEY`	Banco de dados de violações	Gratuito limitado

Variáveis

Variável	O que isso possibilita	Obrigatório?	Onde conseguir
`API_KEYS`	Chaves de API preferenciais, separadas por vírgulas, aceitas para o modo de chave de API.	Somente modo de autenticação	Gere longas sequências aleatórias
`API_KEY`	Chave de API única legada aceita para o modo de chave de API	Somente modo de autenticação	Gere uma longa sequência aleatória.
`ALLOW_ANON_API`	Permite solicitações de API locais/de demonstração não autenticadas sem uma chave.	Não	`true`Para uso local/de demonstração, `false`para produção
`PRISM_DEMO_MODE`	Exibe o aviso de demonstração pública na interface do usuário.	Não	`true`Apenas para a configuração de composição de demonstração.
`NUMVERIFY_API_KEY`	Valida números de telefone	Não	Painel de controle Numverify
`LEAK_LOOKUP_API_KEY`	Busca em violações de dados por credenciais vazadas	Não	Painel da API LeakLookup
`HIBP_API_KEY`	Verifica se os e-mails/senhas foram comprometidos.	Não	Portal do desenvolvedor HIBP
`IPINFO_API_KEY`	Obtém informações de geolocalização e ASN para endereços IP.	Não	Painel de controle do IPInfo.io
`VIRUSTOTAL_API_KEY`	Analisa hashes de arquivos e URLs em busca de malware.	Não	Painel da API do VirusTotal
`ABUSEIPDB_API_KEY`	Verifica se um endereço IP foi denunciado por atividade maliciosa.	Não	Painel de controle do AbuseIPDB
`SHODAN_API_KEY`	Busca por dispositivos conectados à internet e portas abertas.	Não	Painel de controle do desenvolvedor Shodan
`TELEGRAM_BOT_TOKEN`	Envia alertas e relatórios de varredura automatizados diretamente para um canal do Telegram.	Não	Telegram BotPai
`CENSYS_API_ID`	Autentica a superfície de ataque e consultas de varredura em toda a internet.	Não	Console de pesquisa Censys
`CENSYS_API_SECRET`	Emparelhado com CENSYS_API_ID para acesso a dados Censys	Não	Console de pesquisa Censys
`ALLOWED_ORIGINS`	Configura as definições de CORS para restringir quais domínios de front-end podem comunicar com o seu back-end.	Não	Defina como uma lista de domínios separados por vírgulas.
`PRISM_BASE_PATH`	Prefixo de caminho de backend público para implantações de subcaminho de proxy reverso	Não	Defina como verdadeiro `/prism`ou deixe vazio
`PRISM_UI_API_KEY`	Chave de interface do usuário do navegador público injetada na interface do usuário servida pelo Docker	Não	Use um valor aceito com escopo de interface do usuário de`API_KEYS`
`PRISM_FRONTEND_DIR`	Diretório de exportação estática do Next.js fornecido pelo FastAPI.	Não	O padrão é`frontend/out`
`NEXT_PUBLIC_API_URL`	Origem da API externa para configurações de compilação/tempo de execução do frontend	Não	Deixe em branco para Docker de mesma origem.
`NEXT_PUBLIC_BASE_PATH`	Caminho base do Next.js em tempo de compilação para implantações de subdiretórios	Não	Combine `PRISM_BASE_PATH`e depois reconstrua.
`TRUST_PROXY_HEADERS`	Permite `X-Forwarded-*`o tratamento confiável por trás de um proxy reverso.	Não	Defina como verdadeiro somente por trás de um proxy confiável.
`FORWARDED_ALLOW_IPS`	IPs de origem proxy autorizados a definir cabeçalhos encaminhados	Não	Endereços IP separados por vírgula ou `*`para redes privadas confiáveis
`TRUSTED_HOSTS`	Restringe os cabeçalhos de host aceitos no backend.	Não	Nomes de host públicos separados por vírgulas
`HEALTHCHECK_HOST`	Cabeçalho do host enviado pelas verificações de integridade do Docker	Não	Por padrão, usa-se a primeira `TRUSTED_HOSTS`entrada ou o localhost.
`OPENROUTER_API_KEY`	Resumo e chat com IA via OpenRouter (provedor de LLM preferencial)	Não	Painel de controle do OpenRouter
`GROQ_API_KEY`	Resumo e chat com IA via Groq (provedor alternativo de LLM)	Não	Console Groq
`MAX_STORED_SCANS`	Número máximo de varreduras mantidas na memória antes que as antigas sejam removidas (padrão: 200)	Não	Defina um valor inteiro.
`DISABLE_DOCS`	Desativa as páginas de documentação da API /docs e /redoc	Não	Definir como Verdadeiro/Falso
`WEBHOOK_SECRET`	Adiciona um cabeçalho X-Prism-Secret aos retornos de chamada do webhook para verificação.	Não	Gere uma string de espaço reservado
`MAX_UPLOAD_MB`	Define o limite máximo de tamanho de arquivo para uploads; o padrão é 20 MB caso não esteja definido.	Não	Defina um valor inteiro.
`WEBHOOK_FORMAT`	Configura o formato dos dados enviados pelo webhook.	Não	Configure para raw, slack ou discord
`CACHE_TTL_HOURS`	Tempo de vida (TTL) do cache do módulo em horas	Não	Defina um valor inteiro.

Transparência de Certificados, Wayback Machine, DNS, WHOIS, Analisador de Sites, Reputação de E-mail, Verificação SMTP, Blackbird, Maigret, Cabeçalhos de E-mail, Metadados de Arquivos e Verificador da Dark Web funcionam sem precisar de chaves de API .

API

O backend expõe uma API REST + WebSocket. As requisições da aplicação requerem um cabeçalho `<API-key>` X-API-Keyou ` Authorization: Bearer<API-key>` no modo de chave de API; no modo anônimo (`<API-key> ALLOW_ANON_API=true`), o cabeçalho pode ser omitido. O usuário permanece sem autenticação. A documentação interativa é servida em `<API-key>` (Swagger) e em `<API-key>` quando executada localmente (a menos que `<API-key>` /healthzseja definido )./docs/redocDISABLE_DOCS=true

Método	Ponto final	Descrição
`POST`	`/api/scan`	Iniciar uma varredura ( `{ target, scan_type, modules }`) → retorna`scan_id`
`GET`	`/api/scan/{id}`	Estado e resultados da digitalização
`GET`	`/api/scan/{id}/graph`	Gráfico de relacionamento de entidades
`GET`	`/api/scan/{id}/map`	Marcadores de mapa GeoIP
`GET`	`/api/scan/{id}/report`	Relatório HTML
`GET`	`/api/scan/{id}/report/pdf`	Relatório em PDF
`GET`	`/api/scans`	Liste as digitalizações anteriores (por diretor).
`GET`	`/healthz`	Verificação de saúde não autenticada
`WS`	`/ws/{scan_id}`	Transmissão ao vivo do progresso da digitalização
`POST`	`/api/ai/summary`,`/api/ai/chat`	Resumo e perguntas e respostas sobre IA
`POST`	`/api/url-scan`, `/api/mac-lookup`, `/api/crypto`, `/api/darkweb`, `/api/qr-decode`,`/api/email-headers``/api/metadata`	Ferramentas independentes

Exemplo autenticado:

curl -X POST http://localhost:8080/api/scan \
  -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  -d '{"target":"example.com","scan_type":"domain"}'

Estrutura do Projeto

prism/
├── config.py                     # Environment + API key loader
├── requirements.txt
├── Dockerfile
├── docker-compose.yml
│
├── modules/
│   ├── extra_tools.py            # WHOIS, GeoIP, DNS, Website Analyzer
│   ├── cert_transparency.py      # Subdomain discovery via crt.sh
│   ├── threat_intel.py           # VirusTotal + AbuseIPDB
│   ├── shodan_lookup.py          # Shodan host intelligence
│   ├── censys_lookup.py          # Censys host + certificate search
│   ├── wayback.py                # Wayback Machine snapshots + sensitive URLs
│   ├── onion_checker.py          # .onion mirror checker (Ahmia + DarkSearch)
│   ├── darkweb_search.py         # Dark-web mentions search
│   ├── blackbird.py              # Username search (async, 50+ platforms)
│   ├── maigret_wrapper.py        # Deep username search (3000+ sites)
│   ├── hlr_lookup.py             # Phone validation + reverse lookup
│   ├── hunter.py                 # DNS-based email reputation check
│   ├── smtp_verify.py            # SMTP mailbox existence verification
│   ├── leak_lookup.py            # Email breach / credential leak lookup
│   ├── telegram_lookup.py        # Telegram username/ID lookup
│   ├── email_header_analyzer.py  # SPF/DKIM/DMARC + hop analysis
│   ├── metadata_extractor.py     # EXIF/PDF/DOCX + GPS extraction
│   ├── crypto_lookup.py          # Crypto address heuristics
│   ├── qr_decoder.py             # QR image decoder
│   ├── url_scanner.py            # Standalone URL scanner
│   ├── opsec_score.py            # Exposure risk scoring (0–100)
│   ├── graph_builder.py          # Entity relationship graph data
│   ├── report_generator.py       # Jinja2 HTML report + xhtml2pdf PDF
│   └── report_i18n.py            # Report translations EN / RU / DE
│
├── web/
│   ├── app.py                    # FastAPI + WebSocket scan engine
│   └── security.py               # Auth, CORS, rate limiting, SSRF guard
│
├── frontend/                     # Next.js 14 + TypeScript + Tailwind
│   └── src/
│       ├── app/                  # App Router pages
│       ├── components/           # UI (Topbar, Sidebar, Map, Graph, ...)
│       └── lib/                  # API client, i18n, types
│
└── tests/                        # 123 pytest tests
    ├── test_modules.py
    ├── test_modules_extended.py
    ├── test_v2_1_modules.py
    └── test_webhook.py

Executando testes

pip install pytest pytest-cov pytest-asyncio
pytest -q
# or with coverage:
pytest tests/ -v --cov=modules --cov=web --cov-report=term-missing

Verificação de tipo de front-end:

cd frontend
npx tsc --noEmit -p tsconfig.json

CI/CD

Pipeline do GitHub Actions ( .github/workflows/ci.yml):

Fiapo — floco8
Teste — pytest com cobertura
Construir — Imagem Docker

Roteiro

v2.2 — lançada

Renderização de relatório multilíngue (EN/RU/DE) viareport_i18n
Webhooks de retorno com assinatura HMAC + proteção SSRF
Mapa GeoIP Leaflet com múltiplos marcadores (substitui o mapa de iframe único)
Autenticação reforçada: chaves de API somente no cabeçalho, sem segredos na string de consulta.
CORS estrito por padrão; ALLOW_ANON_APIopção para modo anônimo ativada.
Mapa do celular: remoção da fabricação de coordenadas, apenas latitude/longitude explícitas.
Download de relatório HTML/PDF autenticado via blob fetch
Conjunto de testes expandido para 102 casos.

v2.3 — lançada

v2.4 — lançada

Módulo de reconhecimento de usuários/organizações do GitHub (perfil, idiomas, repositórios, e-mails com metadados de commits)
Ferramentas independentes para identificação de hash e codificação Base64/URL
Atualização por módulo — execute novamente um único módulo a partir do seu cartão de resultados.
Mapa GeoIP aproximado em nível regional para varreduras de telefones.
Histórico de varreduras — classificado do mais recente para o mais antigo, atualização automática, "Limpar histórico", localizado
Estados vazios amigáveis (aba de gráficos) e mais dicas sobre a barra lateral rotativa
Reforço de segurança — fontes Unicode (DejaVu) em PDF, análise robusta do ambiente de inicialização, tentativas de reinstalação do Docker com apt.

v2.5 — planejado

Análises agendadas + monitoramento contínuo / listas de observação com alertas diferenciados
Exportação de grafo de entidades para GEXF / GraphML (Gephi / Maltego)
Endpoint de cotas e estatísticas de uso por chave de API
Extensão para navegador que permite realizar verificações com um clique.
Localidades adicionais (ZH) + alternância entre tema claro e escuro
(Explorando) Agente OSINT de IA — investigação autônoma com múltiplos módulos

Quer contribuir? Escolha uma questão em aberto com a tag good first issueou abra uma nova.

História das Estrelas

Aviso Legal

Esta ferramenta destina-se exclusivamente a uso lícito :

Avaliações de segurança e testes de penetração autorizados
Pesquise sobre a infraestrutura que você possui ou para a qual tem permissão explícita para testar.
fins acadêmicos e educacionais

Não utilize o PRISM para coleta de dados não autorizada, vigilância ou qualquer atividade que viole a legislação aplicável. O autor não se responsabiliza por uso indevido .

Apoie o projeto

Se o PRISM for útil para você, uma ⭐ é a melhor forma gratuita de ajudar. Se você quiser apoiar o desenvolvimento financeiramente:

Dicas Sber (RUB)
Criptomoedas:

USDT (TRC20): TEdN41cTdAyNm7vrP4NYceT9sVhTB9BHho
TON:          UQAkpcYb0hKgqEwGLs08syU_4Nh-_MhwaJT3HPWqFSidLThV
BTC:          bc1qm8zvvh2ehv3m2su6u0exmcr903cf07gn0r66y6
ETH:          0x0639476A71255FD2C15dceD53e167952DcddEE8A

Perguntas frequentes

Preciso de chaves de API? Não — 14 dos 22 módulos funcionam sem nenhuma chave.

É gratuito? Sim, possui licença MIT e é totalmente auto-hospedado.

Posso executá-lo sem instalar nada? Experimente a demonstração ao vivo ou inicie-o com a demonstração Docker de um único comando.

Qual LLM o resumo de IA utiliza? Qualquer endpoint compatível com OpenAI — OpenRouter, Groq ou Ollama local funcionam.

Contribuindo

Contribuições são bem-vindas! Por favor, leia o arquivo CONTRIBUTING.md antes de enviar uma solicitação de pull request! Para questões de segurança, consulte o arquivo SECURITY.md .

Licença

MIT

Compartilhe