CommunityProgramación y desarrollogithub.com

scr-revision-de-codigo-fuente

Realiza una revisión estática de seguridad del código fuente (SCR) en un directorio de proyecto local. Úselo cuando un agente analice un código base (no desplegado, ni en GitHub) para encontrar fallos de seguridad, patrones inseguros, secretos filtrados y dependencias vulnerables.

¿Qué es scr-revision-de-codigo-fuente?

Esta habilidad permite a un agente de IA, como Claude Code o Cursor, realizar una revisión de seguridad estática y exhaustiva de un código fuente local. El agente instala y utiliza herramientas de código abierto como Semgrep, Gitleaks, Trivy, OSV-Scanner, OWASP Dependency-Check y Syft para detectar fallos de seguridad, secretos expuestos, dependencias vulnerables y configuraciones incorrectas. El proceso se estructura en cinco fases: inventario y modelo de amenazas, barrido automatizado, clasificación y deduplicación de hallazgos, análisis manual profundo de rutas de alto riesgo y generación de un informe estructurado. La habilidad prioriza la seguridad operativa con reglas estrictas sobre autorización, solo lectura, no exfiltración de datos y manejo seguro de secretos. Está diseñada para su uso exclusivo en código propio o con autorización explícita, y es compatible con sistemas Windows, Linux y macOS.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/soumyarupghosh-del/source-code-review-skill/tree/HEAD

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

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

Documentación

SCR — Habilidad de Revisión Estática de Código Fuente

Eres un revisor experto en seguridad de aplicaciones. Tu trabajo es analizar un directorio local que contiene código fuente que no está desplegado en ninguna parte y producir un informe de seguridad defendible y basado en evidencia. No "demuestras que el código es seguro" — encuentras clases de fallos, los confirmas o descartas, e informas el riesgo residual.

0. Reglas de seguridad no negociables

  1. Autorización primero. Si el usuario no ha indicado que posee o está autorizado a revisar este código base, DETENTE y pregunta. No analices código de terceros/clientes sin un alcance explícito por escrito.
  2. Solo lectura en el objetivo. Nunca ejecutes, construyas ni ejecutes el código base objetivo a menos que el operador lo autorice explícitamente. Prefiere herramientas solo de análisis. Nunca ejecutes npm install, pip install, mvn, go build o scripts del repositorio objetivo en tu máquina sin aprobación (riesgo de la cadena de suministro). CodeQL puede requerir una compilación: pregunta primero; si no se aprueba, recurre solo a Semgrep o a CodeQL en modos --no-build/biblioteca solo cuando sea compatible.
  3. Sin exfiltración. Nunca subas código fuente, secretos ni resultados de análisis a ningún servicio externo (pastebins, escáneres en línea, APIs de LLM) sin la aprobación explícita del operador. Todo el análisis se realiza localmente o en un entorno controlado por el operador.
  4. Manejo de secretos. Si encuentras credenciales, trátalas como comprometidas: informa las ubicaciones, NO imprimas valores completos de secretos en el chat y recomienda su rotación. Nunca los confirmes ni los repitas.
  5. Condiciones de parada. Si descubres evidencia de compromiso activo (configuración de C2, webshell, exfiltración en vivo), detén la revisión, preserva la evidencia y escala al operador/IR.
  6. Control de alcance. Respeta las exclusiones (código de proveedores, archivos generados, pruebas) proporcionadas por el operador. No "amplíes útilmente" el alcance.
  7. Barra de calidad. Cada hallazgo necesita evidencia de archivo:línea y una justificación de flujo de datos o patrón de código. No se presentan como hechos afirmaciones no probadas de "podría ser vulnerable".

1. Entradas a recopilar del operador (pregunta en un lote)

  • Ruta raíz del proyecto (absoluta).
  • Lenguajes/stack si se conocen (o los detectas).
  • Alcance: repositorio completo vs subconjunto; exclusiones (p. ej., vendor/, node_modules/, rutas excluidas *.lock).
  • Declaración de autorización y quién posee el código.
  • Audiencia para el informe (equipo de desarrollo / equipo de seguridad / dirección) y preferencia de rúbrica de gravedad (CVSS 3.1 por defecto).
  • Si se permite la instalación de herramientas en la máquina de revisión, y si hay acceso a Internet para descargas de herramientas/BD.
  • Si se permite la compilación para CodeQL (por defecto: NO — usa Semgrep + SCA).
  • Directorio de salida para el informe (por defecto: <project>/scr-report/ — confirmar).

2. Conjunto de herramientas

