llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · pymdown-extensions

GHSA-MW73-8637-G65G

pymdownx.keys: ReDoS exponencial en las ramas de claves entre comillas de RE_EARLY_KBD

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.5
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -77 d de la divulgación
Exposición13 dDesde la divulgación, 7 nov 2026, 11:09 a. m.
Detección11 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Revisa tus logs de la semana con la lupa.Hoy es tranquila, pero podría madrugarte.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 11.0.2
Monitoreo
Detectada +1
22 ago 26
7 nov 26
18 nov 26
21 nov 26
22 ago 26
14 sept 26
7 oct 26
29 oct 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 11.0.2 pymdown-extensions · -77 d desde divulgación
Divulgación Publicada GHSA-MW73-8637-G65G divulgada · CVSS 7.5 (GitHub)
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub

Resumen

`pymdownx/keys.py` construye `RE_EARLY_KBD` con una alternancia ambigua en ambas ramas de claves entre comillas. Una secuencia de barras invertidas dentro de una clave entre comillas tiene una cantidad de descomposiciones válidas que crece como la sucesión de Fibonacci, así que cuando la coincidencia que la rodea no puede completarse, el motor de expresiones regulares explora todas ellas. Un documento de 42 bytes tarda ~36 segundos de CPU de un solo núcleo en renderizarse; 44 bytes tardan ~91 segundos. El crecimiento es de ~2.7× por cada dos bytes añadidos.

Esta es la misma clase de error que los cuatro patrones corregidos en 11.0.1 mediante `c68498598d7b13011bb4571350b6e3612a4ce44b` ("Fix regex pattern inefficiencies: BetterEm, Tilde, Caret, and MagicLink"). Ese commit no tocó `keys.py`, que contiene el mismo idioma en otra forma, por lo que 11.0.1 sigue afectada.

Componente afectado

`pymdownx/keys.py`, líneas 101–102, dentro de `RE_EARLY_KBD` (la construcción aparece dos veces: una vez en la repetición perezosa y otra en la alternativa final obligatoria):

(?:(?:[\\w\\-]+|"(?:\\\\.|[^"])+"|\\'(?:\\\\.|[^\\'])+\\')\\+)*?

Ambas alternativas entre comillas están afectadas: `"(?:\\\\.|[^"])+"` y `'(?:\\\\.|[^'])+'`.

Esta línea no ha cambiado desde `6bc3eb92a` (2017-04-16, "Add Keys extension"), por lo que todas las versiones que incluyen la extensión Keys están afectadas, incluida la actual 11.0.1.

Alcanzabilidad: `RE_EARLY_KBD` se registra incondicionalmente en `KeysExtension.extendMarkdown()` (`keys.py:233`) siempre que `pymdownx.keys` esté habilitada. Ninguna opción de configuración lo controla. Cualquier despliegue que renderice Markdown no confiable con la extensión Keys habilitada es alcanzable. Probablemente tenga una idea mejor que yo de qué tan común es esto en la práctica.

Detalles

La alternancia interna es ambigua porque las dos ramas pueden consumir la misma entrada de maneras distintas:

  • `\\\\.` coincide con una barra invertida seguida de cualquier carácter: dos caracteres
  • `[^"]` coincide con cualquier carácter que no sea comilla doble, incluida la barra invertida: un carácter

Así, una secuencia de N barras invertidas puede dividirse en pares `\\\\.`, en pasos individuales `[^"]` o en cualquier mezcla de ambos. El número de divisiones de una secuencia de longitud N usando piezas de tamaño 1 y 2 es Fibonacci(N+1), es decir, ~1.62^N. Mientras la coincidencia finalmente falle, el motor debe probarlas todas antes de rendirse.

La carga útil fuerza exactamente esa situación: `++"` entra en la rama entre comillas, la secuencia de barras invertidas crea la ambigüedad, y un carácter final que no es comilla garantiza que la comilla de cierre `"` nunca se encuentre.

