O que é o TrustSiteMonitor

O TrustSiteMonitor (trustsitemonitor.com) é uma ferramenta de auditoria de segurança voltada para desenvolvedores e times de produto que querem identificar vulnerabilidades em seus sites e APIs antes que alguém mal-intencionado o faça. Você informa a URL e o scanner roda uma bateria de 26 verificações automáticas, cobrindo desde headers HTTP até credenciais expostas em bundles JavaScript.

A ferramenta foi construída com .NET no core de análise e Python no scanner avançado, e oferece dois modos: o scanner padrão, que roda automaticamente a cada análise solicitada, e o deep scanner, que usa um browser real (Playwright) para capturar requests dinâmicos que o scanner estático não consegue ver.

O diferencial em relação a outras ferramentas de segurança é o foco específico em stacks modernas de SaaS: Supabase, Firebase, Next.js, APIs GraphQL e configurações de IA/LLM são verificadas com checagens específicas, cobrindo vulnerabilidades que scanners genéricos costumam deixar passar.

Como funciona a análise

Ao submeter uma URL, o TrustSiteMonitor dispara o AnaliseService.cs, que executa 26 fases em sequência. Cada fase é independente e gera seus próprios alertas - uma falha em uma fase não impede as demais de rodar.

O scanner faz requisições HTTP reais para o site analisado, verifica headers de resposta, tenta acessar caminhos sensíveis conhecidos, analisa o conteúdo do bundle JavaScript em busca de credenciais, e testa endpoints de API com payloads de vulnerabilidades comuns como XSS e SQL Injection.

Ao final, o resultado é consolidado em um relatório com nível de severidade para cada achado (crítico, alto, médio, baixo, informativo). O deep scanner complementa essa análise com navegação real no browser, interceptando todos os requests XHR e Fetch que o site faz ao carregar, descobrindo endpoints de API que não aparecem em análise estática.

As 26 fases do scanner padrão

O scanner padrão cobre um espectro amplo de vulnerabilidades organizadas em fases progressivas. As primeiras fases são de reconhecimento e configuração; as seguintes testam vulnerabilidades ativas.

As fases 1 a 10 cobrem a base de segurança:

  • Fase 1 - Reconhecimento: identifica tecnologias do stack (framework, servidor web, CMS) pelos headers e respostas HTTP.
  • Fase 2 - Headers de segurança: verifica ausência de X-Frame-Options, CSP (Content Security Policy), HSTS, X-Content-Type-Options e CORS mal configurado.
  • Fase 3 - Arquivos sensíveis: tenta acessar .env, .git, config.json, wp-config.php e arquivos de backup expostos.
  • Fase 3.5 - Rotas do robots.txt: analisa paths internos listados no robots.txt que estejam sem proteção adequada.
  • Fase 4 - Painéis admin e APIs: verifica se /admin, /phpmyadmin, /debug, /_debug e logs estão expostos.
  • Fase 4.5 - APIs abertas: detecta Swagger/OpenAPI público e schema GraphQL introspectável sem autenticação.
  • Fase 5 - Credenciais no bundle JS: escaneia o JavaScript em busca de Firebase key, Supabase anon key, OpenAI key, Stripe live key, AWS credentials e Anthropic API key.
  • Fase 6 - Source maps: verifica se arquivos .map estão sendo servidos em produção, o que permite reconstruir o código-fonte original.
  • Fase 7 - Proteção brute force: testa se o endpoint de login aplica rate limit ou bloqueia tentativas repetidas.
  • Fase 8 - Directory listing: verifica se o servidor está servindo listagem de arquivos em diretórios.

As fases 9 a 18 cobrem vulnerabilidades em APIs e dados:

  • Fase 9 - Exposição de erros: detecta stack trace e detalhes de exceção retornados em produção.
  • Fase 10 - Portas de infraestrutura: verifica se MongoDB, Redis, Elasticsearch e bancos de dados estão acessíveis externamente.
  • Fase 11 - Supabase: quando detectado, testa schema completo, RLS bypassado por tabela, IDOR em storage público e RPCs de risco.
  • Fase 12 - XSS refletido: testa parâmetros de URL que refletem input sem sanitização.
  • Fase 13 - SQL Injection: testa parâmetros de busca com payloads SQLi clássicos e baseados em erro.
  • Fase 14 - SSRF: identifica endpoints que fazem fetch de URL controlável pelo usuário.
  • Fase 15 - IDOR genérico: detecta endpoints com IDs na URL acessíveis sem autenticação.
  • Fase 16 - IDs sequenciais: verifica se IDs numéricos incrementais permitem enumeração fácil de dados.
  • Fase 17 - IDs em responses públicas: detecta userId, emails e dados internos vazando em respostas públicas.
  • Fase 18 - Limites de paginação: testa endpoints sem limit obrigatório que permitem dump de dados via ?page=1&limit=99999.

As fases 19 a 26 cobrem riscos avançados e de negócio:

  • Fase 19 - Upload inseguro: verifica se endpoints aceitam tipos de arquivo perigosos.
  • Fase 20 - Monitoramento exposto: detecta /metrics (Prometheus) e /health com dados de infraestrutura sensíveis.
  • Fase 21 - Config de negócio exposta: identifica feature flags, preços e configurações internas públicas.
  • Fase 22 - Data dump sem auth: detecta arrays com muitos registros retornados sem autenticação.
  • Fase 23 - Mecanismo de autenticação: verifica token em query param, JWT sem expiração e cookies sem flags Secure/HttpOnly.
  • Fase 24 - Config de IA/LLM exposta: detecta system prompts e configurações de modelo expostos publicamente.
  • Fase 25 - OAuth/SSO credentials: identifica Client ID/Secret expostos em redirects e ausência de PKCE.
  • Fase 26 - Acesso direto ao banco: detecta endpoints que expõe queries diretas, MongoDB admin ou SQL raw.

O deep scanner: análise dinâmica com browser real

O deep scanner (deep_scanner.py) é o modo avançado do TrustSiteMonitor, rodando sob demanda para análises mais profundas. Ele usa Playwright para navegar o site como um usuário real e interceptar todos os requests XHR e Fetch que acontecem durante o carregamento, descobrindo endpoints de API que a análise estática simplesmente não consegue ver.

Além da descoberta dinâmica de endpoints, o deep scanner adiciona checagens específicas:

  • Captura de base URLs de API via regex em variáveis baseUrl, apiUrl, API_URL nos bundles JS.
  • Detecção de Prometheus /metrics exposto com enumeração de rotas internas reais via labels.
  • Teste de data dump sem auth massivo: cada endpoint descoberto é testado sem token.
  • Varredura de credenciais em JS com 11 padrões: Supabase, Firebase, OpenAI, Anthropic, Stripe, AWS, Sentry, Discord e outros.
  • Detecção de auth fraco: token em query params (?token= em URLs reais).
  • Captura de OAuth Client ID exposto em redirects 301/302.
  • Detecção de system prompts de IA em responses públicas.
  • Identificação de IP interno vazando: faixas RFC1918 em responses JSON.
  • Confirmação de endpoint admin existente: 401/403 em /admin, /mongo, /models confirmam que o path existe.

O deep scanner é especialmente útil para aplicações SPA (React, Vue, Angular, Next.js) onde a maior parte dos endpoints de API só é descoberta após interação com o frontend.

Cobertura específica para Supabase

Um dos diferenciais mais relevantes do TrustSiteMonitor é a cobertura específica para o Supabase, o backend-as-a-service mais popular entre startups SaaS. A fase 11 do scanner padrão é dedicada inteiramente a ele, e o deep scanner complementa com análise dinâmica.

As verificações específicas para Supabase incluem:

  • Schema exposto: verifica se o schema completo do banco é acessível via API pública.
  • RLS bypassado: testa tabela por tabela se as políticas de Row Level Security estão funcionando corretamente.
  • IDOR em storage: verifica se objetos em buckets públicos podem ser acessados por qualquer usuário.
  • RPCs de risco: identifica funções de banco de dados (RPCs) chamadas sem autenticação adequada.

Esses vetores são especialmente críticos porque o Supabase entrega a anon key diretamente no frontend, e muitos times configuram RLS incorretamente - ou não configuram - deixando dados abertos para qualquer um que saiba fazer uma chamada REST para o endpoint do Supabase.

