GHSA-MW73-8637-G65G
pymdownx.keys: ReDoS exponencial en las ramas de claves entre comillas de RE_EARLY_KBD
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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
`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.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
pypipymdown-extensions |
Corregida | 11.0.2 | -77 d | 13.1.0 no afectada |
11.0.2Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/facelessuser/pymdown-extensions/security/advisories/GHSA-mw73-8637-g65gLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
