Skip to main content

Pillow EUVDEUVD-2026-104645

| CVE-2026-112404 HIGH
Buffer Over-read (CWE-126)
2026-10-19 GitHub_M GHSA-c6hw-5grf-ff96
8.8
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft TIFF with duplicated Photometric/BitsPerSample tags
  2. Delivery
    Submit image to Pillow-backed service
  3. Exploit
    Trigger tile/RGBA decode without row-fit check
  4. Execution
    Over-read adjacent heap into output pixels
  5. Impact
    Leak 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Pillow 8.1.0, < 13.0.0

Affected Packages

pypi pillow fix: 13.0.0

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

Vendor (GitHub_M) PRIMARY 8.8 HIGH
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
vuln.today AI 8.2 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 19, 2026 - 23:18 EUVD
CVE Published
Oct 19, 2026 - 21:27 cve.org
HIGH 8.8

DescriptionCVE.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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 80% exploitable
Prevalence
High
Pillow is the de facto Python imaging library, embedded in countless web backends
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Pillow

View all
CVE-2022-30595 CRITICAL POC
9.8 May 25

libImaging/TgaRleDecode.c in Pillow 9.1.0 has a heap buffer overflow in the processing of invalid TGA image files. Rated

CVE-2026-59204 HIGH POC
8.7 Jul 14

Denial of service in Python Pillow (versions 8.2.0 through 12.2.0) allows remote attackers to exhaust memory during JPEG

CVE-2026-54058 HIGH POC
8.3 Jul 14

Out-of-bounds memory disclosure in Python Pillow before 12.3.0 lets an attacker who supplies a crafted McIdas AREA image

CVE-2026-59197 HIGH POC
8.2 Jul 14

Heap out-of-bounds write in Python Pillow prior to 12.3.0 lets an attacker who controls the rank-filter size parameter c

CVE-2026-59200 HIGH POC
7.5 Jul 14

Uncontrolled memory consumption in Python Pillow (PIL) versions 5.1.0 through 12.2.x allows a remote attacker to cause d

CVE-2021-23437 HIGH POC
7.5 Sep 03

The package pillow 5.2.0 and before 8.3.2 are vulnerable to Regular Expression Denial of Service (ReDoS) via the getrgb

CVE-2025-48379 HIGH POC
7.1 Jul 01

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

CVE-2016-4009 CRITICAL
9.8 Apr 13

Integer overflow in the ImagingResampleHorizontal function in libImaging/Resample.c in Pillow before 3.1.1 allows remote

CVE-2014-3007 CRITICAL
10.0 Apr 27

Python Image Library (PIL) 1.1.7 and earlier and Pillow 2.3 might allow remote attackers to execute arbitrary commands v

CVE-2026-96639 CRITICAL
9.8 Oct 21

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

CVE-2021-34552 CRITICAL
9.8 Jul 13

Pillow through 8.2.0 and PIL (aka Python Imaging Library) through 1.1.7 allow an attacker to pass controlled parameters

CVE-2021-25289 CRITICAL
9.8 Mar 19

An issue was discovered in Pillow before 8.1.1. Rated critical severity (CVSS 9.8), this vulnerability is remotely explo

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy