Communitygithub.com

khasky/public-client-leak-audit

Audita um cliente público (extensão, app, SPA, CLI, SDK) em busca de vazamentos de detalhes internos do backend, segredos e informações que possibilitam abuso. Endurece o código antes de abrir o código-fonte ou enviar para uma loja.

O que é public-client-leak-audit?

Esta skill, chamada 'Public Client Leak Audit', serve para auditar um cliente público (como extensão, app, SPA, CLI ou SDK) que se comunica com um backend privado. O objetivo é garantir que a superfície pública do cliente seja autocontida, revelando apenas as chamadas que faz e os formatos de dados que troca (o que é inevitável), mas nada além disso. Qualquer detalhe extra sobre o funcionamento interno do servidor é reconhecimento gratuito para um atacante. A skill produz três artefatos: uma lista de achados (vazamentos e falhas de segurança do lado do cliente, com `file:line` e severidade), um conjunto de correções aplicadas e um relatório com recomendações residuais. Ela é útil para engenheiros de software que desejam endurecer seus clientes públicos antes de abrir o código-fonte, enviar para uma loja de aplicativos ou realizar uma auditoria completa de segurança, suportando qualquer plataforma onde o cliente seja executado e o repositório de código esteja acessível. A skill carrega referências especializadas sob demanda e segue um fluxo de trabalho em seis fases: escopo da fronteira público/privado, varredura de vazamentos, endurecimento do lado do cliente, correção, verificação e relatório.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add khasky/public-client-leak-audit

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Auditoria de Vazamento em Cliente Público

Audite um cliente público que se comunica com um backend privado. Objetivo: a superfície pública deve ser autocontida — ela pode revelar as chamadas que faz e os formatos de dados que troca (inevitável para qualquer cliente distribuído), mas nada além disso. Cada detalhe extra sobre como o servidor funciona é reconhecimento gratuito para um atacante e uma alavanca para abuso.

Esta skill produz três coisas: uma lista de achados (vazamentos + falhas de segurança do lado do cliente, cada um com file:line e severidade), um conjunto de correções aplicadas e um relatório com recomendações residuais.

Arquivos de referência (carregue sob demanda — leia apenas o que precisar, não inclua todos inline):

O modelo mental central

Classifique cada divulgação em um de dois baldes:

  • Mínimo necessário (manter): os endpoints que o cliente chama, os formatos de requisição/resposta que ele realmente envia e recebe, suas próprias escolhas de retry/backoff/debounce, limites de validação de entrada e o mapeamento status → comportamento da UI. Um cliente público não pode esconder isso; fingir o contrário é teatro de segurança.
  • Divulgação excessiva (corrigir): qualquer coisa que descreva o que o servidor faz com uma requisição, limites/cotas do lado do servidor que o cliente não precisa estritamente, endpoints que o cliente distribuído nunca chama, ramos de erro que espelham a lógica interna do servidor, mecanismos anti-abuso, identificadores de infra/stack tecnológica, caminhos/repositórios privados e testes que codificam o comportamento do backend.

A regra de reescrita. O código do cliente e os testes podem declarar o contrato ("HTTP 422 → mostrar a mensagem de provedor não suportado"). Eles não devem explicar o que ou por que o servidor o faz ("o servidor executa uma verificação de domínio descartável e rejeita com 422"). Quando um comentário explica o comportamento do servidor, exclua-o ou reduza-o ao contrato observável pelo cliente. Consulte references/rewrite-rules.md.

Fluxo de trabalho

Escalone o esforço conforme a solicitação: uma verificação rápida do tipo "isso vaza algo?" são as fases 1–2; "limpe antes de abrir o código-fonte" ou "auditoria completa" são todas as seis. Para uma base de código grande, distribua a fase 2 em vários agentes de leitura paralelos (um por cluster de taxonomia) e mescle os achados de file:line — mas faça o escopo na fase 1 você mesmo primeiro.

Fase 1 — Escopo da fronteira público/privado

Antes de pesquisar, estabeleça o que "privado" significa para este produto. Não pule esta etapa — toda a auditoria é relativa a essa fronteira.

  • Identifique o(s) artefato(s) público(s) sob auditoria e as contrapartes privadas (backend, ferramentas de administração, infraestrutura, irmãos do monorepo). Pergunte ao usuário ou deduza de um AGENTS.md/README/CONTRIBUTING se a divisão não for óbvia.
  • Liste a stack do backend do produto, hospedagem, banco de dados, mecanismos anti-abuso e quaisquer recursos de teste/staging — para reconhecer um vazamento quando encontrar um. Se não os conhecer, essa é a primeira pergunta ao usuário.
  • Escreva o que conta como mínimo necessário para este cliente (seus endpoints reais e payloads) para não perder tempo sinalizando o inevitável.

Fase 2 — Varredura de vazamentos