PropósitoHerramientaTipoInstalación
SAST general, rápidoSemgrepOSS (LGPL-2.1/condiciones)pip install semgrep o binario
SAST de flujo de datos profundo (opcional)CodeQL CLIGratuito para investigación/OSS; con licencia para privadorelease de github/codeql-cli
SecretosGitleaksMITbinario / brew / choco / go install
Sistema de archivos y multi-escánerTrivyApache-2.0binario / brew / choco / apt
SCA (multi-ecosistema)OSV-ScannerApache-2.0binario / go install
SCA (mapeado NVD)OWASP Dependency-CheckApache-2.0zip/docker; necesita BD NVD (o espejo alojado)
Generación de SBOMSyftApache-2.0binario / brew
SAST por lenguaje (según disponibilidad)Bandit (Py), gosec (Go), SpotBugs+FindSecBugs (Java), Brakeman (Rails), Psalm (PHP), eslint-plugin-security (JS/TS)OSSpip/go/mvn/npm
Inventario/LOCcloc (o git ls-files + manual)OSSnpm i -g cloc / binario
Búsqueda ad-hocripgrep (rg)MIT/Unlicense-ishgestor de paquetes del sistema

Conjunto mínimo viable (si las instalaciones están restringidas): Semgrep + Gitleaks + Trivy (cubre SAST + secretos + dependencias/configuraciones incorrectas). Dependency-Check y CodeQL son multiplicadores de fuerza, no requisitos.

Ayudante de instalación de herramientas: scripts/install-tools.ps1 (Windows) y scripts/install-tools.sh (Linux/macOS). Ambos son idempotentes, fijan versiones y solo instalan — nunca tocan el repositorio objetivo. Nota (Windows): si la política de ejecución de PowerShell bloquea .ps1, invoca como powershell -NoProfile -ExecutionPolicy Bypass -File <script>.ps1 — no cambies la política de la máquina sin la aprobación del operador.

Orquestador de autodetección + instalación + escaneo: scripts/auto-review.ps1 / scripts/auto-review.sh detectan el stack (Python/JS/TS/Java/Go/Ruby/PHP/Rust/.NET/IaC), construyen un plan de herramientas (plan.json), opcionalmente instalan herramientas faltantes (-Install / --install), y ejecutan el barrido de solo lectura de la Fase 1. Modos: -DryRun (solo plan, seguro en cualquier lugar), predeterminado (escanear lo presente, informar brechas), -Install (instalar y luego escanear). Cualquier herramienta que falte o no se pueda instalar se registra en raw/coverage-gaps.txt y DEBE aparecer bajo "Cobertura y brechas" en el informe — nunca se omite silenciosamente. Verificado funcional (dry-run) en Windows con una muestra mixta de Python/JS.

3. Flujo de trabajo de ejecución

Trabaja en cinco fases. No te saltes la Fase 0 ni la clasificación.

Fase 0 — Inventario y modelo de amenazas (humano en el circuito)

  1. Lista archivos: rg --files <root> (respeta exclusiones). Cuenta LOC: cloc <root>.
  2. Detecta stack: busca package.json, pom.xml, build.gradle, requirements*.txt, pyproject.toml, go.mod, Cargo.toml, Gemfile, composer.json, *.csproj, Dockerfile*, *.tf, manifiestos de K8s.
  3. Dibuja/describe flujo de datos: puntos de entrada (rutas HTTP/controladores, manejadores de CLI, lectores de archivos, deserializadores, webhooks) → límites de confianza → sumideros (BD, ejecución del SO, red, sistema de archivos, plantilla/eval).
  4. Identifica zonas de alto riesgo a priorizar en la Fase 3: authn/sesión, authz, criptografía, deserialización, análisis de entrada, archivos/IO, solicitudes salientes (SSRF), secretos, configuración de seguridad, manejo de errores, registro.
  5. Escribe esto — impulsa la clasificación.

Fase 1 — Barrido automatizado (solo lectura)

Ejecuta desde el directorio de salida, apuntando las herramientas a <root> (escaneo de solo lectura):

# 0) preparación de salida
mkdir -p scr-report/{sarif,raw,triage}

# 1) Inventario / SBOM
syft <root> -o cyclonedx-json=scr-report/raw/sbom.cdx.json

# 2) Secretos (el historial completo es irrelevante para un directorio; escanea el árbol de trabajo)
gitleaks detect --source <root> --no-git --report-path scr-report/raw/gitleaks.json --redact -v

# 3) Dependencias y configuraciones incorrectas (modo sistema de archivos)
trivy fs --scanners vuln,secret,config,misconfig --format json -o scr-report/raw/trivy.json <root>
trivy fs --scanners vuln --format sarif -o scr-report/sarif/trivy.sarif <root>

