Alta

NLTK: Denegación de servicio en tiempo de compilación de regex en funciones de búsqueda/tokenización

  • Publicada: 19.11.2026
  • Actualizado: 22.11.2026 10:00

Resumen

NLTK presenta una denegación de servicio por expresiones regulares (ReDoS) en tiempo de compilación dentro de sus funciones de búsqueda. Cuando una aplicación envía texto no confiable como patrón de búsqueda a TokenSearcher.findall() / Text.findall(), o como patrón de tokenización a RegexpTokenizer, el patrón se traslada al motor de terceros regex. El costo de compilación de este motor es aproximadamente cuadrático respecto a la cantidad de grupos de captura. Un patrón breve con la estructura () repetida numerosas veces (por ejemplo "()" * 25000, de unos 50 KB) fuerza decenas de segundos de procesamiento de CPU síncrono antes de que comience cualquier coincidencia. El tiempo límite de reloj establecido por NLTK solo protege la fase de coincidencia y no se aplica durante la compilación, por lo que una única petición pequeña puede acaparar un núcleo de CPU, y peticiones repetidas o concurrentes pueden agotar los recursos del sistema.

Causa raíz

La mitigación del problema de retroceso durante la coincidencia (aviso GHSA-rrv8-h7p8-rx55 / CVE-2026-80205) cambió la ruta de búsqueda de patrones suministrados por el llamador desde el módulo re de la biblioteca estándar al motor regex, envolviendo la búsqueda en un tiempo límite de reloj. Sin embargo, ese límite opera exclusivamente durante la fase de coincidencia. La compilación previa ocurre de forma síncrona y sin control de tiempo. El compilador de regex presenta una complejidad de cerca de O(n^2) según el número de grupos, de modo que un patrón con múltiples grupos vacíos hace que la compilación sea la fase crítica. No existe control previo sobre la cantidad de grupos antes de compilar.

Affected components / functions:
- nltk.text.TokenSearcher.findall  (nltk/text.py)  -> regex.findall(pattern, corpus, timeout=...)
    On released 3.10.0-3.10.2 this sink calls regex.findall directly; on 3.10.3 and later it
    routes through nltk.redos.compile. Either way the regex engine compiles the caller pattern
    with no group-count bound, and the timeout guards only matching.
- nltk.redos.compile  (nltk/redos.py, introduced in 3.10.3)  -> regex.compile(src, flags)
    Called synchronously before the timeout-bearing wrapper exists. On released 3.10.3 there is
    no pre-compile guard at all; on the current development tree a check_pattern bounds source
    length, nesting depth, and counted-repeat product, but not the number of groups.

Impacto

Un atacante no autenticado capaz de intervenir en una cadena de expresión regular procesada por los puntos de entrada de búsqueda o tokenización de NLTK puede forzar un consumo masivo de CPU. Una sola petición con un patrón de aproximadamente 50 KB compuesto por grupos vacíos bloquea un worker durante decenas de segundos. Debido a la complejidad cuadrática y la ausencia de límites de longitud en 3.10.3, múltiples peticiones concurrentes pueden agotar los núcleos disponibles e interrumpir el servicio legítimo. No hay impacto en la confidencialidad ni en la integridad, y el servicio vuelve a la normalidad una vez finalizada la compilación o cancelado el worker.

Prueba de concepto

Requires the nltk package (3.10.0 through 3.10.3) and its declared regex dependency. No corpus data or network access is needed.

  1. Construir un patrón con múltiples grupos de captura vacíos.
  2. Enviarlo a un punto receptor de patrones y medir el tiempo transcurrido antes de la búsqueda.
  3. Verificar que el tiempo límite de coincidencia no se activa, pues el consumo ocurre en la compilación.
python
import time, regex

# Exact released 3.10.0-3.10.2 code path of TokenSearcher.findall:
#   regex.findall(pattern, corpus, timeout=<wall-clock match limit>)
pattern = "()" * 25000            # ~50 KB, 25000 capturing groups; survives the "<>." rewrites
start = time.perf_counter()
try:
    regex.findall(pattern, "<hello><world><foo>", timeout=1.0)
    print(f"completed in {time.perf_counter()-start:.2f}s with NO TimeoutError")
except TimeoutError:
    print(f"TimeoutError after {time.perf_counter()-start:.2f}s")

