Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft TIFF with duplicated Photometric/BitsPerSample tags
-
DeliverySubmit image to Pillow-backed service
-
ExploitTrigger tile/RGBA decode without row-fit check
-
ExecutionOver-read adjacent heap into output pixels
-
ImpactLeak heap data or crash process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer over-read prevention
|
| Exploitation Conditions | Requires the victim application to open a crafted TIFF and actually load its pixels (e.g., load(), convert(), thumbnail, or save-to-other-format) using Pillow 8.1.0 through 12.x with libtiff-backed decoding. The malicious file must carry duplicated PhotometricInterpretation or BitsPerSample tags that Pillow and libtiff interpret differently, and must drive the tile decode path (_decodeTile) or the RGBA unpacker path - the strip path already validates that the input row fits inside libtiff's produced row and is NOT affected. Limiting factors: exploitation is confined to applications that process attacker-controlled TIFF data through the vulnerable code paths; impact is primarily a crash plus limited, non-deterministic adjacent heap disclosure into output pixels rather than code execution, and upgrading to 13.0.0 fully removes the condition. |
| Impact | This is a CWE-126 out-of-bounds (over-read) flaw in Pillow's TIFF tile and RGBA decode paths (8.1.0 up to, but not including, 13.0.0). The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) scores 8.8 and emphasizes VA:H (process crash / DoS) with only VC:L (limited heap-memory disclosure into output pixels) and VI:N. No EPSS score was provided and the input does not list KEV or POC status, so there is no public exploit identified at time of analysis and no evidence of active exploitation - the signals are therefore driven almost entirely by the CVSS vector rather than by observed attacker activity. Note a tension between the vector and the mechanism: AV:N/PR:N/UI:N models the common server-side case where an application auto-ingests attacker-supplied images, but exploitation fundamentally requires the target application to open and load pixels from a crafted TIFF, so in interactive/desktop contexts there is an implicit user/application action that the vector does not capture. Realistically this is a moderate-priority issue: the availability impact (crash) is the most reliable outcome, while the heap-data disclosure is bounded (adjacent row data bleeding into output pixels) and the confidentiality value to an attacker is uncertain and non-deterministic. Given Pillow's very broad deployment, patching is worthwhile, but the absence of KEV/POC/EPSS signals argues against emergency treatment. |
| Exploit ScenarioDerived | An attacker uploads a crafted TIFF with duplicated PhotometricInterpretation or BitsPerSample tags to a web service that uses Pillow to decode or thumbnail user images. When the service loads pixels via the tile or RGBA path, Pillow reads past the row libtiff actually produced, either crashing the worker (DoS) or embedding adjacent heap bytes into the returned/processed image. No public weaponized exploit is identified in the provided data, though the fix commit includes a regression test that constructs a triggering short-strip/short-tile TIFF. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Heap out-of-bounds over-read in Pillow 8.1.0 through 12.x allows a crafted TIFF processed by an application using libtiff-backed decoding to copy adjacent heap contents into output pixels or crash the process. The flaw affects the tile path in _decodeTile and the RGBA unpacker when duplicated PhotometricInterpretation or BitsPerSample tags are interpreted differently by Pillow and libtiff; the strip path is not affected. No public exploit code or CISA KEV entry was identified at time of analysis, and upgrading to 13.0.0 fixes the issue.
RemediationAI
Vendor-released patch: Pillow 13.0.0, available at https://github.com/python-pillow/Pillow/releases/tag/13.0.0, with the upstream fix in commit 1d4773e6cea0c4a2814e6d4cdc099bbcf56da6ce and advisory GHSA-c6hw-5grf-ff96. Upgrade to 13.0.0 or later as the primary remediation. If immediate upgrade is not possible, block processing of untrusted TIFF files, disable TIFF decoding in applications that do not require it, or force conversion through a separate hardened image decoder outside Pillow; these reduce exposure but remove functionality or add operational complexity. Run Pillow image processing in a sandboxed, low-privilege worker to contain crashes and limit heap-disclosure impact, though this does not remove the underlying over-read.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Pillow's libtiff-backed TIFF decoder handles image data as strips or tiles, with buffer sizing and row availability partly controlled by libtiff. CWE-126 (buffer over-read) arises because _decodeTile and the RGBA unpacker path do not verify that the required input row fits inside the row libtiff actually produced, while the strip path has this validation. Crafted TIFFs with duplicated PhotometricInterpretation or BitsPerSample tags can cause Pillow and libtiff to disagree on row layout, leading to reads beyond valid row data. The commit for this CVE adjusts _decodeTile and _decodeStrip buffer growth and zeroes newly allocated regions so that codecs which decode fewer rows than declared, such as JPEG or Group 4, cannot leave uninitialized memory that gets copied into the image. The affected CPE is cpe:2.3:a:python-pillow:pillow:*:*:*:*:*:*:*:*, covering the Pillow TIFF decoding functionality used by Python applications.
Know when Pillow gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
Remotely supplied crafted TIFF processed without auth (AV:N/PR:N/UI:N in server ingest model); over-read yields limited heap disclosure (C:L) and reliable crash (A:H), no integrity impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Pillow is a Python imaging library. From 8.1.0 until 13.0.0, Pillow's TIFF tile and RGBA decode paths can read beyond row data produced by libtiff. In _decodeTile and the RGBA unpacker path, when Pillow and libtiff interpret duplicated PhotometricInterpretation or BitsPerSample tags differently, Pillow does not verify that the required input row fits inside the row libtiff produced, while the strip path has this validation. Loading pixels from such a crafted TIFF can expose adjacent heap data in output pixels or crash the process. This issue is fixed in version 13.0.0.
Blast Radius
ecosystem impact- 78 pypi packages depend on pillow (66 direct, 12 indirect)
Ecosystem-wide dependent count for version 8.1.0.
Technical POC Analysis
CWE-126 (buffer over-read) in Pillow's libtiff glue layer, src/libImaging/TiffDecode.c (reported at line 483 in decodeTile(), with the sibling gap in decodeAsRGBA(); advisory commit a707c6b21c313880d…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Pillow, the Python imaging library used across many internal and customer-facing services, carries a high-severity (CVSS 8.8) heap over-read that can leak adjacent process memory into generated image output or crash the host process whenever a crafted TIFF is decoded. Any team accepting TIFF input - document ingestion, medical or geospatial imaging, media pipelines, or customer file-upload endpoints - is exposed, creating both confidentiality risk (memory disclosure) and availability risk (service crashes). Leadership should care because the defect is reachable through ordinary file upload, requires no special privileges on the target application, and a fix requires an upstream library upgrade that teams must schedule deliberately.
No vendor-released patch is confirmed at time of analysis per the patch status field, although the technical description identifies Pillow 13.0.0 as the fixed release - verify this against the Pillow release notes and vendor advisory and apply it as the primary remediation once validated. Until then: block or quarantine untrusted TIFF uploads at the perimeter and in application input validation; disable TIFF handling entirely in services that do not require it; run TIFF decoding in an isolated, memory-limited, least-privilege worker process or container so a crash or over-read cannot reach sensitive adjacency; reject or normalize TIFF files containing duplicate PhotometricInterpretation or BitsPerSample tags before they reach Pillow; and monitor for abnormal worker crashes or unexpected pixel data in generated images as a detection signal for attempted exploitation.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
libImaging/TgaRleDecode.c in Pillow 9.1.0 has a heap buffer overflow in the processing of invalid TGA image files. Rated
Denial of service in Python Pillow (versions 8.2.0 through 12.2.0) allows remote attackers to exhaust memory during JPEG
Out-of-bounds memory disclosure in Python Pillow before 12.3.0 lets an attacker who supplies a crafted McIdas AREA image
Heap out-of-bounds write in Python Pillow prior to 12.3.0 lets an attacker who controls the rank-filter size parameter c
Uncontrolled memory consumption in Python Pillow (PIL) versions 5.1.0 through 12.2.x allows a remote attacker to cause d
The package pillow 5.2.0 and before 8.3.2 are vulnerable to Regular Expression Denial of Service (ReDoS) via the getrgb
Pillow is a Python imaging library. In versions 11.2.0 to before 11.3.0, there is a heap buffer overflow when writing a
Integer overflow in the ImagingResampleHorizontal function in libImaging/Resample.c in Pillow before 3.1.1 allows remote
Python Image Library (PIL) 1.1.7 and earlier and Pillow 2.3 might allow remote attackers to execute arbitrary commands v
Pillow versions 11.0.0 through 12.x (fixed in 13.0.0) can reuse a stale native ImagingCore buffer when a multi-frame ima
Pillow through 8.2.0 and PIL (aka Python Imaging Library) through 1.1.7 allow an attacker to pass controlled parameters
An issue was discovered in Pillow before 8.1.1. Rated critical severity (CVSS 9.8), this vulnerability is remotely explo
EUVD-2026-104645
GHSA-c6hw-5grf-ff96
NVD
CVE.org
EPSS
Exploit-DB