Comparação com alternativas

As ferramentas mais conhecidas para auditoria de segurança web são o OWASP ZAP, o Burp Suite e o Nikto. Todas são poderosas, mas exigem configuração e conhecimento técnico significativo para usar corretamente.

O TrustSiteMonitor se diferencia pelo foco em simplicidade de uso e cobertura de stacks modernas. Enquanto o ZAP e o Burp Suite são ferramentas genéricas para pentesters experientes, o TrustSiteMonitor foi projetado para desenvolvedores que querem uma resposta rápida sobre o estado de segurança da sua aplicação sem precisar configurar um ambiente de pentest completo.

A cobertura específica para Supabase, Firebase, GraphQL introspection e credenciais em bundles JS também é mais profunda do que scanners genéricos oferecem, pois essas ferramentas geralmente não foram atualizadas para cobrir os vetores específicos de stacks SaaS modernas.

Pontos positivos e limitações

Os pontos fortes do TrustSiteMonitor são a amplitude de cobertura (26 fases), a facilidade de uso (uma URL é o suficiente para começar), e o foco em stacks modernas. O deep scanner com Playwright é particularmente valioso para SPAs onde a descoberta dinâmica de endpoints faz diferença real.

As limitações naturais de qualquer scanner automático também se aplicam aqui: falsos positivos podem ocorrer, e vulnerabilidades que exigem autenticação não são testadas no modo padrão. O scanner não substitui um pentest manual para aplicações críticas, mas é uma primeira camada de defesa eficiente para identificar problemas óbvios antes de uma auditoria mais profunda.

Outro ponto de atenção: o scanner faz requisições reais ao site analisado. Em sites com rate limit muito agressivo, algumas fases podem retornar falsos negativos por terem sido bloqueadas antes de concluir a verificação.

Casos de uso reais

O TrustSiteMonitor é especialmente útil em alguns cenários práticos:

  • Pre-launch de produto: auditar o site e a API antes de lançar para o público, identificando problemas como Swagger aberto ou credenciais no bundle JS antes que usuários reais os encontrem.
  • Revisão pós-deploy: rodar o scanner após cada deploy significativo para garantir que novas funcionalidades não introduziram regressões de segurança.
  • Auditoria de terceiros: verificar o estado de segurança de um site de parceiro ou fornecedor antes de uma integração.
  • Startups SaaS com Supabase: verificar especificamente se RLS está configurado corretamente e se a anon key não está sendo usada para acessar dados que deveriam ser protegidos.

Dicas para interpretar os resultados

Ao receber o relatório do TrustSiteMonitor, priorize por severidade. Achados críticos como credenciais expostas no bundle JS ou arquivos .env acessíveis devem ser corrigidos imediatamente antes de qualquer outra coisa.

Para achados de severidade média como headers de segurança ausentes, o impacto real depende do contexto da aplicação. Um site estático sem dados de usuário pode operar sem CSP sem risco significativo; uma aplicação de saúde ou financeira não pode.

O relatório de source maps expostos merece atenção especial: arquivos .map em produção permitem que qualquer pessoa reconstrua o código-fonte original do frontend, incluindo lógica de negócio, chaves embarcadas e comentários que não deveriam estar públicos. A correção é simples - basta configurar o bundler para não gerar .map em produção.

Vale a pena usar o TrustSiteMonitor?

Para desenvolvedores e times de produto que não tem um especialista em segurança dedicado, sim. O TrustSiteMonitor oferece em minutos uma visão abrangente do estado de segurança de um site, cobrindo as vulnerabilidades mais comuns que aparecem em projetos reais - muitas vezes por descuido, não por falta de conhecimento.

O custo de não fazer essa verificação pode ser alto: uma chave de API do Stripe exposta no bundle JS pode resultar em fraude; um .env acessível publicamente expõe toda a infraestrutura; um Supabase com RLS desabilitado entrega o banco de dados de todos os clientes para qualquer requisição anônima.

O próximo passo é acessar trustsitemonitor.com, informar a URL do seu site e rodar a análise. Se o relatório voltar limpo, você tem evidência de que os vetores mais comuns estão cobertos. Se voltar com alertas críticos, você descobriu o problema antes que alguém mal-intencionado descobrisse.