Percorra a taxonomia em references/leak-taxonomy.md. Cubra todo o repositório, não apenas src/: testes/e2e, docs, README/CHANGELOG, arquivos CI/workflow, .env* e seus gêmeos .example, arquivos de build/config, manifestos de pacote (scripts, postinstall) e strings de locale/i18n (elas são enviadas dentro do pacote). Execute scripts/leak-sweep.sh <target-dir> como varredura inicial, depois leia os resultados no contexto — uma correspondência de padrão é uma pista, não um veredito. Para cada achado real, registre file:line, uma citação curta e uma cláusula de motivo. Mantenha também uma lista "verificado, limpo" para que o relatório mostre cobertura.

Preste atenção especial a duas classes de alto valor e fáceis de perder:

  • Segredos a um passo da publicação — valores reais em arquivos .env* ignorados pelo git que um pacote de origem (zip de "fontes revisáveis" da loja/app-store, npm pack, um backup de diretório) incluiria porque o empacotador não respeita .gitignore. Não rastreado ≠ seguro.
  • Código de teste/e2e — credenciais de teste determinísticas, parâmetros de consulta especiais, endpoints que o cliente distribuído nunca chama e comentários narrando a mecânica interna do servidor. É aqui que o comportamento do backend vaza com mais frequência, porque os testes documentam as respostas esperadas do servidor.

Fase 3 — Endurecimento do lado do cliente

Execute references/client-hardening.md. Isso é ortogonal aos vazamentos: trata-se de o cliente ser explorável independentemente do que divulga. Priorize a validação de remetente/origem em IPC privilegiado, armazenamento e saída de tokens de autenticação, sinks de DOM/XSS alimentados por dados derivados de página ou servidor, permissões excessivamente amplas e configuração de tempo de build que permite que um build envenenado redirecione o backend ou empacote um segredo.

Fase 4 — Correção

Aplique as correções. Ordem de impacto:

  1. Feche primeiro os canais de vazamento de segredos (exclua arquivos .env*/secret dos pacotes de origem; mova valores reais para fora de arquivos adjacentes ao commit).
  2. Aplique a regra de reescrita a comentários/strings/docs que vazam; prefira renomear o código para que um comentário se torne desnecessário em vez de reformular o comentário.
  3. Exclua código morto que codifica política do servidor (TTLs de sessão, cotas, endpoints removidos).
  4. Ajuste testes/docs para o contrato observável pelo cliente; mantenha o fluxo funcionando, corte a narração.
  5. Implemente as alterações de endurecimento com testes.

Preservar o comportamento é o padrão: mantenha contratos públicos da API, chaves de armazenamento, nomes de mensagens e formatos de requisição/resposta estáveis, a menos que a tarefa exija explicitamente uma alteração funcional.

Fase 5 — Verificação

Prove que você não quebrou nada e não perdeu nada:

  • Execute a verificação de tipos, testes unitários, lint e uma build de produção do projeto. Capture códigos de saída reais (um pipe cmd | tail relata o status do tail, ocultando uma build com falha — execute sem o pipe ou use PIPESTATUS/set -o pipefail).
  • Reexecute a varredura de vazamentos; confirme que os padrões pretendidos agora são zero (exceto os deliberados).
  • Verifique o artefato construído e qualquer pacote de origem em busca de segredos, sourcemaps e strings internas — grep na saída de dist//build e no zip de fontes. Não confie apenas na limpeza da árvore de origem.
  • Confirme que os fluxos legítimos ainda funcionam (por exemplo, uma build de staging/e2e que tem permissão para diferir ainda resolve corretamente).

Fase 6 — Relatório

Escreva o relatório conforme references/report-template.md: achados por severidade, alterações aplicadas, recomendações residuais (rotação de segredos, exposição no histórico do git, trade-offs conscientemente adiados) e a evidência de verificação. Observe que o histórico do git não pode ser corrigido retroativamente — um segredo removido ou um assunto de commit descritivo permanece no log; recomende rotação e higiene de mensagens de commit futuras em vez de reescrever o histórico de um repositório público.

Diretrizes

  • Não sinalize excessivamente o inevitável. Endpoints, formatos de payload e mapeamentos status → UI são o mínimo necessário; sinalizá-los corrói a confiança no relatório.
  • Uma correspondência de padrão é uma pista. Leia-a no contexto antes de chamá-la de vazamento — "epoch" geralmente é um timestamp, "worker" pode ser um Web Worker, "durable" pode ser uma fila, não Durable Objects.
  • Mantenha strings voltadas ao usuário que declaram uma política relevante ao usuário (por exemplo, "os códigos expiram em 10 minutos"); corte o enquadramento interno na descrição/comentário não visível ao lado dela.
  • Esta skill audita seu próprio / código autorizado para reduzir sua superfície de ataque pública. É defensiva: redução de divulgação e endurecimento do cliente, não construção de explorações.

Habilidades Relacionadas