← Volver al blog
ReDoSExpresiones RegularesNode.jsNext.jsDoSOWASPSeguridad de APIRE2

ReDoS en Node.js y Next.js: retroceso catastrófico, bloqueo del event loop y patrones enviados por el usuario [2026]

ReDoS es una caída del servicio del tamaño de un paquete

Casi todos los ataques de denegación de servicio necesitan volumen: una botnet, una avalancha de conexiones, algo que le cueste dinero al atacante. ReDoS (denegación de servicio por expresión regular, Regular Expression Denial of Service) necesita una sola petición HTTP con una cadena de 40 caracteres. Si esa cadena llega a un patrón vulnerable — y el patrón muchas veces lo escribió tu propio equipo, años antes, como una "validación sencilla" — el proceso Node.js deja de servir nada. No deja de servir esa petición: deja de servir todas, en todas las rutas, porque la evaluación de la regex es JavaScript síncrono en el mismo hilo único que tu handler HTTP.

No hay ningún await que te salve. AbortSignal no entra dentro de RegExp.prototype.test. Un timeout alrededor de la llamada no se dispara hasta que la llamada retorna. Tu health check expira, tu orquestador reinicia el contenedor, el atacante manda la misma petición otra vez y te quedas con un bucle de caídas y un postmortem de cinco líneas que dice "el pod estaba unhealthy".

Esta es una de las pocas clases de vulnerabilidad donde la corrección es arquitectónica y no un parche: decides quién tiene permiso para expresar un patrón y dónde tiene permiso para ejecutarse.

Cómo V8 retrocede hasta una explosión de 2^n

Los motores de expresiones regulares de JavaScript (V8 incluido) son motores de retroceso (backtracking). Con un patrón que tiene alternancia o cuantificadores anidados, el motor prueba un camino, falla y rebobina para probar el siguiente. Eso está bien cuando el número de caminos es lineal respecto a la longitud de la entrada. Es catastrófico cuando el número de caminos es exponencial.

El caso canónico:

js
// demo/redos.mjs — run with: node demo/redos.mjs
const evil = /^(a+)+$/;

for (const n of [16, 20, 22, 24, 26, 28]) {
  const input = "a".repeat(n) + "!"; // one character that can never match
  const t0 = process.hrtime.bigint();
  evil.test(input);
  const ms = Number(process.hrtime.bigint() - t0) / 1e6;
  console.log(`n=${n} -> ${ms.toFixed(2)} ms`);
}

Salida típica en un portátil moderno:

text
n=16 -> 0.35 ms
n=20 -> 4.10 ms
n=22 -> 15.80 ms
n=24 -> 62.40 ms
n=26 -> 249.10 ms
n=28 -> 998.70 ms

Cada dos caracteres adicionales multiplican el trabajo por cuatro. Con n=40 hablamos de horas. La construcción (a+)+ es la señal: el + exterior y el + interior pueden repartir la misma tirada de caracteres a de un número exponencial de maneras, y como el ! final garantiza el fallo global, el motor tiene que agotar todas ellas antes de responder "no hay coincidencia".

Fíjate en lo que importa aquí: el fallo se produce con entrada que no coincide. Al atacante no le hace falta satisfacer tu patrón, le basta con obligar al motor a explorar. Eso también significa que una regla de WAF que bloquee payloads evidentes no ayuda gran cosa: el haystack son solo letras repetidas.

Las cinco formas que estallan

| Forma | Ejemplo | Por qué explota | |---|---|---| | Cuantificadores anidados | ^(a+)+$ | Los mismos caracteres se pueden particionar de un número exponencial de maneras | | Alternancia solapada | ^(a\|aa)+$ | Ambas ramas consumen a, así que cada posición bifurca | | Grupo cuantificado con cola ambigua | ^(\w+\s?)*$ | \s? permite al motor repartir de nuevo los límites de palabra en cada paso | | Comodines ilimitados adyacentes | ^.*.*=.*$ | Cada .* puede absorber el resto, generando un número de caminos casi factorial | | Cuantificador anidado dentro de un lookaround | ^(?=(a+)+$) | Los lookarounds también retroceden; el coste queda oculto para quien llama |

Hay otras dos que aparecen en código real y son fáciles de pasar por alto:

  • Patrones sin anclar sobre entrada larga. /(\w+\s?)+$/ sin ^ obliga al motor a reintentar todo el asunto desde cada posición de inicio.
  • Clases Unicode con case-insensitive. /^\p{L}+$/iu sobre cadenas largas con marcas combinantes es mucho más lento de lo que la gente espera; la expansión de la clase de caracteres es enorme.