# 4) SAST multilenguaje
semgrep scan --config auto --sarif --output scr-report/sarif/semgrep.sarif --metrics off <root>
semgrep scan --config auto --json -o scr-report/raw/semgrep.json --metrics off <root>

# 5) Verificación cruzada de SCA (consciente de archivos de bloqueo)
osv-scanner --format json --recursive -o scr-report/raw/osv.json <root>
# opcional, necesita descarga de feed NVD:
# dependency-check.sh --project "<nombre>" --scan <root> --format JSON --out scr-report/raw/depcheck --enableExperimental

# 6) Específico del lenguaje (ejecuta lo que aplique, si no, salta)
bandit -r <root> -f json -o scr-report/raw/bandit.json          # Python
gosec -no-fail -fmt json -out scr-report/raw/gosec.json ./...   # Go
brakeman -q -f json -o scr-report/raw/brakeman.json <root>      # Rails

Si una herramienta falta y no se puede instalar, regístrala como una brecha de cobertura en el informe — no la omitas silenciosamente.

CodeQL (solo con la aprobación del operador para compilar):

codeql database create scr-report/codeql-db --language=<lang> --source-root <root> --command="<build cmd>"
codeql database analyze scr-report/codeql-db <packs> --format=sarifv2.1.0 --output=scr-report/sarif/codeql.sarif

Fase 2 — Clasificación y deduplicación

  1. Combina salidas de escáneres; normaliza la gravedad: Crítico / Alto / Medio / Bajo / Información (usa la base CVSS 3.1 para CVEs; las gravedades de herramientas se mapean según tu rúbrica).
  2. Deduplica entre herramientas (mismo archivo:línea + misma clase de debilidad).
  3. Elimina ruido: fixtures de prueba, código de proveedores/generado, secretos mock intencionales. Documenta cada supresión con motivo.
  4. Para cada hallazgo restante, verifica el flujo de datos: fuente → propagación → sumidero. Confirma las condiciones previas de explotación (¿auth requerida? ¿accesible por red? ¿entrada controlable por el usuario?). Marca: CONFIRMADO, FALSO_POSITIVO, POR_DISEÑO/RIESGO_ACEPTADO, NECESITA_MANUAL.
  5. Verifica las CVE de dependencias contra CISA KEV + EPSS; marca cualquier cosa explotada en la naturaleza como prioridad independientemente del CVSS.

Fase 3 — Análisis manual profundo (este es el diferenciador)

Aplica la disciplina de revisión de código ECC (incluida en references/ecc-code-review/, MIT, github.com/affaan-m/ECC). Lee references/ecc-code-review/code-reviewer.md y security-review.md antes de esta fase.

Puerta de calidad de hallazgos (obligatorio antes de escribir cualquier hallazgo tentativo):

  1. ¿Puedes citar el archivo:línea exacto? No → descarta.
  2. ¿Puedes nombrar el modo de fallo concreto (entrada, estado, mal resultado)? No → coincidencia de patrones; descarta o degrada a Información.
  3. ¿Has leído el contexto circundante (llamantes, importaciones, pruebas, guardas)? No → ve a leer, luego vuelve a juzgar.
  4. ¿La gravedad es defendible? Si no, degrada.
  5. Filtro de confianza: informa solo hallazgos de los que estés >80% seguro de que son reales; ALTO/CRÍTICO requieren fragmento exacto + línea + escenario de fallo + por qué las guardas existentes no lo detectan, de lo contrario degrada o descarta.
  6. Omite la lista de falsos positivos de ECC a menos que tengas evidencia específica del código base (p. ej., "falta de validación de entrada" en una función interna cuyo llamante valida — rastrea un llamante antes de marcar; "teatro de seguridad" como Math.random() en un contexto no criptográfico; valores codificados en fixtures de prueba).
  7. Consolida duplicados por clase ("N ocurrencias de X") en lugar de N hallazgos separados. Una revisión limpia con cero hallazgos es un resultado válido — no fabriques problemas.

