Communitygithub.com

khasky/public-client-leak-audit

Una habilidad para agentes de IA. Audita un cliente público (extensión, app, SPA, CLI, SDK) en busca de filtraciones de funcionamiento interno del backend, secretos y divulgaciones que permitan abusos, y lo endurece antes de publicar como código abierto o enviarlo a una tienda de aplicaciones.

¿Qué es public-client-leak-audit?

Esta habilidad para agentes de IA está diseñada para auditar la superficie pública de un cliente que se comunica con un backend privado. El objetivo es garantizar que todo lo que el cliente expone públicamente sea el mínimo indispensable para su funcionamiento, sin revelar detalles internos del servidor, secretos o mecanismos que faciliten el abuso. El agente sigue un flujo de trabajo en seis fases: 1) definir el límite público/privado, 2) buscar filtraciones utilizando una taxonomía de divulgación, 3) endurecer la seguridad del cliente, 4) aplicar correcciones (eliminar secretos, reescribir comentarios, eliminar código muerto), 5) verificar que no se haya roto nada y 6) generar un informe detallado. La habilidad incluye referencias especializadas (taxonomía de filtraciones, reglas de reescritura, lista de verificación de endurecimiento y plantilla de informe), así como un script de búsqueda automatizada con ripgrep. Es compatible con cualquier cliente público (web, SDK, CLI, extensión, SPA) y es especialmente útil antes de publicar código abierto, enviar a una tienda de aplicaciones o realizar una auditoría de seguridad. El enfoque es defensivo: se busca reducir la superficie de ataque y endurecer el cliente, no construir exploits.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Auditoría de Filtraciones en Clientes Públicos

Audita un cliente de código abierto que se comunica con un backend privado. Objetivo: la superficie pública debe ser autocontenida: puede revelar las llamadas que realiza y las formas de los datos que intercambia (inevitable para cualquier cliente distribuido), pero nada más allá. Cada detalle extra sobre cómo funciona el servidor es reconocimiento gratuito para un atacante y una palanca para el abuso.

Esta habilidad produce tres cosas: una lista de hallazgos (filtraciones + agujeros de seguridad del lado del cliente, cada uno con archivo:línea y severidad), un conjunto de correcciones aplicadas y un informe con recomendaciones residuales.

Archivos de referencia (cargar bajo demanda — lee el que necesites, no incluyas todos en línea):

  • references/leak-taxonomy.md — las categorías de divulgación a buscar, por qué importa cada una y patrones de búsqueda iniciales.
  • references/rewrite-rules.md — la regla de reescritura de comentarios/cadenas con ejemplos de antes/después; cómo decidir mantener vs. eliminar.
  • references/client-hardening.md — lista de verificación de seguridad del lado del cliente (permisos, IPC, tokens, DOM, red, configuración de compilación, cadena de suministro).
  • references/report-template.md — la estructura del informe de salida.
  • scripts/leak-sweep.sh — un barrido parametrizado con ripgrep para iniciar la búsqueda (personaliza los arrays de patrones por producto).

El modelo mental central

Clasifica cada divulgación en uno de dos grupos:

  • Mínimo necesario (conservar): los endpoints que el cliente llama, las formas de solicitud/respuesta que realmente envía y recibe, sus propias elecciones de reintento/backoff/debounce, límites de validación de entrada y el mapeo estado → comportamiento de la UI. Un cliente público no puede ocultar esto; pretender lo contrario es teatro de seguridad.
  • Sobredivulgación (corregir): cualquier cosa que describa lo que el servidor hace con una solicitud, límites/cuotas del lado del servidor que el cliente no necesita estrictamente, endpoints que el cliente distribuido nunca llama, ramas de error que reflejan la lógica interna del servidor, mecanismos antiabuso, identificadores de infraestructura/stack tecnológico, rutas/repositorios privados y andamiaje de pruebas que codifica el comportamiento del backend.

La regla de reescritura. El código del cliente y las pruebas pueden indicar el contrato ("HTTP 422 → mostrar el mensaje de proveedor no soportado"). No deben explicar qué o por qué el servidor lo hace ("el servidor ejecuta una comprobación de dominio desechable y rechaza con 422"). Cuando un comentario explica el comportamiento del servidor, elimínalo o redúcelo al contrato observable por el cliente. Consulta references/rewrite-rules.md.

Flujo de trabajo

Escala el esfuerzo según la solicitud: una "rápida comprobación de si hay filtraciones" son las fases 1–2; "limpiar antes de publicar como código abierto" o "auditoría completa" son las seis. Para un código base grande, distribuye la fase 2 entre varios agentes de solo lectura en paralelo (uno por clúster de taxonomía) y fusiona sus hallazgos archivo:línea — pero tú mismo realiza primero el alcance en la fase 1.

Fase 1 — Definir el límite público/privado

Antes de buscar, establece qué significa "privado" para este producto. No te saltes esto: toda la auditoría es relativa a este límite.

  • Identifica los artefactos públicos bajo auditoría y las contrapartes privadas (backend, herramientas de administración, infraestructura, hermanos del monorepo). Pregunta al usuario o infiere de un AGENTS.md/README/CONTRIBUTING si la división no es obvia.
  • Enumera el stack del backend del producto, hosting, base de datos, mecanismos antiabuso y cualquier recurso de prueba/preproducción — para que reconozcas una filtración cuando la veas. Si no los conoces, esa es la primera pregunta al usuario.
  • Escribe lo que cuenta como mínimo necesario para este cliente (sus endpoints y cargas reales) para que no pierdas tiempo marcando lo inevitable.