# Negative control: same length, zero groups, compiles in well under a second.
start = time.perf_counter()
regex.findall("a" * 50000, "<hello>", timeout=1.0)
print(f"control (0 groups) completed in {time.perf_counter()-start:.2f}s")
completed in 4.24s with NO TimeoutError
control (0 groups) completed in 0.16s

Otras mediciones en el mismo entorno mostraron que regex.compile("()" * n) escaló a 0.35s / 1.17s / 2.61s / 4.77s para n = 5000 / 10000 / 15000 / 20000 (crecimiento cuadrático evidente); re.compile("()" * 20000) de la biblioteca estándar tomó 0.14s, confirmando que el costo corresponde al motor regex y a la densidad de grupos. Mediante el tokenizador, RegexpTokenizer("()" * 20000).tokenize("hello world") se bloqueó unos 5.1s exclusivamente en la etapa de compilación sin TimeoutError.

Cadena de ataque

  1. Exposición: Una aplicación expone búsquedas o tokenización mediante regex en NLTK a la entrada del usuario, por ejemplo a través de Text.findall() / TokenSearcher.findall() o un RegexpTokenizer con patrón configurable.
  2. Control: El atacante suministra la cadena () repetida n veces. Al no contener espacios, <, > ni ., supera las cuatro reescrituras de TokenSearcher.findall (nltk/text.py) de manera intacta y llega a RegexpTokenizer.
  3. Ruta: El patrón alcanza el punto de compilación: regex.findall(pattern, corpus, timeout=...) en 3.10.0 mediante 3.10.2, o nltk.redos.compile a regex.compile en 3.10.3 y el flujo del tokenizador.
  4. Protección: El límite de tiempo de reloj solo se aplica después de la compilación. En la versión publicada 3.10.3 no hay validación previa; en la rama de desarrollo se valida longitud, anidación y repeticiones, pero no el recuento de grupos.
  5. Primitiva: Compilación síncrona e ininterrumpible de expresiones regulares cuyo costo es cuadrático respecto a la cantidad de grupos.
  6. Resultado: Una pequeña solicitud consume decenas de segundos de CPU en un núcleo; solicitudes simultáneas bloquean todos los núcleos y causan denegación de servicio.

Evidencia de evasión

Este hallazgo evidencia una corrección previa incompleta. El aviso anterior de referencia es GHSA-rrv8-h7p8-rx55 / CVE-2026-80205, centrado en el retroceso catastrófico en Text.findall(), el cual adoptó el motor regex y añadió un tiempo límite al cotejo. La nueva evidencia demuestra que la compilación previa no queda cubierta por este límite.

Pruebas efectuadas:

  • Intervención por tiempo límite: regex.findall("()" * 20000, corpus, timeout=1.0) tardó cerca de 4.3s sin TimeoutError, y RegexpTokenizer("()" * 20000).tokenize(...) retuvo la ejecución 5.1s sin TimeoutError. El límite de coincidencia no actúa en la compilación.
  • Control previo (rama de desarrollo): con (), el contador de anidación oscila entre 0 y 1; el límite de longitud sigue admitiendo cerca de 50000 grupos. La validación admite "()" * 49000 al no computar los grupos.
  • Caché de compilación: la caché interna solo gestiona cadenas cortas y los puntos afectados compilan directamente; valores distintos de n generan compilaciones nuevas sin caché.
  • Duplicados: otros avisos abordan retrocesos en la coincidencia o recursión del analizador sintáctico, no el comportamiento del compilador.
  • Controles negativos: un patrón sin grupos y el compilador estándar re mostraron bajo coste, aislando la causa al motor regex y su gestión de grupos.

Versiones afectadas

  • Ecosystem: pip (PyPI)
  • Package: nltk
  • Confirmed affected range: >= 3.10.0, <= 3.10.3
  • Latest release checked: 3.10.3 (PyPI, latest published)
  • Fix status: not fixed

El vector se introdujo en la versión 3.10.0 tras adoptar el motor regex. La versión 3.9.4 y anteriores utilizaban re para TokenSearcher.findall (compilación lineal, sin este vector: re.findall). Entre 3.10.0 y 3.10.2, TokenSearcher.findall llama de forma directa a regex.findall(pattern, corpus, timeout=...), reproduciendo la denegación de servicio (confirmado en el paquete fuente de 3.10.0). La versión 3.10.3 introdujo además nltk/redos.py y canalizó RegexpTokenizer a través de él. El módulo publicado 3.10.3 carece de validación previa o tope de longitud. 3.10.3 es la versión más reciente publicada; no existe versión oficial corregida y la rama de desarrollo sigue expuesta.