Entre los CVE reales de esta clase están CVE-2024-27982 (parseo de cabeceras en undici), CVE-2022-36067 (el sandbox vm2), CVE-2021-23341 en prismjs y una cola larga de avisos en semver, ansi-regex, trim y nth-check: todos eran alcanzables desde un npm install normal y, a menudo, desde una simple cadena en el cuerpo de una petición. Tu árbol de dependencias envía perdición; tu propio código también puede enviarla.

De dónde saca realmente un atacante el patrón

Enviar un payload de ReDoS es trivial. La pregunta interesante es por qué tu aplicación permite que una cadena se convierta en regex. Los puntos de entrada habituales:

  1. "Búsqueda avanzada" con un interruptor de regex. Alguien publicó la función potente y nadie se preguntó si el tenant debía tenerla.
  2. Filtros guardados y reglas de alerta. Un patrón guardado en la base de datos se compila en cada lectura: el punto de inyección es la UI de administración, y el disparador es cualquier petición posterior que le meta un valor largo.
  3. Validación configurada por el tenant. La validación de campos personalizados ("debe cumplir este formato") en un producto multi-tenant es, por definición, una regex no confiable.
  4. Enrutado, redacción y tablas de reglas. Filtros de webhooks, reglas de limpieza de logs, reescrituras de URL: todo guiado por patrones y todo editable por alguien que no es experto en regex.
  5. Código generado por un LLM. Un modelo que devuelve new RegExp(userInput) porque el prompt decía "hazlo flexible", y que además compila.
  6. Parámetros de consulta pasados directamente a RegExp. El clásico:
ts
// app/api/search/route.ts — VULNERABLE, do not ship
import { NextRequest, NextResponse } from "next/server";

const cache = new Map<string, RegExp>();

export async function GET(req: NextRequest) {
  const pattern = req.nextUrl.searchParams.get("pattern") ?? "";
  if (!cache.has(pattern)) cache.set(pattern, new RegExp(pattern, "i"));
  const rx = cache.get(pattern)!;

  const rows = await db.product.findMany({ select: { id: true, name: true } });
  return NextResponse.json(rows.filter((row) => rx.test(row.name)));
}

Esto tiene dos bugs con el mismo abrigo. El primero es ReDoS: ?pattern=%5E(a%2B)%2B%24 es un patrón válido, y cada uno de los nombres de tus productos se convierte en una sonda exponencial potencial. El segundo es una caché sin límite con clave controlada por el atacante: una fuga de memoria lenta que termina en un reinicio por OOM. Hay un tercero, más sutil: las filas se traen completas y se filtran en memoria, así que el trabajo peligroso ocurre después de haber pagado ya el viaje a la base de datos.

Confírmalo con tiempos, no con intuición:

bash
# 30 a's + "!" against a product name of the same shape
time curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" \
  "http://localhost:3000/api/search?pattern=%5E(a%2B)%2B%24"

Si el tiempo de respuesta sube con la longitud del nombre guardado, lo tienes. Si quieres demostrarlo en un test unitario sin colgar el CI, ejecuta el patrón en un worker con un presupuesto de tiempo duro.

Detéctalo antes de que lo haga producción

Primero la instrumentación: no puedes arreglar lo que no ves. El lag del event loop es la señal de que una regex síncrona se está comiendo el proceso:

js
// instrumentation.mjs — import once at boot (or from instrumentation.ts in Next.js)
import { monitorEventLoopDelay } from "node:perf_hooks";

const histogram = monitorEventLoopDelay({ resolution: 10 });
histogram.enable();

setInterval(() => {
  const p99 = histogram.percentile(99) / 1e6;
  const max = histogram.max / 1e6;
  if (p99 > 100) {
    console.warn(`event_loop_lag p99=${p99.toFixed(1)}ms max=${max.toFixed(1)}ms`);
  }
  histogram.reset();
}, 5_000).unref();

Segundo, una sonda que rechace un patrón incapaz de terminar dentro de un presupuesto fijo. Es la única forma segura de probar un patrón no confiable, porque el worker se puede terminar:

js
// scripts/regex-budget.mjs — compile a pattern under a hard time budget
import { Worker } from "node:worker_threads";

const PROBE = `
  const { parentPort, workerData } = require("node:worker_threads");
  const rx = new RegExp(workerData.pattern, workerData.flags);
  const t0 = process.hrtime.bigint();
  const ok = rx.test(workerData.haystack);
  parentPort.postMessage({ ok, ms: Number(process.hrtime.bigint() - t0) / 1e6 });
`;

export function probePattern(pattern, flags = "", budgetMs = 50) {
  return new Promise((resolve) => {
    // adversarial haystack: repeated chars + a guaranteed mismatch at the end
    const haystack = "a".repeat(64) + "!";
    const worker = new Worker(PROBE, { eval: true, workerData: { pattern, flags, haystack } });
    const timer = setTimeout(() => {
      worker.terminate();
      resolve({ ok: false, timedOut: true, budgetMs });
    }, budgetMs);
    worker.once("message", (result) => {
      clearTimeout(timer);
      worker.terminate();
      resolve({ ...result, timedOut: false });
    });
    worker.once("error", (error) => {
      clearTimeout(timer);
      resolve({ ok: false, error: error.message });
    });
  });
}

