Cómo revisar la seguridad de tu código con Claude Code
Monta un flujo de revisión de seguridad con /security-review, comandos propios, un subagente experto y CI en GitHub.
- Claude Code instalado con el instalador nativo y sesión iniciada con un plan Pro, Max, Team o Enterprise, o con una API key de Anthropic
- Un repositorio git con cambios reales que revisar (Node, Python, Go o similar)
- Permisos de administración en el repo de GitHub para crear secretos y workflows (solo para el paso 6)
- Opcional: gitleaks, semgrep y el auditor de dependencias de tu stack (npm audit, pip-audit) instalados en local
- Ejecutar /security-review sobre los cambios de tu rama e interpretar sus hallazgos con criterio
- Blindar Claude Code para que no lea secretos (.env, credenciales) durante la auditoría
- Crear un comando de auditoría propio con el modelo de amenazas de tu proyecto, incluido el tratamiento de datos personales (RGPD, normativas LATAM)
- Definir un subagente de seguridad reutilizable y validar cada hallazgo con un test que lo reproduzca antes de corregirlo
- Automatizar la revisión de seguridad en cada pull request con GitHub Actions
Instalar Claude Code y blindar el acceso a secretos
Antes de pedirle a Claude que audite nada, asegúrate de que la propia auditoría no se convierta en una fuga. Claude Code lee archivos de tu repo para entender el contexto, y un .env con claves de Stripe o de tu base de datos de producción no debería entrar nunca en esa conversación. Instala Claude Code con el instalador nativo (en macOS/Linux con el script de abajo; en Windows con el equivalente de PowerShell que indica la documentación oficial), entra en la raíz del repositorio y crea .claude/settings.json con reglas de denegación. Las reglas deny tienen prioridad sobre cualquier permiso que concedas después durante la sesión, así que son tu red de seguridad. Commitea este archivo: así todo el equipo hereda la misma política. Para preferencias personales usa .claude/settings.local.json, que no se versiona. Por último, arranca con claude y comprueba con /model que estás usando el modelo más capaz disponible (por defecto claude-opus-5-5): en revisiones de seguridad el razonamiento profundo marca la diferencia entre encontrar un IDOR o pasarlo por alto.
# Instalador nativo (macOS / Linux / WSL)
curl -fsSL https://claude.ai/install.sh | bash
# En la raíz del repo
mkdir -p .claude
cat > .claude/settings.json << 'EOF'
{
"permissions": {
"deny": [
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)",
"Read(./**/*.pem)",
"Read(./**/*.key)"
]
}
}
EOF
claudeEjecutar /security-review sobre los cambios de tu rama
Claude Code trae un comando integrado, /security-review, que analiza los cambios pendientes de tu rama buscando vulnerabilidades: inyección SQL y de comandos, XSS, fallos de autenticación y autorización, manejo inseguro de datos, deserialización peligrosa, secretos hardcodeados, etc. Trabaja sobre el diff, no sobre todo el repo, así que el flujo natural es: crea una rama, haz tus cambios, commitea y lanza la revisión antes de abrir la PR. Escribe /security-review en la sesión y espera el informe: cada hallazgo incluye archivo, línea, severidad, explicación del vector de ataque y una propuesta de corrección. Léelo como leerías el informe de un pentester junior muy rápido: casi siempre acierta en lo evidente, pero tú decides qué es explotable en tu contexto real. Si algo no te cuadra, pregunta en la misma sesión: «¿Qué input concreto explotaría el hallazgo 2 y desde qué endpoint?». Si Claude no sabe construir un payload plausible, probablemente sea un falso positivo.
git checkout -b feature/pagos-webhook
# ...haces cambios...
git add -A && git commit -m "feat: webhook de pagos"
claude
# Dentro de la sesión:
# > /security-review
# > ¿Qué input concreto explotaría el hallazgo 2 y desde qué endpoint?Crear un comando de auditoría con tu modelo de amenazas
El comando integrado es genérico; tu proyecto no lo es. Crea un comando propio en .claude/commands/ que incluya lo que solo tú sabes: quién es el atacante, qué datos son sensibles y qué normativa aplica. Si tratas datos personales de clientes en España, el RGPD; en México, la LFPDPPP; en Colombia, la Ley 1581; en Argentina, la Ley 25.326. Eso convierte un log que imprime un email en un hallazgo de verdad, no en ruido. El archivo Markdown se convierte en /auditoria y $ARGUMENTS recibe lo que escribas después (un directorio o módulo). El frontmatter allowed-tools limita la sesión a lectura y comandos git de solo consulta: una auditoría no debería modificar nada. Pide además un formato de salida fijo con severidad y confianza; así puedes comparar auditorías entre sprints y priorizar sin releer prosa.
mkdir -p .claude/commands
cat > .claude/commands/auditoria.md << 'EOF'
---
description: Auditoría de seguridad profunda de un módulo con nuestro modelo de amenazas
allowed-tools: Read, Grep, Glob, Bash(git log:*), Bash(git diff:*), Bash(git blame:*)
---
Audita la seguridad de: $ARGUMENTS
Contexto del proyecto:
- API REST multi-tenant. Atacante principal: usuario autenticado de otro tenant.
- Datos sensibles: emails, DNI/NIE, CURP, RFC, cédulas, IBAN, tokens de pago.
- Normativa: RGPD (UE) y leyes de protección de datos de México y Colombia.
Revisa en este orden:
1. Autorización: ¿cada consulta filtra por tenant_id? Busca IDOR.
2. Inyección: SQL, NoSQL, comandos de sistema, plantillas.
3. Gestión de secretos y datos personales en logs, errores y respuestas.
4. Validación de entrada en límites de confianza (webhooks, uploads).
5. Dependencias y configuración (CORS, cookies, cabeceras).
Para cada hallazgo devuelve: ID, severidad (crítica/alta/media/baja), confianza (alta/media/baja), archivo:línea, vector de ataque concreto, corrección propuesta.
No reportes problemas de estilo ni hallazgos sin vector de ataque plausible.
No modifiques ningún archivo.
EOF
# Uso dentro de Claude Code:
# > /auditoria src/billingDefinir un subagente revisor de seguridad
Cuando trabajas en una sesión larga de desarrollo, tu contexto está lleno de la feature que construyes y eso sesga la revisión: el mismo «cerebro» que escribió el código lo justifica. Un subagente arranca con su propio contexto limpio y su propio prompt de sistema, lo que se parece más a pedir revisión a un compañero. Créalo en .claude/agents/ con un frontmatter que defina nombre, descripción (Claude la usa para decidir cuándo delegar) y herramientas de solo lectura. Luego invócalo de forma explícita: «usa el subagente revisor-seguridad para revisar los cambios de esta rama». También puedes gestionar subagentes con el comando /agents si prefieres una interfaz guiada. Combinarlo con tu comando del paso 3 funciona bien: el comando define qué auditar y el subagente aporta la perspectiva adversarial independiente.
mkdir -p .claude/agents
cat > .claude/agents/revisor-seguridad.md << 'EOF'
---
name: revisor-seguridad
description: Revisor de seguridad adversarial. Úsalo para revisar cambios antes de abrir una PR o tras tocar autenticación, pagos o datos personales.
tools: Read, Grep, Glob, Bash
model: opus
---
Eres un pentester senior revisando código ajeno. Asume que el autor tenía prisa.
Método:
1. Ejecuta git diff main...HEAD para ver los cambios.
2. Para cada cambio, identifica límites de confianza: ¿qué datos vienen del usuario?
3. Traza esos datos hasta su uso (consultas, shell, HTML, ficheros, logs).
4. Intenta construir un payload concreto. Si no puedes, descarta el hallazgo.
Solo puedes usar Bash para comandos git de lectura. Nunca modifiques archivos.
Devuelve una tabla: severidad | confianza | archivo:línea | payload | corrección.
EOFValidar hallazgos con tests y herramientas deterministas
Un LLM es excelente encontrando fallos de lógica (IDOR, autorización rota, flujos mal pensados), algo en lo que los SAST tradicionales fallan. A cambio, las herramientas deterministas son imbatibles en lo exhaustivo: secretos en todo el historial git o CVEs conocidas en dependencias. Usa ambas. Primero, ejecuta los escáneres y pásale la salida a Claude para que la triaje en contexto. Después, para cada hallazgo crítico o alto, aplica esta regla: ningún parche sin un test que falle antes. Pídele a Claude que escriba un test que reproduzca el ataque, verifica que falla, y solo entonces que aplique la corrección y vuelva a ejecutarlo. Así confirmas que la vulnerabilidad era real (si el test no falla, era un falso positivo) y te queda un test de regresión permanente. Revisa siempre el diff del parche: una corrección de seguridad apresurada puede romper la lógica de negocio.
# 1. Escáneres deterministas
gitleaks detect --source . --report-path gitleaks.json
semgrep scan --config auto --json -o semgrep.json
npm audit --json > npm-audit.json # o: pip-audit -f json -o pip-audit.json
# 2. Triaje en Claude Code
claude
# > Lee gitleaks.json, semgrep.json y npm-audit.json. Descarta falsos positivos
# > razonando con el código real y ordena el resto por explotabilidad.
# 3. Para cada hallazgo alto/crítico
# > Escribe un test que reproduzca el hallazgo H-1 (acceso a facturas de otro
# > tenant). Ejecútalo y confirma que FALLA. No toques todavía el código.
# > Ahora aplica la corrección mínima y vuelve a ejecutar el test.Automatizar la revisión en cada pull request
El último paso es que nadie tenga que acordarse. Anthropic publica una GitHub Action, anthropics/claude-code-security-review, que analiza el diff de cada PR y deja comentarios en las líneas afectadas. Crea un secreto en el repo (Settings, sección de secretos de Actions) llamado CLAUDE_API_KEY con una API key de la Console de Anthropic, y añade el workflow de abajo. fetch-depth: 2 y el checkout del head de la PR son necesarios para que la acción pueda calcular el diff. Con exclude-directories evitas gastar tokens en vendor o código generado. Úsala como capa adicional, no como sustituto de la revisión humana: lo ideal es que bloquee nada por sí sola al principio y que el equipo calibre durante unas semanas qué hallazgos son útiles antes de convertirla en check obligatorio.
# .github/workflows/security-review.yml
name: Security Review
permissions:
pull-requests: write
contents: read
on:
pull_request:
jobs:
security:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.sha || github.sha }}
fetch-depth: 2
- uses: anthropics/claude-code-security-review@main
with:
comment-pr: true
claude-api-key: ${{ secrets.CLAUDE_API_KEY }}
exclude-directories: "vendor,node_modules,dist"Has pasado de «a ver si se me escapa algo» a un flujo de seguridad en capas: Claude Code no puede leer tus secretos, /security-review revisa cada rama antes de la PR, un comando propio audita módulos completos con tu modelo de amenazas y la normativa de protección de datos que te aplica en España o LATAM, un subagente aporta una revisión adversarial con contexto limpio, cada hallazgo grave se confirma con un test antes de parchearlo y GitHub Actions comenta automáticamente cada pull request. Si quieres llevar Claude Code a todo tu flujo de desarrollo, más allá de la seguridad (refactors, testing, hooks y trabajo en equipo), ese es el siguiente nivel natural.