Auditoria de Exposição de Arquivos Sensíveis e Segredos do Lado do Cliente

Visão Geral

Aplicativos web modernos enviam muito código e configuração para o navegador. Quando credenciais vazam para essa superfície visível no cliente — codificadas em JavaScript, escondidas em atributos meta/data-* ou comentários HTML, ou servidas como arquivos de origem/configuração/implantação brutos que nunca deveriam ser públicos — qualquer pessoa pode lê-las com curl e um navegador. Esta habilidade é um fluxo de trabalho defensivo, somente leitura para encontrar essa classe de exposição em um aplicativo web que você está autorizado a avaliar.

Mapeia para OWASP A02:2021 Falhas Criptográficas (exposição de dados sensíveis), A05:2021 Configuração Insegura, e CWE-798 (credenciais codificadas), CWE-200 (exposição de informações sensíveis), CWE-540 (código-fonte em uma compilação de produção). Ele busca apenas recursos que o servidor já entrega a qualquer visitante anônimo — ele não explora, força bruta ou muta nada.

Quando Usar Esta Habilidade

• Use quando precisar verificar se um site implantado vaza chaves de API, tokens ou senhas em seu pacote do lado do cliente antes do envio ou durante uma revisão.
• Use ao trabalhar com uma implantação estática/SPA (Vercel, Netlify, Nginx, S3, GitHub Pages) e você quiser confirmar que nenhum arquivo de origem/configuração/implantação é alcançável publicamente.
• Use quando o usuário pedir para "encontrar segredos", "auditar arquivos expostos", "verificar o JS/HTML em busca de credenciais" ou executar uma verificação leve de exposição de dados sensíveis em uma URL que ele possui ou está autorizado a testar.
• Não use isso para atacar sites de terceiros. Veja Notas de Segurança e Proteção.

Como Funciona

Defina o alvo uma vez. Cada comando abaixo lê apenas o que o servidor serve publicamente.

BASE="https://TARGET.example"     # authorized target, no trailing path
WORK="$(mktemp -d)"; cd "$WORK"

Passo 1: Buscar a página e inspecionar os cabeçalhos de resposta

curl -s -D headers.txt -o body.html "$BASE/"
cat headers.txt

Sinalizadores nos cabeçalhos:

• access-control-allow-origin: * — CORS permissivo (pior quando combinado com credenciais).
• Falta de Content-Security-Policy, X-Frame-Options/frame-ancestors, X-Content-Type-Options: nosniff, Referrer-Policy, Permissions-Policy.
• Strict-Transport-Security ausente/fraco.
• Server/banners de versão de framework que identificam a pilha.

Passo 2: Buscar no HTML por segredos e "sinks"

grep -inE "secret|passwd|password|api[_-]?key|apikey|token|bearer|authorization|\
akia|sk_live|sk_test|pk_live|whsec_|ghp_|aiza|private[_-]?key|mongodb(\+srv)?://|\
data-[a-z-]*(secret|token|key|access)" body.html
grep -inE "<!--" body.html            # read every HTML comment
grep -ioE '<meta[^>]+>' body.html     # meta tags often carry keys/ids
grep -ioE '<script[^>]+src="[^"]+"'   body.html   # enumerate JS bundles

Segredos se escondem em atributos data-*, tags <meta>, hidden <div>s, e <!-- comments --> com pelo menos a mesma frequência que em scripts.

Passo 3: Baixar todos os pacotes JavaScript e escaneá-los

# extract script srcs, resolve relative paths against $BASE, fetch and scan
grep -ioE 'src="[^"]+\.js"' body.html | sed -E 's/^src="//; s/"$//' \
 | while read -r p; do
     u="$p"; case "$p" in http*) ;; /*) u="$BASE$p";; *) u="$BASE/$p";; esac
     f="js_$(echo "$p" | tr '/:' '__')"
     curl -s "$u" -o "$f" && echo "== $u =="
   done
grep -rinE "secret|password|api[_-]?key|token|bearer|sk_(live|test)|pk_(live|test)|\
whsec_|akia|aiza|jwt|signing[_-]?key|admin[_-]?token|mongodb|redis://" js_* 2>/dev/null

Também escaneie quaisquer sourcemaps (*.js.map) — eles podem reconstruir a origem original com comentários intactos.

Passo 4: Sondar por arquivos de origem / configuração / implantação alcançáveis publicamente

SPAs frequentemente têm uma reescrita "catch-all" que retorna index.html para caminhos desconhecidos, então compare os tamanhos das respostas — um caminho cujo tamanho difere do fallback da SPA é um arquivo real e distinto.

FALLBACK=$(curl -s "$BASE/____nope____$RANDOM" | wc -c)   # SPA fallback size
for p in /.env /.env.local /.env.production /.git/config /.git/HEAD \
  /package.json /package-lock.json /vercel.json /.vercel/project.json \
  /Dockerfile /docker-compose.yml /wrangler.toml /.gitignore \
  /server/index.js /src/config/app.config.js /config.js \
  /src/services/payment.service.js /webpack.config.js /next.config.js; do
    read -r code size < <(curl -s -o /dev/null -w "%{http_code} %{size_download}" "$BASE$p")
    [ "$code" = "200" ] && [ "$size" != "$FALLBACK" ] && echo "REAL FILE  $code $size  $p"
done

…