Ejecútala en un test unitario sobre todos los patrones que tus usuarios pueden guardar. { ok: false, timedOut: true } es un patrón rechazado, no un patrón lento, y worker.terminate() es la única primitiva de cancelación que realmente tienes.

Capa 1: elimina el lenguaje de patrones

La mejor corrección de ReDoS no es un motor más seguro, es no aceptar regex. Casi toda "búsqueda avanzada" necesita cuatro operaciones. Enumérelas y la clase de vulnerabilidad desaparece:

ts
// lib/filters.ts — the whole filter language, no regex anywhere
export type Filter =
  | { kind: "contains"; value: string }
  | { kind: "startsWith"; value: string }
  | { kind: "equals"; value: string }
  | { kind: "oneOf"; values: string[] };

const MAX_VALUE = 120;

export function parseFilter(input: unknown): Filter {
  // validate shape with zod/valibot in real code, then:
  const f = input as Filter;
  if (f.kind === "oneOf") {
    if (f.values.length > 20) throw new Error("too many values");
    return { kind: "oneOf", values: f.values.map((v) => v.slice(0, MAX_VALUE)) };
  }
  return { kind: f.kind, value: f.value.slice(0, MAX_VALUE) };
}

Si tienes que expresarlo en SQL, escapa los metacaracteres de LIKE para que un % enviado por el usuario no convierta un filtro de prefijo en un escaneo completo de la tabla:

ts
// Escape LIKE wildcards before interpolation into a parameterized query
const escaped = value.replace(/[\\%_]/g, (ch) => `\\${ch}`);
await db.$queryRaw`SELECT id, name FROM "Product" WHERE name ILIKE ${escaped + "%"}`;

Ese replace es en sí mismo una regex: una segura, fija, acotada y escrita por ti. Esa es la distinción que importa en todo el artículo: los patrones del código fuente son auditables; los patrones de los usuarios no.

Capa 2: RE2 para los patrones que de verdad necesitas

A veces los usuarios sí necesitan expresiones: parsers de logs, reglas de redacción, pipelines de datos. En ese caso, cambia el motor. RE2 es un motor de tiempo lineal: renuncia a las retroreferencias (backreferences) y a los lookarounds, que es exactamente el intercambio que quieres, porque esas características son el origen del retroceso superlineal.

bash
npm install re2
ts
// lib/untrusted-regex.ts — untrusted pattern, linear-time engine
import RE2 from "re2";

const MAX_PATTERN = 200;

export function compileUntrusted(pattern: string, flags = "i"): RE2 {
  if (pattern.length > MAX_PATTERN) {
    throw new Error("pattern exceeds length limit");
  }
  try {
    // RE2 throws on backreferences and lookarounds — that is the point
    return new RE2(pattern, flags);
  } catch {
    throw new Error("pattern uses unsupported constructs");
  }
}

Dos advertencias que conviene conocer antes de publicarlo:

  • re2 es un addon nativo. Tiene binarios precompilados para plataformas comunes, pero Alpine/musl, ARM y versiones de Node poco habituales pueden disparar una compilación desde fuentes. Prueba tu imagen de despliegue y mantén una ruta de respaldo si require("re2") falla.
  • Rechazar retroreferencias y lookarounds cambiará el comportamiento para los tenants que se apoyaban en ellas. Eso es una decisión de producto, no un bug: muestra un error de validación claro en lugar de devolver coincidencias incorrectas en silencio.

Node también incluye un motor lineal experimental en V8. Es útil como red de seguridad más que como defensa principal:

bash
# Fall back to the non-backtracking engine after N backtracks (V8 flags, experimental)
node --enable-experimental-regexp-engine-on-excessive-backtracks \
     --regexp-backtrack-limit=1000 server.js

Los flags son experimentales y sus nombres han cambiado entre versiones de V8, así que fíjalos en tu Dockerfile con un comentario y verifica el comportamiento en un test que, sin ellos, se colgaría.

Capa 3: acota todo y después pasa el linter

Incluso con RE2, los límites duros hacen predecible el radio de daño:

ts
// Bound the haystack, not just the pattern
const MAX_HAYSTACK = 4_096;

export function safeTest(rx: RE2, value: string): boolean {
  const haystack = value.length > MAX_HAYSTACK ? value.slice(0, MAX_HAYSTACK) : value;
  return rx.test(haystack);
}

Y pasa el linter sobre los patrones que escribiste tú, porque tu propio código es la fuente más habitual:

js
// eslint.config.mjs — catch super-linear backtracking at review time
import regexp from "eslint-plugin-regexp";