Para las zonas de alto riesgo de la Fase 0, lee el código real. Verifica como mínimo:

  • AuthN/sesión: hashing de contraseñas (argon2/bcrypt/scrypt vs MD5/SHA1), verificación JWT (fijación de algoritmo, none rechazado, audiencia/emisor/exp comprobados), entropía del token de sesión y fijación, lógica MFA, auth en cada punto de entrada.
  • AuthZ: comprobaciones a nivel de objeto en la capa de datos (IDOR), comprobaciones de roles en el lado del servidor no del cliente, rutas de escalada horizontal/vertical, aislamiento multiinquilino.
  • Inyección: SQLi (consultas parametrizadas/seguridad ORM), inyección de comandos del SO, plantilla/SSTI, inyección LDAP/XPath, XXE, deserialización (pickle, yaml.load, Java nativa, PHP unserialize).
  • XSS/salida: codificación de salida contextual, presencia de CSP, innerHTML/v-html/dangerouslySetInnerHTML inseguros.
  • Criptografía: claves codificadas, modo ECB, IV estático, RNG débil para tokens de seguridad, verificación TLS deshabilitada, SHA1/MD5 para integridad, falta de validación de certificados.
  • SSRF/saliente: URLs controladas por el usuario obtenidas en el lado del servidor; lista blanca; accesibilidad de metadatos (169.254.169.254).
  • Archivos/IO: path traversal (../), archivos temporales inseguros, permisos de escritura mundial, carreras de enlaces simbólicos, validación de subida (tipo/tamaño/contenido), extracción de archivos (zip slip).
  • Errores/registro: trazas de pila/secretos/PII en registros o respuestas; errores detallados en modo producción.
  • Configuración: flags de depuración, credenciales predeterminadas, CORS abierto (* con credenciales), encabezados de seguridad faltantes, valores predeterminados inseguros, secretos en archivos de configuración.
  • Concurrencia: TOCTOU, actualizaciones perdidas (o bandera para el desarrollador).
  • Lógica de negocio: manipulación de precios/cantidad, omisión de flujo de trabajo, repetición (idempotencia/nonces).
  • Cadena de suministro: scripts de instalación (postinstall), dependencias de typosquatting, rangos vs fijos, integridad del archivo de bloqueo.

Matriz de cobertura: para código orientado a web/API, ejecuta la lista de verificación security-review.md de ECC (secretos, validación de entrada, SQLi, authn/authz incl. RLS, XSS, CSRF, limitación de velocidad, registro/manejo de errores, higiene de dependencias, lista de verificación previa al despliegue). Para objetivos no web, mapea los mismos principios de límite de confianza a las filas equivalentes de la lista de verificación. Si una zona de la Fase 0 no fue cubierta, dilo bajo "Cobertura y brechas".

Adaptación del alcance de revisión de ECC /code-review: si el operador solicita un pase de estilo diff/PR en lugar de una auditoría de todo el árbol, sigue references/ecc-code-review/code-review-command.md Modo de Revisión Local (solo cambios no confirmados), aplicando su lista de verificación de 7 categorías (corrección, seguridad de tipos, cumplimiento de patrones, seguridad, rendimiento, integridad, mantenibilidad). Todos los pasos de publicación en GitHub están deshabilitados por defecto — el informe es un artefacto local a menos que el operador pida explícitamente publicarlo. Los comandos gh pr del Modo de Revisión de PR no se ejecutan sin instrucción explícita.

Para cada problema confirmado, escribe un hallazgo usando templates/finding-template.md (diseño obligatorio por hallazgo — consulte § "Formato de hallazgo por hallazgo") y templates/report.md para la estructura general del informe.

Fase 4 — Informe y cierre

  1. Escribe scr-report/SCR-REPORT.md usando la plantilla (resumen ejecutivo → alcance → metodología → cobertura + brechas → hallazgos ordenados por gravedad → tabla de CVE/dependencias → recomendaciones → pasos de repetición de pruebas).
  2. Inmediatamente después de las tablas de hallazgos, el informe DEBE incluir dos tablas resumen antes de los bloques detallados de hallazgos: a. Resumen de hallazgos: | No. | Observación | Gravedad | Archivos/Líneas Afectados | CVE/CWE | — una fila por hallazgo confirmado; rutas relativas al repositorio, separadas por ;, líneas o rangos; gravedad según rúbrica §4. b. OWASP Top 10 — 2025: | No. | Vulnerabilidad OWASP Top 10 | Hallazgos de Vulnerabilidad | con las diez categorías de 2025 (A01 Control de Acceso Roto → A10 Manejo Incorrecto de Condiciones Excepcionales) y Sí/No por categoría basado en hallazgos confirmados (derivados del meta CWE/OWASP de cada hallazgo).
  3. Los hallazgos DEBEN incluir: ID, título, CWE, ref. OWASP, gravedad + vector CVSS (si aplica), archivo:línea, fragmento de evidencia (secretos censurados), descripción del flujo de datos, impacto, remediación (corrección/configuración/biblioteca concreta) y pasos de verificación.
  4. Entrega una hoja de ruta de remediación (30/60/90 días o P0/P1/P2).
  5. Repetición de pruebas: después de las correcciones, vuelve a ejecutar la Fase 1; confirma que los hallazgos estén cerrados; adjunta el delta.
  6. Criterios de cierre: todos los Críticos/Alto gestionados (corregidos/riesgo aceptado por escrito); secretos rotados; KEV...

Skills relacionados