Fase 2 — Barrer en busca de filtraciones

Recorre la taxonomía en references/leak-taxonomy.md. Cubre todo el repositorio, no solo src/: pruebas/e2e, docs, README/CHANGELOG, archivos CI/workflow, .env* y sus gemelos .example, archivos de compilación/configuración, manifiestos de paquete (scripts, postinstall) y cadenas locale/i18n (se distribuyen dentro del paquete). Ejecuta scripts/leak-sweep.sh <directorio-objetivo> como barrido inicial, luego lee los aciertos en contexto — una coincidencia de patrón es una pista, no un veredicto. Para cada hallazgo real, registra archivo:línea, una cita breve y una razón de una cláusula. También mantén una lista de "verificado, limpio" para que el informe muestre cobertura.

Presta especial atención a dos clases de alto valor y fáciles de pasar por alto:

  • Secretos a un paso de la publicación — valores reales en archivos .env* ignorados por git que un paquete fuente (zip de "código fuente revisable" de la tienda/app-store, npm pack, una copia de seguridad de directorio) incluiría porque el empaquetador no respeta .gitignore. No rastreado ≠ seguro.
  • Código de prueba/e2e — credenciales de prueba deterministas, parámetros de consulta especiales, endpoints que el cliente distribuido nunca llama y comentarios que narran el funcionamiento interno del servidor. Aquí es donde las filtraciones del backend ocurren con mayor frecuencia, porque las pruebas documentan las respuestas esperadas del servidor.

Fase 3 — Endurecimiento del lado del cliente

Ejecuta references/client-hardening.md. Esto es ortogonal a las filtraciones: se trata de que el cliente sea explotable independientemente de lo que divulgue. Prioriza la validación del remitente/origen en IPC privilegiados, almacenamiento y salida de tokens de autenticación, sumideros DOM/XSS alimentados por datos derivados de la página o del servidor, permisos demasiado amplios y configuración de compilación que permita que una compilación envenenada redirija el backend o empaquete un secreto.

Fase 4 — Remediar

Aplica las correcciones. Orden de impacto:

  1. Primero cerrar los canales de filtración de secretos (excluir archivos .env*/secretos de los paquetes fuente; mover valores reales fuera de archivos adyacentes a confirmaciones).
  2. Aplicar la regla de reescritura a comentarios/cadenas/documentos que filtran; prefiere renombrar código para que un comentario sea innecesario antes que reformular el comentario.
  3. Eliminar código muerto que codifica la política del servidor (TTL de sesiones, cuotas, endpoints eliminados).
  4. Recortar pruebas/documentos al contrato observable por el cliente; mantener el flujo de trabajo, eliminar la narración.
  5. Implementar los cambios de endurecimiento con pruebas.

La preservación del comportamiento es la opción predeterminada: mantén estables los contratos de la API pública, las claves de almacenamiento, los nombres de mensajes y las formas de solicitud/respuesta a menos que la tarea solicite explícitamente un cambio funcional.

Fase 5 — Verificar

Demuestra que no rompiste nada y que no pasaste nada por alto:

  • Ejecuta la verificación de tipos del proyecto, las pruebas unitarias, el linter y una compilación de producción. Captura los códigos de salida reales (una tubería cmd | tail reporta el estado de tail, ocultando una compilación fallida — ejecútala sin la tubería o usa PIPESTATUS/set -o pipefail).
  • Vuelve a ejecutar el barrido de filtraciones; confirma que los patrones buscados ahora sean cero (excepto los deliberados).
  • Escanea el artefacto compilado y cualquier paquete fuente en busca de secretos, sourcemaps y cadenas internas — grep en la salida de dist//compilación y en el zip de fuentes. No confíes solo en la limpieza del árbol fuente.
  • Confirma que los flujos legítimos aún funcionan (por ejemplo, una compilación de staging/e2e que está permitida para ser diferente aún se resuelve correctamente).

Fase 6 — Informe

Redacta el informe según references/report-template.md: hallazgos por severidad, cambios aplicados, recomendaciones residuales (rotación de secretos, exposición en el historial de git, compensaciones diferidas conscientemente) y la evidencia de verificación. Ten en cuenta que el historial de git no se puede corregir retroactivamente — un secreto eliminado o un asunto de commit descriptivo permanece en el registro; recomienda la rotación y la higiene futura de los mensajes de commit en lugar de reescribir el historial de un repositorio público.

Límites de seguridad

  • No marques en exceso lo inevitable. Los endpoints, las formas de las cargas y los mapeos estado → UI son el mínimo necesario; marcarlos erosiona la confianza en el informe.
  • Una coincidencia de patrón es una pista. Léela en contexto antes de llamarla filtración — "epoch" suele ser una marca de tiempo, "worker" podría ser un Web Worker, "durable" podría ser una cola, no Durable Objects.
  • Mantén las cadenas orientadas al usuario que indican una política relevante para el usuario (por ejemplo, "los códigos caducan en 10 minutos"); elimina el marco interno en la descripción/comentario no visible que lo acompaña.
  • Esta habilidad audita tu propio código o código autorizado para reducir su superficie de ataque pública. Es defensiva: reducir la divulgación y endurecer el cliente, no construir exploits.

Skills relacionados