export default [
  regexp.configs["flat/recommended"],
  {
    rules: {
      "regexp/no-super-linear-backtracking": "error",
      "regexp/no-useless-quantifier": "warn",
      "regexp/prefer-lookaround": "off",
    },
  },
];

Para los patrones que ya están guardados en la base de datos (filtros guardados, reglas de alerta, validación de tenants), audítalos fuera de línea con un comprobador de ReDoS en lugar de adivinar:

bash
# recheck reports ambiguity and exponential worst cases
npx recheck '^(\w+\s?)*$'

# or scan a JSON export of stored patterns, one per line
jq -r '.patterns[]' exports/tenant-patterns.json | while read -r p; do
  npx recheck --json "$p" | jq -r '.source + " -> " + (.complexity | tostring)'
done

Capa 4: limita la tasa y aísla lo que se escape

Ninguna capa anterior es perfecta, así que asume que un patrón sobrevive. Ponle techo al daño:

  • Límite de tasa por tenant al enviar patrones y al ejecutarlos. Un tenant que lanza 2.000 filtros guardados por minuto o está roto o es hostil; ambos merecen un 429.
  • Ejecuta la evaluación no confiable en un pool de workers dedicado con resourceLimits, y termínalo al agotar el presupuesto. Mantenlo fuera del hilo HTTP principal para que un solo patrón desbocado no detenga los health checks.
  • Limita las evaluaciones concurrentes por proceso. Veinte workers quemando CPU es la misma caída con un diagrama de arquitectura más bonito.
  • Alerta sobre el p99 y el max del event loop. Un pico aislado es una señal; ignóralo y el siguiente llegará en forma de reinicio.
  • Registra el patrón y el tenant en cada timeout. Necesitas saber qué regla guardada es la bomba antes de que la encuentre la siguiente petición.

La checklist de arranque

  • [ ] Ninguna ruta pasa req.query, un campo del cuerpo de la petición o un valor de base de datos a new RegExp(...).
  • [ ] La "búsqueda avanzada" expone filtros enumerados (contains, startsWith, equals, oneOf), no una caja de patrón.
  • [ ] Si los patrones son un requisito real, se compilan con RE2, nunca con el motor de retroceso de V8.
  • [ ] La longitud del patrón está acotada (200 caracteres o menos) y el haystack también (4.096 caracteres o menos) antes de cualquier test.
  • [ ] Todo patrón no confiable se ejecuta dentro de un worker con presupuesto de tiempo duro y terminate() al desbordarse.
  • [ ] eslint-plugin-regexp con regexp/no-super-linear-backtracking está activo en CI y el build falla si hay violaciones.
  • [ ] Los patrones guardados (filtros, reglas de alerta, validadores de tenants) se auditaron fuera de línea con recheck o redos-detector.
  • [ ] Cualquier caché de regex está acotada y usa un hash como clave, no una cadena ilimitada del atacante.
  • [ ] Existen límites de tasa al enviar patrones y al ejecutarlos, por tenant.
  • [ ] El lag del event loop (p99 y max) se exporta a tu backend de métricas con una alerta asociada.
  • [ ] Un test unitario afirma que un patrón malicioso conocido se rechaza o expira, para que un refactor futuro no pueda quitar la protección en silencio.
  • [ ] Los flags de Node/V8 y los addons nativos (re2) están fijados y verificados en la imagen exacta que despliegas.

Qué hacer esta semana

Primero el grep: grep -rn "new RegExp(" src/ app/ pages/ lib/ y grep -rn "\.test(" src/ | grep -v "test(" te muestran la mayor parte de la superficie de ataque en diez minutos. Clasifica cada coincidencia como "patrón fijo escrito por nosotros" (pásale el linter) o "patrón que viene de fuera" (RE2, o elimina la función). Después coge los diez patrones guardados más caros de producción y pásalos por recheck: normalmente encuentras al menos uno que un cliente creó sin querer. Por último, integra la sonda de presupuesto en workers en tu suite de tests para cada endpoint que acepta un filtro. ReDoS no se detiene con buenas intenciones; se detiene con el hecho de que el código físicamente no puede ejecutar un patrón sin fecha límite.

¿Quieres que alguien que ataca APIs a diario revise tus endpoints de filtros, tus patrones guardados y el margen de tu event loop? Agenda una auditoría de seguridad y probaremos a colgar tu proceso con una cadena, para luego enseñarte exactamente qué línea lo permitió.

La próxima semana: seguridad de URLs prefirmadas en almacenamiento de objetos compatible con S3 — alcance, expiración, confinamiento de content-type y el bug de confusión de confianza (confused deputy) que convierte un bucket seguro en uno público.

Comparte este artículo:TwitterLinkedIn
JS

JS Security Audit

Auditorías dirigidas por un ingeniero de seguridad JavaScript senior con más de 10 años de experiencia.