En contraste, `pymdownx/blocks/html.py:19` ya escribe esta construcción correctamente, excluyendo la barra invertida de la clase negada para que las ramas sean disjuntas:

(?:"(?:\\\\(?:.)|[^\\\\"\r\n\f]+)*?"|...)
#                ^^^^ barra invertida excluida: solo \\\\(?:.) puede consumirla

`keys.py` es la excepción en esta base de código, no la regla.

Para completar, `betterem.py:37`, `((?:[^\\*]|(?<!\\*{2})\\*)+?)`, no está afectada y no necesita cambios: su segunda rama coincide con exactamente un asterisco, por lo que una secuencia de asteriscos tiene una sola descomposición. Lo verifiqué empíricamente y no solo a simple vista (razón de crecimiento media de 0.85, plana). Las ramas disjuntas o de longitud fija son seguras sin importar cuánto anidamiento aparente tengan.

También revisé la corrección de 11.0.1 mientras investigaba, por si le resulta útil: `betterem`, `caret` y `tilde` renderizan una secuencia adversarial de 4,000 caracteres (`*a` + `*`×4000 + `b` y equivalentes) en unos 50 ms. La corrección se mantiene; `keys.py` simplemente nunca estuvo dentro de su alcance.

Prueba de concepto

import markdown, time

payload = '++\"' + '\\\\' * 38 + 'x'          # 42 bytes
t = time.monotonic()
markdown.markdown(payload, extensions=['pymdownx.keys'])
print(f"{len(payload)} bytes -> {time.monotonic() - t:.1f}s")

Medido con pymdown-extensions 11.0.1 (PyPI) y Markdown 3.10.3, CPython 3.14, un solo núcleo:

| carga útil | comillas dobles | comillas simples |
| --- | --- | --- |
| 34 B | 0.69 s | — |
| 38 B | 4.91 s | — |
| 42 B | 35.8 s | 39.1 s |
| 44 B | ~91 s | — |

Controles, para demostrar que los tiempos se deben a este patrón y no a la longitud de la entrada ni al entorno:

| control | resultado |
| --- | --- |
| misma carga útil de 42 bytes, `pymdownx.keys` deshabilitada | 0.0005 s |
| entrada benigna de 42 bytes (`++\"` + `a`×38 + `x`), keys habilitada | 0.0004 s |
| `++\"Custom Key\"++` renderiza `<kbd>` antes de medir | sí, extensión verificada como funcional |
| calibración del arnés: patrón `betterem` previo a la corrección | crece 2.62× por paso (esperado) |
| calibración del arnés: patrón `betterem` posterior a la corrección | plano, 0.82× (esperado) |

Se adjunta un script autocontenido con los controles de calibración integrados (`poc_pymdown_keys_redos.py`). Ejecuta el caso solo con expresiones regulares sin dependencias y el caso de extremo a extremo si `markdown` y `pymdown-extensions` están instalados. Si la extensión no está renderizando realmente, el script se detiene en lugar de reportar tiempos.

Impacto

Un atacante no autenticado que pueda enviar Markdown a un servicio que lo renderiza con `pymdownx.keys` habilitada puede consumir CPU sin límite con una entrada muy pequeña. Como el crecimiento es exponencial, el atacante controla el costo: 42 bytes equivalen a ~36 segundos medidos, y extrapolando el crecimiento observado de 2.7× por cada dos bytes, ~54 bytes llegarían al rango de horas (extrapolado, no medido; me detuve en 44 B / ~91 s). Un número reducido de solicitudes concurrentes puede saturar todos los workers, por lo que el resultado práctico es una denegación de servicio.

No hay exposición de datos ni impacto en la integridad; es puramente agotamiento de recursos.

El requisito previo es que la extensión Keys esté habilitada y que el código fuente de Markdown no sea confiable. Los sitios que solo renderizan contenido confiable y redactado por sus autores no están expuestos de forma significativa.

Severidad

Propongo CVSS 3.1 7.5 Alta, `AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H`, por el hecho de que la carga útil es trivial, no requiere autenticación ni interacción, y el atacante controla el costo.

Hay dos matices que aclaro, ya que ustedes están en mejor posición para sopesarlos:

  • CVSS no tiene una forma limpia de expresar "requiere que una extensión opcional esté habilitada". Ese requisito previo es real y no intenté codificarlo en el vector; sugiere una calificación práctica más baja.
  • Alineé la propuesta con la forma en que se trató el problema hermano en 11.0.1. Si ustedes calificaron ese caso de manera distinta a como yo supongo, esta debería seguir su criterio y no el mío.

Corrección sugerida

Hacer las ramas disjuntas excluyendo el carácter de escape de la clase negada, exactamente lo que `blocks/html.py` ya hace:

-(?:(?:[\\w\\-]+|"(?:\\\\.|[^"])+"|\\'(?:\\\\.|[^\\'])+\\')\\+)*?
+(?:(?:[\\w\\-]+|"(?:\\\\.|[^\\\\"])+"|\\'(?:\\\\.|[^\\\\\\'])+\\')\\+)*?

Ambas apariciones de cada rama entre comillas necesitan el cambio: la línea 101 (la repetición perezosa) y la línea 102 (la alternativa final obligatoria), tanto para la alternativa con comillas dobles como con comillas simples, es decir, cuatro ediciones en total.

Aplique esto a `RE_EARLY_KBD` completo y lo verifiqué contra la versión 11.0.1 instalada:

  • Elimina la explosión. La razón de crecimiento media baja de 2.66× a 1.01× (plana). La carga útil de 42 bytes pasa de 35.8 s a 0.0005 s de extremo a extremo mediante `markdown.markdown()` con la extensión parcheada registrada.
  • La salida es idéntica byte a byte a la versión original en todos los casos que probé: `++ctrl+alt+delete++`, `++\"Custom Key\"++`, `++ctrl+'Left Click'++`, `++cmd+shift+p++`, `++\"a\\\"b\"++` (comilla escapada) y `++\"back\\\\slash\"++` (barra invertida escapada). Los seis siguen renderizando `<kbd>`.

Hay un cambio de comportamiento que prefiero señalar en lugar de pasarlo por alto: la entrada `"trailing\"`, es decir, una barra invertida suelta justo antes de la comilla de cierre, coincide actualmente y dejaría de coincidir después del cambio. Bajo la semántica de escape, esa cadena no está terminada, ya que la comilla está escapada, así que no coincidir es quizá la lectura más correcta y es coherente con `blocks/html.py`. Aun así, es un cambio de comportamiento y la decisión es suya, no mía. Si prefieren conservar exactamente el comportamiento actual, añadir `(?!\\\\)` a la rama de clase negada logra eso.

No he abierto un PR, para evitar crear un artefacto público antes de que tengan oportunidad de revisarlo. Con gusto puedo enviarlo de forma privada contra un fork o una rama de seguridad si les resulta más fácil.

Mitigación

Si considera que está en riesgo por este problema y no puede tolerarlo, la extensión Keys es opcional y puede deshabilitarse.

Referencias

  • Corrección relacionada: `c68498598d7b13011bb4571350b6e3612a4ce44b`: BetterEm, Tilde, Caret, MagicLink (11.0.1)
  • Manejo correcto de la misma construcción ya presente en el repositorio: `pymdownx/blocks/html.py:19`
  • Origen de la línea vulnerable: `6bc3eb92a`, 2017-04-16
  • CWE-1333: Complejidad ineficiente de expresiones regulares

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
10.0/ 10Muy alto
Vector 10.0 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
pymdown-extensions≥ 3.0 < 11.0.2
3.0
11.0.2
13.1.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypipymdown-extensions
Corregida 11.0.2 -77 d 13.1.0 no afectada
Versiones corregidas11.0.2
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/facelessuser/pymdown-extensions/security/advisories/GHSA-mw73-8637-g65g

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.