Corrección sugerida

Restringir la complejidad del patrón antes de compilar, no únicamente durante la coincidencia. Se debe limitar la cantidad de grupos (y estructuras complejas de compilación) antes de remitir el patrón a regex, rechazando entradas excesivas antes de invocar regex.compile / regex.findall. La validación debe actuar en un punto central que cubra TokenSearcher.findall / Text.findall, RegexpTokenizer y demás componentes de tokenización, etiquetado, lematización y segmentación.

Reportado por zx (GitHub: @manus-pi).

Estado de la solución (2026-09-28)

Estado: EN PROGRESO (solución en pull request abierto, no integrado en develop).

PR: #3895 "[WIP] Bound algorithmic-DoS and uncontrolled-recursion vectors (CWE-400/407/674/1333)", abierto, rama head b22ebe144.

Commit de corrección: 002bcf714 (redos.check_pattern rechaza patrones con más de MAX_GROUP_COUNT=1000 grupos de captura antes del compilador; todos los patrones pasan por redos.compile).

Reevaluación de PoC (RegexpTokenizer("()" * 20000).tokenize("hello world")): en el head del PR genera ValueError en menos de 0.01 s ("regex opens more than 1000 capturing groups; refusing to compile"); en develop 2fa3f48fe compiló y ejecutó durante 19.7 s sin bloqueo preventivo, por lo que develop continúa siendo VULNERABLE.

Publicación: ninguna.

Qué hacer

Aún no se ha publicado una versión corregida oficial (la solución se encuentra en curso mediante la solicitud de extracción #3895). Como mitigación provisional, las aplicaciones que expongan las API afectadas a datos no confiables deben validar y rechazar patrones excesivamente largos o con alta densidad de grupos, además de ejecutar las operaciones de NLTK en workers restringidos con un límite de tiempo de CPU.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) nltk >= 3.10.0, < 3.10.4 3.10.4

Referencias

Puntuación CVSS 7.5/10
Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Debilidad (CWE)
CWE-1333, CWE-400
Plataforma
Python (PyPI)
Paquete
nltk
Publicada
19.11.2026
Actualizado
22.11.2026 10:00

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

OSV / GitHub Advisory Database - GHSA-32p6-cwhc-8r78 - CC BY 4.0

Historial de vulnerabilidades: nltk

Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Todas (79) en el archivo
Entradas en total
79
Primera → última
08.2019 11.2026
Sin corrección
5
Explotada en ataques
0

Distribución por gravedad

  • Crítica 5
  • Alta 41
  • Media 31
  • Baja 2

Divulgaciones por año

  1. 2019: 1
  2. 2020: 0
  3. 2021: 2
  4. 2022: 1
  5. 2023: 0
  6. 2024: 1
  7. 2025: 0
  8. 2026: 74
Gravedad:
  1. NLTK: Denegación de servicio en tiempo de compilación de regex en funciones de búsqueda/tokenización esta entrada
    Alta · 7.5 CVE-2026-129229 >= 3.10.0, < 3.10.4 3.10.4
  2. Alta CVE-2026-79674 < 3.10.3 3.10.3
  3. Alta · 8.8 CVE-2026-71513 >= 3.10.0, < 3.10.3 3.10.3
  4. Alta · 5.9 CVE-2026-62385 < 3.10.0 3.10.0
  5. Alta · 7.5 CVE-2026-33231 < 3.9.4 3.9.4
  6. Alta · 8.6 CVE-2026-0847 < 3.9.3 3.9.3
  7. Crítica · 10.0 CVE-2025-14009 < 3.9.3 3.9.3
  8. Alta · 7.5 CVE-2024-39705 < 3.9 3.9
  9. Alta · 7.5 CVE-2021-3842 < 3.6.6 3.6.6
  10. Alta · 7.5 CVE-2021-3828 < 3.6.4 3.6.4
  11. Alta · 7.5 CVE-2019-14751 < 3.4.5 3.4.5

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.