swl-ses 3.3.2

package/hooks/escaneo-secretos.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: escaneo-secretos.js
+ * Tipo: PreToolUse  (aplica a: Write, Edit)
+ *
+ * Escanea el contenido que Claude Code está a punto de escribir en disco
+ * buscando patrones conocidos de secretos y credenciales sensibles:
+ *
+ *   - API keys de Anthropic / OpenAI (sk-ant-*, sk-proj-*, sk-live-*, sk-test-*)
+ *   - Tokens de AWS (AKIA*, ASIA*)
+ *   - Tokens de GitHub (ghp_*, gho_*, ghu_*, ghs_*, ghr_*)
+ *   - Tokens de GitLab (glpat-*)
+ *   - Claves privadas PEM / SSH
+ *   - Passwords hardcodeados en asignaciones de variable comunes
+ *   - Tokens JWT (tres segmentos base64 separados por puntos)
+ *   - Connection strings con credenciales embebidas (usuario:contraseña@host)
+ *   - Variables de entorno sensibles hardcodeadas en código
+ *
+ * Resultado:
+ *   - Secreto detectado → exit 2, JSON {result:"block", reason:"..."} en stdout
+ *   - Sin secreto       → exit 0, sin output
+ *   - Error interno     → exit 0 (nunca bloquear por fallo del hook)
+ *
+ * NOTA: Este hook es una primera línea de defensa heurística, no un escáner
+ * de seguridad exhaustivo. Complementar con herramientas como trufflehog,
+ * gitleaks o detect-secrets en el pipeline CI.
+ */
+
+// ---------------------------------------------------------------------------
+// Patrones de detección
+// ---------------------------------------------------------------------------
+
+/**
+ * Cada entrada describe un tipo de secreto con:
+ *   - nombre:   Etiqueta para el mensaje de error.
+ *   - patron:   Expresión regular para detectarlo.
+ *   - ejemplos: Comentario ilustrativo (no se usa en código).
+ */
+const PATRONES_SECRETOS = [
+  {
+    nombre: 'Anthropic API Key (sk-ant-*)',
+    // sk-ant-api03-xxxxxxxx...
+    patron: /\bsk-ant-[A-Za-z0-9\-_]{20,}\b/,
+  },
+  {
+    nombre: 'OpenAI API Key (sk-proj-* / sk-live-* / sk-test-* / sk-[a-z0-9]{48})',
+    // sk-proj-..., sk-live-..., sk-test-..., sk-<48 chars alfanum>
+    patron: /\bsk-(?:proj|live|test)-[A-Za-z0-9\-_]{20,}\b|\bsk-[A-Za-z0-9]{48,}\b/,
+  },
+  {
+    nombre: 'AWS Access Key ID (AKIA* / ASIA*)',
+    // AKIAIOSFODNN7EXAMPLE  o  ASIAXXX...
+    patron: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
+  },
+  {
+    nombre: 'GitHub Personal Access Token (ghp_* / gho_* / ghu_* / ghs_* / ghr_*)',
+    patron: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/,
+  },
+  {
+    nombre: 'GitLab Personal Access Token (glpat-*)',
+    patron: /\bglpat-[A-Za-z0-9\-_]{20,}\b/,
+  },
+  {
+    nombre: 'Clave privada PEM (RSA / EC / OpenSSH)',
+    // -----BEGIN RSA PRIVATE KEY-----  o  -----BEGIN OPENSSH PRIVATE KEY-----
+    patron: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |)PRIVATE KEY-----/,
+  },
+  {
+    nombre: 'Password hardcodeado en variable',
+    // password = "valor", passwd='valor', pwd="valor"  (no vacío, no placeholder)
+    // Se ignoran valores que claramente son placeholders: "xxx", "your_", "<", "ENV", os.environ
+    patron: /(?:password|passwd|pwd|secret|secret_key|api_secret)\s*[:=]\s*["'](?!(?:your_|<|xxx|ENV|os\.environ|\$\{|%\w+%))[^"'\s]{6,}["']/i,
+  },
+  {
+    nombre: 'Token JWT (tres segmentos base64url)',
+    // eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c3IifQ.xxxx
+    // Solo se marca si el header decodifica como JSON con "alg" (heurística fuerte)
+    patron: /\beyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\b/,
+  },
+  {
+    nombre: 'Connection string con credenciales (usuario:contraseña@host)',
+    // postgresql://user:pass@host, mysql://user:pass@host, mongodb://user:pass@host
+    patron: /(?:postgresql|mysql|mongodb|redis|amqp|mssql|jdbc):\/\/[^:@\s]+:[^@\s]+@[^\s"']+/i,
+  },
+  {
+    nombre: 'Stripe Secret Key (sk_live_* / sk_test_*)',
+    patron: /\bsk_(?:live|test)_[A-Za-z0-9]{24,}\b/,
+  },
+  {
+    nombre: 'Slack Bot / App Token (xoxb-* / xoxa-* / xoxe-*)',
+    patron: /\bxox[bpae]-[A-Za-z0-9\-]{20,}\b/,
+  },
+  {
+    nombre: 'Twilio Account SID / Auth Token',
+    // AC seguido de 32 hex chars
+    patron: /\bAC[0-9a-fA-F]{32}\b/,
+  },
+  {
+    nombre: 'Google API Key (AIzaSy*)',
+    patron: /\bAIzaSy[A-Za-z0-9\-_]{33}\b/,
+  },
+  {
+    nombre: 'Secreto en variable de entorno hardcodeado',
+    // SECRET_KEY="valor_largo_no_placeholder"  fuera de archivos .env.example
+    patron: /(?:SECRET_KEY|AUTH_TOKEN|ACCESS_TOKEN|PRIVATE_KEY|CLIENT_SECRET)\s*=\s*["'][^"'\s]{10,}["']/,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Lógica de exclusión (falsos positivos comunes)
+// ---------------------------------------------------------------------------
+
+/**
+ * Patrones que indican que el contenido es un archivo de ejemplo, test o
+ * documentación donde los secretos son ficticios.
+ * Si el file_path o el contenido coincide con alguno, se omite el bloqueo.
+ */
+const PATRONES_EXCLUSION_RUTA = [
+  /\.example$/i,
+  /\.sample$/i,
+  /\.test\.[jt]s$/i,
+  /\.spec\.[jt]s$/i,
+  /test[s]?[/\\]/i,
+  /__tests__[/\\]/i,
+  /fixtures?[/\\]/i,
+  /mocks?[/\\]/i,
+  /README/i,
+  /CHANGELOG/i,
+  /\.md$/i,
+];
+
+/**
+ * Cadenas que indican un valor ficticio o placeholder dentro del contenido.
+ * Si la línea que contiene el patrón también contiene alguna de estas cadenas,
+ * se considera falso positivo.
+ */
+const MARCADORES_PLACEHOLDER = [
+  'YOUR_',
+  'your_',
+  '<YOUR',
+  'PLACEHOLDER',
+  'placeholder',
+  'example.com',
+  'example_',
+  'fake_',
+  'dummy_',
+  'test_token',
+  'test_key',
+  'xxxxxxxx',
+  '# noqa',
+  '// nosec',
+  'pragma: allowlist secret',
+];
+
+// ---------------------------------------------------------------------------
+// Funciones auxiliares
+// ---------------------------------------------------------------------------
+
+/**
+ * Verifica si la ruta del archivo indica que el contenido es un ejemplo/test.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function esArchivoExcluido(filePath) {
+  return PATRONES_EXCLUSION_RUTA.some(p => p.test(filePath));
+}
+
+/**
+ * Verifica si la línea que contiene el match parece ser un placeholder.
+ * @param {string} linea
+ * @returns {boolean}
+ */
+function esPlaceholder(linea) {
+  return MARCADORES_PLACEHOLDER.some(m => linea.includes(m));
+}
+
+/**
+ * Extrae el contenido textual a escanear desde el payload del hook.
+ * Para Write: campo "content".
+ * Para Edit: campos "new_string" y "content".
+ *
+ * @param {string} toolName - Nombre de la herramienta ("Write" | "Edit").
+ * @param {object} toolInput - Parámetros de la herramienta.
+ * @returns {string} Contenido concatenado a escanear.
+ */
+function extraerContenido(toolName, toolInput) {
+  const partes = [];
+
+  if (toolName === 'Write') {
+    if (typeof toolInput.content === 'string') partes.push(toolInput.content);
+  } else if (toolName === 'Edit') {
+    // Solo escanear lo que se está insertando, no el texto que se reemplaza
+    if (typeof toolInput.new_string === 'string') partes.push(toolInput.new_string);
+    // Algunos editores pasan "content" como campo alternativo
+    if (typeof toolInput.content === 'string') partes.push(toolInput.content);
+  }
+
+  return partes.join('\n');
+}
+
+/**
+ * Escanea el contenido contra todos los patrones de secretos.
+ * Retorna la primera coincidencia encontrada, o null si el contenido es seguro.
+ *
+ * @param {string} contenido
+ * @param {string} filePath - Ruta del archivo destino (para contexto en mensajes).
+ * @returns {{ nombrePatron: string, linea: string, numeroLinea: number }|null}
+ */
+function escanear(contenido, filePath) {
+  if (!contenido) return null;
+
+  const lineas = contenido.split('\n');
+
+  for (let i = 0; i < lineas.length; i++) {
+    const linea = lineas[i];
+
+    // Saltar líneas comentadas con marcadores de exclusión explícitos
+    if (esPlaceholder(linea)) continue;
+
+    for (const { nombre, patron } of PATRONES_SECRETOS) {
+      if (patron.test(linea)) {
+        return {
+          nombrePatron: nombre,
+          // Ofuscar el valor real en el mensaje de error para no exponerlo en logs
+          linea: linea.replace(patron, (match) => {
+            const visible = match.slice(0, 8);
+            return `${visible}${'*'.repeat(Math.max(0, match.length - 8))}`;
+          }),
+          numeroLinea: i + 1,
+          filePath,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint principal
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+
+    const toolName  = String(data.tool_name  || data.tool?.name || '');
+    const toolInput = data.tool_input || data.tool?.input || {};
+    const filePath  = String(toolInput.file_path || toolInput.path || '');
+
+    // Este hook solo aplica a Write y Edit
+    if (!['Write', 'Edit'].includes(toolName)) {
+      process.exit(0);
+    }
+
+    // Si la ruta indica archivo de ejemplo/test, saltar escaneo
+    if (filePath && esArchivoExcluido(filePath)) {
+      process.exit(0);
+    }
+
+    // Extraer y escanear el contenido
+    const contenido = extraerContenido(toolName, toolInput);
+    const coincidencia = escanear(contenido, filePath);
+
+    if (coincidencia) {
+      // BLOQUEAR: emitir JSON de bloqueo en stdout
+      const razon = [
+        `Secreto detectado antes de escribir en disco.`,
+        ``,
+        `Tipo:     ${coincidencia.nombrePatron}`,
+        `Archivo:  ${coincidencia.filePath || '(desconocido)'}`,
+        `Línea:    ${coincidencia.numeroLinea}`,
+        `Contexto: ${coincidencia.linea.trim().slice(0, 120)}`,
+        ``,
+        `Acciones recomendadas:`,
+        `  1. Mover el secreto a una variable de entorno (.env, no commiteado).`,
+        `  2. Usar un gestor de secretos (Vault, AWS Secrets Manager, etc.).`,
+        `  3. Si es un valor ficticio, agregar un marcador como YOUR_TOKEN,`,
+        `     o una línea: # pragma: allowlist secret`,
+      ].join('\n');
+
+      process.stdout.write(JSON.stringify({ result: 'block', reason: razon }));
+      process.exit(2);
+    }
+
+    // Sin secretos detectados — permitir la escritura
+    process.exit(0);
+
+  } catch (err) {
+    // El hook nunca bloquea por errores internos propios
+    process.stderr.write(`[escaneo-secretos] Error interno: ${err.message}\n`);
+    process.exit(0);
+  }
+});