@saulwade/swl-ses 1.3.8 → 1.4.1

package/hooks/lib/security-net.js

@@ -0,0 +1,201 @@
+// Adaptado de temp/ultraship-main/tools/lib/security.mjs bajo MIT License
+// Fuente: Houseofmvps/ultraship (https://github.com/Houseofmvps/ultraship)
+'use strict';
+
+const { resolve } = require('path');
+
+// Tamaño máximo de archivo a leer en memoria (10 MB)
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+// Tamaño máximo de cuerpo de respuesta HTTP (5 MB)
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+
+// Rangos IP privados/internos que nunca deben recibir solicitudes
+const PRIVATE_IP_PATTERNS = [
+  /^127\./,                                                  // Loopback
+  /^10\./,                                                   // Clase A privada
+  /^172\.(1[6-9]|2\d|3[01])\./,                             // Clase B privada
+  /^192\.168\./,                                             // Clase C privada
+  /^169\.254\./,                                             // Link-local (AWS metadata!)
+  /^0\./,                                                    // Red actual
+  /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./,              // NAT de nivel operador
+  /^::1$/,                                                   // Loopback IPv6
+  /^fd[0-9a-f]{2}:/i,                                       // Local único IPv6
+  /^fe80:/i,                                                 // Link-local IPv6
+  /^fc[0-9a-f]{2}:/i,                                       // Local único IPv6
+];
+
+// Hostnames de metadatos cloud que siempre se bloquean
+const BLOCKED_HOSTNAMES = new Set([
+  'metadata.google.internal',
+  'metadata.google.com',
+]);
+
+/**
+ * Valida que una ruta de directorio sea segura: existe, es absoluta y sin trucos de traversal.
+ * Devuelve la ruta absoluta resuelta, o null si la entrada está vacía.
+ *
+ * @param {string} dir
+ * @returns {string|null}
+ */
+function validateDirPath(dir) {
+  if (!dir) return null;
+  const resolved = resolve(dir);
+  // Permitimos cualquier ruta absoluta; la protección real es que
+  // las herramientas solo LEEN dentro de ella.
+  return resolved;
+}
+
+/**
+ * Valida que una URL sea segura para solicitar.
+ * Solo permite HTTP/HTTPS, sin IPs privadas ni endpoints de metadatos.
+ *
+ * @param {string} urlString
+ * @returns {{ valid: true, url: URL } | { valid: false, reason: string }}
+ */
+function validateUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    return { valid: false, reason: `URL inválida: ${urlString}` };
+  }
+
+  // Solo HTTP y HTTPS
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return { valid: false, reason: `Esquema bloqueado "${parsed.protocol}" — solo se permiten http: y https:` };
+  }
+
+  // Bloquear hostnames de metadatos cloud
+  if (BLOCKED_HOSTNAMES.has(parsed.hostname.toLowerCase())) {
+    return { valid: false, reason: `Hostname bloqueado: ${parsed.hostname} (endpoint de metadatos cloud)` };
+  }
+
+  // Normalizar hostname — quitar corchetes IPv6 y expandir IPv6-mapped IPv4
+  let hostname = parsed.hostname;
+  if (hostname.startsWith('[') && hostname.endsWith(']')) {
+    hostname = hostname.slice(1, -1);
+  }
+
+  // Detectar IPv6-mapped IPv4 decimal (::ffff:x.x.x.x) y extraer la parte IPv4
+  const ipv6MappedMatch = hostname.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i);
+  if (ipv6MappedMatch) {
+    hostname = ipv6MappedMatch[1];
+  }
+
+  // Detectar IPv6-mapped IPv4 en hex (p.ej. ::ffff:7f00:1 = 127.0.0.1)
+  const ipv6MappedHexMatch = hostname.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (ipv6MappedHexMatch) {
+    const hi = parseInt(ipv6MappedHexMatch[1], 16);
+    const lo = parseInt(ipv6MappedHexMatch[2], 16);
+    hostname = `${(hi >> 8) & 0xff}.${hi & 0xff}.${(lo >> 8) & 0xff}.${lo & 0xff}`;
+  }
+
+  // Bloquear IPs privadas/internas
+  for (const pattern of PRIVATE_IP_PATTERNS) {
+    if (pattern.test(hostname)) {
+      return { valid: false, reason: `IP privada/interna bloqueada: ${parsed.hostname}` };
+    }
+  }
+
+  // Bloquear variantes de localhost que apunten a rutas de metadatos
+  if (
+    hostname === 'localhost' ||
+    hostname === '::1' ||
+    parsed.hostname === 'localhost' ||
+    parsed.hostname === '[::1]'
+  ) {
+    if (
+      parsed.pathname.startsWith('/latest/meta-data') ||
+      parsed.pathname.startsWith('/metadata') ||
+      parsed.pathname.startsWith('/computeMetadata')
+    ) {
+      return { valid: false, reason: 'Ruta de metadatos en localhost bloqueada' };
+    }
+  }
+
+  return { valid: true, url: parsed };
+}
+
+/**
+ * Verifica el tamaño de un archivo antes de leerlo.
+ * Recibe `statSync` como parámetro para facilitar testing sin I/O real.
+ *
+ * @param {string} filePath
+ * @param {function} statSync - función compatible con fs.statSync
+ * @returns {{ ok: boolean, size: number, reason?: string }}
+ */
+function checkFileSize(filePath, statSync) {
+  try {
+    const stat = statSync(filePath);
+    if (stat.size > MAX_FILE_SIZE) {
+      return {
+        ok: false,
+        size: stat.size,
+        reason: `Archivo demasiado grande (${Math.round(stat.size / 1024 / 1024)}MB > ${MAX_FILE_SIZE / 1024 / 1024}MB límite)`,
+      };
+    }
+    return { ok: true, size: stat.size };
+  } catch {
+    return { ok: false, size: -1, reason: 'Archivo no encontrado o no legible' };
+  }
+}
+
+/**
+ * Crea un acumulador de respuesta HTTP con límite de tamaño.
+ * Útil para evitar OOM al leer respuestas grandes de streaming.
+ *
+ * @param {number} [maxSize]
+ * @returns {{ onData: function, getBody: function, isTruncated: function, getTotalSize: function }}
+ */
+function createResponseAccumulator(maxSize) {
+  if (maxSize === undefined) maxSize = MAX_RESPONSE_SIZE;
+  let body = '';
+  let totalSize = 0;
+  let truncated = false;
+
+  return {
+    onData(chunk) {
+      totalSize += chunk.length;
+      if (!truncated && totalSize <= maxSize) {
+        body += chunk;
+      } else {
+        truncated = true;
+      }
+    },
+    getBody() { return body; },
+    isTruncated() { return truncated; },
+    getTotalSize() { return totalSize; },
+  };
+}
+
+/**
+ * Redacta un valor si la clave indica que contiene información sensible.
+ * Preserva los primeros 4 caracteres del valor para depuración mínima.
+ *
+ * @param {string} key   - nombre de la clave (p.ej. "Authorization", "api_key")
+ * @param {string} value - valor a evaluar
+ * @returns {string}
+ */
+function redactSensitiveValue(key, value) {
+  if (!value || typeof value !== 'string') return value;
+  const k = key.toLowerCase();
+  const sensitiveKeys = ['password', 'secret', 'token', 'key', 'credential', 'auth', 'api_key', 'apikey', 'private'];
+  if (sensitiveKeys.some(s => k.includes(s))) {
+    if (value.length > 4) {
+      return value.slice(0, 4) + '***REDACTED***';
+    }
+    return '***REDACTED***';
+  }
+  return value;
+}
+
+module.exports = {
+  MAX_FILE_SIZE,
+  MAX_RESPONSE_SIZE,
+  validateDirPath,
+  validateUrl,
+  checkFileSize,
+  createResponseAccumulator,
+  redactSensitiveValue,
+};