{"id":"GHSA-q45j-58j2-45rg","summary":"Pillow: TiffDecode returns uninitialized memory as pixels for short JPEG strips","details":"```\n============================================================================\nTiffDecode returns uninitialized memory as pixels for short JPEG strips\nLocation: src/libImaging/TiffDecode.c:554  in _decodeStrip()\nCommit:   a707c6b21c313880d0771e54965d142dd42358b6\n============================================================================\n```\n\nPillow hands back leftover process memory as image pixels when it opens a small crafted TIFF file. Anyone who can get an application to open their image, and can see something produced from its pixels (a thumbnail, a preview, a converted copy), can read heap memory that the process had previously used and freed. This works in the default configuration: opening and loading the 478-byte file succeeds with no error or warning, and every row below the first eight holds stale memory instead of picture content.\n\nThe bug is in `_decodeStrip()` in `src/libImaging/TiffDecode.c`, and `_decodeTile()` has the same shape. The function `realloc()`s `state-\u003ebuffer` to `TIFFStripSize()` bytes without initialising it and calls `TIFFReadEncodedStrip()`. Whenever that call does not return -1, it copies all `RowsPerStrip` rows of the buffer into the image. libtiff's JPEG codec only warns when the JPEG embedded in a strip has fewer rows than the strip, and Pillow silences libtiff warnings. The codec decodes the rows that exist and still returns the full strip size, so the untouched remainder is copied out as pixels. libtiff's Group 4 fax codec behaves the same way for a stream that ends early.\n\nThe attached reproducer builds a 256×256 TIFF whose single strip or tile is a 256×8 JPEG. Before loading it, the script frees buffers filled with `b\"LEAK\"`. It then finds 15,872 copies of `LEAK` in rows 8–255 of the decoded image (the same freed chunk was reused in 500 of 500 runs). Under glibc's `MALLOC_PERTURB_`, those rows are entirely the allocator's fill byte. A well-formed control file decodes correctly in both cases.\n\nThis is a read of uninitialised heap memory, not memory corruption. Each strip can disclose up to width × `RowsPerStrip` bytes, and what comes back depends on the allocator's state at the time. The strip path was introduced in e91b851fdc1c (\"Add reading old-JPEG compressed TIFFs\", first released in Pillow 6.0.0). The tile path has had the same pattern since f0436a4ddc95 (Pillow 5.3.0).\n\n## Details\n\n`src/libImaging/TiffDecode.c` decodes compressed TIFFs through libtiff into a strip\n(or tile) buffer that it `realloc()`s to `TIFFStripSize()` bytes and never initialises, and\nthen copies all `RowsPerStrip` rows of that buffer into the image whenever\n`TIFFReadEncodedStrip()` does not return -1. libtiff's JPEG codec does not fail when the\nJPEG stream inside a strip has fewer rows than the strip: it decodes the rows that exist\nand returns the full strip size. The rows it did not write are whatever the heap held\nbefore, and Pillow returns them as pixels.\n\nA 478-byte file shows it: a classic little-endian TIFF, 256×256, `BitsPerSample=8`,\n`Compression=7`, `PhotometricInterpretation=1`, `RowsPerStrip=256`, one strip whose data\nis a baseline JPEG of 256×**8** pixels (as written by `Image.new(\"L\",(256,8),200).save(…,\"JPEG\")`).\n`Image.open(BytesIO(data)).load()` succeeds with default settings (compressed TIFFs always\ntake the libtiff path). Rows 0–7 of the result are the JPEG content (value 200); the\nremaining 63488 bytes of `im.tobytes()` are heap garbage: run under glibc's\n`MALLOC_PERTURB_=1` they are all `0xFE`, under `MALLOC_PERTURB_=170` all `0x55` (the\nfresh-`malloc` fill byte), and in a process that has just freed buffers containing\n`b\"LEAK\"` they contain 15872 copies of `LEAK`.\n\nFeeding the same file to libtiff 4.5.0 directly confirms the library side:\n`TIFFReadEncodedStrip(t, 0, buf, 65536)` prints\n`JPEGPreDecode: Warning, Improper JPEG strip/tile size, expected 256x256, got 256x8.`,\nreturns 65536, and leaves 63488 of the 65536 buffer bytes untouched. Pillow installs\n`TIFFSetWarningHandler(NULL)` (`TiffDecode.c:682`), so the warning is not visible either.\n\nThe strip path:\n\n```c\n// src/libImaging/TiffDecode.c:552\n    /* realloc to fit whole strip */\n    /* malloc check above */\n    new_data = realloc(state-\u003ebuffer, state-\u003ebytes);      // state-\u003ebytes = TIFFStripSize()\n    …\n    state-\u003ebuffer = new_data;\n\n    for (; state-\u003ey \u003c state-\u003eysize; state-\u003ey += rows_per_strip) {\n        …\n            if (TIFFReadEncodedStrip(\n                    tiff,\n                    TIFFComputeStrip(tiff, state-\u003ey, plane),\n                    (tdata_t)state-\u003ebuffer,\n                    strip_size\n                ) == -1) {\n                … return -1;\n            }\n            …\n            // iterate over each row in the strip and stuff data into image\n            for (strip_row = 0;\n                 strip_row \u003c MIN((INT32)rows_per_strip, state-\u003eysize - state-\u003ey);\n                 strip_row++) {\n                …\n                shuffler(\n                    (UINT8 *)im-\u003eimage[state-\u003ey + state-\u003eyoff + strip_row] +\n                        state-\u003exoff * im-\u003epixelsize,\n                    state-\u003ebuffer + strip_row * row_byte_size,\n                    state-\u003exsize\n                );\n```\n\n`state-\u003ebuffer` arrives here as the one-row `calloc` made by `decode.c:230`\n(`(bits*xsize+7)/8` = 256 bytes for the example). The `realloc` to 65536 bytes hands back\na different, uninitialised chunk; nothing zeroes it. `TIFFReadEncodedStrip()` returns the\nnominal strip size on success, not the number of rows produced, and the only check is\n`== -1`, so the row loop unconditionally copies 256 rows × 256 bytes into `im-\u003eimage`\n(which itself is zeroed by `core.new`, so the garbage provably comes from `state-\u003ebuffer`).\n`_decodeTile()` has the same shape (`TiffDecode.c:448` `realloc` to `TIFFTileSize()`, then\n`tile_length` rows copied after each `TIFFReadTile()` at 460–488).\n\nFor a well-formed file the JPEG inside the strip is 256×256, libtiff fills all 65536 bytes\nand the copy is correct. The malicious file differs only in the SOF height of the embedded\nJPEG; libtiff treats \"JPEG smaller than strip\" as a warning, clamps the row count to the\nJPEG height, and reports success.\n\nJPEG is not the only libtiff codec that succeeds on a short strip. `Fax4Decode`\n(`Compression=4`) returns success for a T.6 stream that ends early: a 133-byte 512×256\n1-bit TIFF whose strip is the Group 4 stream of a 512×16 image loads without error,\nlibtiff writes 17 rows (1088 bytes) of the 16384-byte buffer\n(`Fax4Decode: Warning, Premature EOL at line 16`, return value 16384) and the other\n15296 bytes are again heap contents. LZW, Deflate, PackBits, Group 3 and CCITT RLE were\nchecked and do return -1 on short data, so Pillow raises `OSError` for those.\n\nThe strip path was introduced in `e91b851fdc1c` (\"Add reading old-JPEG compressed TIFFs\",\n2018-12-08), first released in Pillow 6.0.0, which replaced row-by-row `TIFFReadScanline()`\n(where libtiff errors on the first missing row) with the whole-strip `realloc()` and copy.\nThe tile path has had the same shape since it was added in `f0436a4ddc95` (2018-07-02,\nPillow 5.3.0).\n\n## Impact\n\nAny application that opens attacker-supplied images with Pillow in the default\nconfiguration and returns something derived from the pixels (thumbnail, preview, format\nconversion, OCR text) discloses freed heap memory of the worker process to the uploader:\neverything below the rows the embedded JPEG/G4 stream actually encodes, up to\n`ImageWidth × RowsPerStrip × SamplesPerPixel` bytes per strip and tens of MB per image\nwithin the default `MAX_IMAGE_PIXELS`. `load()` raises nothing, so the application has no\nsignal that the image is malformed. What comes back depends on allocator state; in a\nlong-running web worker it is typically recently freed request bodies, other users'\ndecoded image buffers and Python object contents. There is no memory corruption; this is\na read of uninitialised (previously used) heap memory, analogous in effect to an\nout-of-bounds read that lands in pixels.\n\n## Reproducing\n\n`repro` is a short Python script that runs against the installed Pillow build with\ndefault settings: no rebuild, no sanitizer, no files written. It runs twice, once normally\nand once re-executing itself under glibc's `MALLOC_PERTURB_=170`, and the last line it\nprints is `BUG` or `OK`.\n\n**Input.** `tiff(jpeg_rows, tiled)` builds a little-endian TIFF in memory. The header\ndeclares a 256×256 8-bit greyscale image with `Compression=7` (JPEG), either as one strip\n(`RowsPerStrip=256`) or as one 256×256 tile (`TileWidth`/`TileLength`). The strip or tile\nis a baseline JPEG of 256×`jpeg_rows` pixels, all value 200, written by Pillow's own JPEG\nencoder. For each layout the script builds two files:\n\n- **Control:** `jpeg_rows=256`. This is a well-formed file, and libtiff fills the whole\n  64 KiB strip/tile.\n- **Crafted:** `jpeg_rows=8`, 478 bytes (strip) or 490 bytes (tile). The only difference\n  is the embedded JPEG's height. libtiff decodes 8 rows (2048 bytes), warns\n  `Improper JPEG strip/tile size` (Pillow silences the warning) and returns the full\n  strip/tile size as success.\n\n**Steps.** Each file is opened (the script asserts it takes the `libtiff` decoder). Just\nbefore `im.load()` the script allocates and frees six 64 KiB `bytearray`s filled with\n`b\"LEAK\"`, which leaves freed heap chunks about the size of the buffer that\n`_decodeStrip()`/`_decodeTile()` is about to `realloc()`. For rows 8–255 it then counts\ncopies of `LEAK` and bytes equal to `0x55` (glibc's fresh-`malloc` fill under\n`MALLOC_PERTURB_=170`). The files contain no `LEAK` bytes (the script asserts this), so\nany copy in the image came from freed heap memory. It reports `BUG` if a crafted file\nshows any `LEAK` in the normal pass, or rows 8–255 entirely `0x55` in the perturbed pass.\n\n**Expected output on this tree:**\n\n```\n[normal ] strip well-formed (1222 B) rows 8-255:     0 x b'LEAK',     0/63488 == 0x55, head=b'\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8'\n[normal ] strip crafted     ( 478 B) rows 8-255: 15872 x b'LEAK',     0/63488 == 0x55, head=b'LEAKLEAK'\n[normal ] tiled well-formed (1234 B) rows 8-255:     0 x b'LEAK',     0/63488 == 0x55, head=b'\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8'\n[normal ] tiled crafted     ( 490 B) rows 8-255: 15872 x b'LEAK',     0/63488 == 0x55, head=b'LEAKLEAK'\n[perturb] strip well-formed (1222 B) rows 8-255:     0 x b'LEAK',     0/63488 == 0x55, head=b'\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8'\n[perturb] strip crafted     ( 478 B) rows 8-255:     0 x b'LEAK', 63488/63488 == 0x55, head=b'UUUUUUUU'\n[perturb] tiled well-formed (1234 B) rows 8-255:     0 x b'LEAK',     0/63488 == 0x55, head=b'\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8\\xc8'\n[perturb] tiled crafted     ( 490 B) rows 8-255:     0 x b'LEAK', 63488/63488 == 0x55, head=b'UUUUUUUU'\nBUG\n```\n\n`im.load()` succeeds for every file. For the crafted files rows 8–255 are the uninitialised\nstrip/tile buffer, copied as-is into the image. With the attached patch applied, rows 8–255\nof the crafted files come back as `\\x00` bytes, with no `LEAK` and no `0x55`, and the\nscript ends with `OK`.\n\nThe `LEAK` count depends on where glibc places the buffer (the same freed chunk was reused\nin 500 of 500 runs here); the `MALLOC_PERTURB_` pass does not. The script covers the JPEG\ncodec only. The Group 4 variant in the Details section (`Compression=4`, a T.6 stream that\nends early) goes through the same `_decodeStrip()` copy, and the same fix covers it.\n\n## Suggested fix\n\nThe attached patch zeroes `state-\u003ebuffer` before each libtiff read in both loops of\n`src/libImaging/TiffDecode.c` — before `TIFFReadTile()` in `_decodeTile()` and before\n`TIFFReadEncodedStrip()` in `_decodeStrip()` — so rows a codec does not produce are\ndeterministic zeros rather than stale heap:\n\n```diff\n--- a/src/libImaging/TiffDecode.c\n+++ b/src/libImaging/TiffDecode.c\n@@ _decodeTile\n             for (x = state-\u003exoff; x \u003c state-\u003exsize; x += tile_width) {\n+                memset(state-\u003ebuffer, 0, state-\u003ebytes);\n                 if (TIFFReadTile(tiff, (tdata_t)state-\u003ebuffer, x, y, 0, plane) == -1) {\n@@ _decodeStrip\n         for (plane = 0; plane \u003c planes; plane++) {\n             ImagingShuffler shuffler = unpackers[plane];\n+            memset(state-\u003ebuffer, 0, state-\u003ebytes);\n             if (TIFFReadEncodedStrip(\n```\n\nA `memset` per strip/tile (rather than one `calloc` after the size is known) is needed\nbecause the same buffer is reused for every strip, and a short last strip would otherwise\nexpose the previous strip's rows — harmless for disclosure, but the per-read `memset`\nkeeps the behaviour uniform at the cost of one extra pass over the buffer. Promoting\nlibtiff warnings to errors via a warning handler is not a good alternative: both codecs\nonly warn (`Improper JPEG strip/tile size`, `Premature EOL`), but so do many legitimate\nfiles (unknown tags, bad tag counts), and the return value of `TIFFReadEncodedStrip()`\ncarries no row count to check against. Initialising the buffer covers every codec.\n`_decodeAsRGBA()` needs no change: `TIFFRGBAImageGet()` fills its whole raster, and JPEG\nfiles do not reach it (`JPEGCOLORMODE_RGB` sends them down the strip path).\n\nValid files decode exactly as before; rows a codec does not produce are now black instead\nof garbage, and nothing that previously loaded now fails. The patch also adds\n`test_jpeg_short_strip` to `Tests/test_file_libtiff.py`, parametrised over strip and tile,\nwhich builds the 256×8-JPEG-in-256×256 file and asserts rows 8–255 are zero. It is a\nregression guard for the fixed code rather than a reliable detector of the bug: in a fresh\npytest process the unfixed strip variant can pass because the new heap chunk happens to be\nzero (the tiled variant fails before the fix). With the patch, `Tests/test_file_libtiff.py`\nand `Tests/test_file_tiff.py` pass and the reproducer prints `OK`.\n\n## The patch\n\nZero the libtiff strip/tile buffer before each TIFFReadEncodedStrip/TIFFReadTile in TiffDecode.c so short strips do not expose uninitialised heap\n\nApplies to `src/libImaging/TiffDecode.c` at the commit above.\n\n```diff\ndiff --git a/Tests/test_file_libtiff.py b/Tests/test_file_libtiff.py\nindex 3d804ea4a..67bc96329 100644\n--- a/Tests/test_file_libtiff.py\n+++ b/Tests/test_file_libtiff.py\n@@ -1162,6 +1162,45 @@ class TestFileLibTiff(LibTiffTestCase):\n             im.load()\n         assert im.size == (950, 975)\n \n+    @pytest.mark.parametrize(\"tiled\", (False, True))\n+    def test_jpeg_short_strip(self, tiled: bool) -\u003e None:\n+        # The JPEG data in the strip/tile only contains 8 of the 256 rows that\n+        # RowsPerStrip/TileLength declare. libtiff decodes the rows that exist\n+        # and still reports success, so the remaining rows must be cleared\n+        # rather than left as uninitialised memory.\n+        jpeg = io.BytesIO()\n+        Image.new(\"L\", (256, 8), 200).save(jpeg, \"JPEG\")\n+        jpeg_data = jpeg.getvalue()\n+\n+        ifd = TiffImagePlugin.ImageFileDirectory_v2()\n+        ifd[256] = 256  # ImageWidth\n+        ifd[257] = 256  # ImageLength\n+        ifd[258] = 8  # BitsPerSample\n+        ifd[259] = 7  # Compression: JPEG\n+        ifd[262] = 1  # PhotometricInterpretation: BlackIsZero\n+        ifd[277] = 1  # SamplesPerPixel\n+        if tiled:\n+            ifd[322] = 256  # TileWidth\n+            ifd[323] = 256  # TileLength\n+            ifd[324] = 0  # TileOffsets\n+            ifd[325] = len(jpeg_data)  # TileByteCounts\n+            # Point the tile data at the end of the IFD\n+            ifd[324] = 8 + len(ifd.tobytes(8))\n+        else:\n+            ifd[278] = 256  # RowsPerStrip\n+            ifd[STRIPOFFSETS] = 0  # Updated by tobytes() to follow the IFD\n+            ifd[279] = len(jpeg_data)  # StripByteCounts\n+\n+        b = io.BytesIO()\n+        ifd.save(b)\n+        b.write(jpeg_data)\n+\n+        with Image.open(b) as im:\n+            assert im.tile[0][0] == \"libtiff\"\n+            im.load()\n+            assert im.crop((0, 0, 256, 8)).getextrema() == (200, 200)\n+            assert im.crop((0, 8, 256, 256)).getextrema() == (0, 0)\n+\n     def test_orientation(self) -\u003e None:\n         with Image.open(\"Tests/images/g4_orientation_1.tif\") as base_im:\n             for i in range(2, 9):\ndiff --git a/src/libImaging/TiffDecode.c b/src/libImaging/TiffDecode.c\nindex 8a57c523d..d1d6bfbbb 100644\n--- a/src/libImaging/TiffDecode.c\n+++ b/src/libImaging/TiffDecode.c\n@@ -457,6 +457,11 @@ _decodeTile(\n         for (plane = 0; plane \u003c planes; plane++) {\n             ImagingShuffler shuffler = unpackers[plane];\n             for (x = state-\u003exoff; x \u003c state-\u003exsize; x += tile_width) {\n+                // Some codecs (e.g. JPEG, Group 4) succeed on a tile that decodes\n+                // to fewer rows than the tile length, leaving the rest of the\n+                // buffer untouched. Clear it so that uninitialised memory is not\n+                // copied into the image.\n+                memset(state-\u003ebuffer, 0, state-\u003ebytes);\n                 if (TIFFReadTile(tiff, (tdata_t)state-\u003ebuffer, x, y, 0, plane) == -1) {\n                     TRACE((\"Decode Error, Tile at %dx%d\\n\", x, y));\n                     state-\u003eerrcode = IMAGING_CODEC_BROKEN;\n@@ -563,6 +568,11 @@ _decodeStrip(\n         int plane;\n         for (plane = 0; plane \u003c planes; plane++) {\n             ImagingShuffler shuffler = unpackers[plane];\n+            // Some codecs (e.g. JPEG, Group 4) succeed on a strip that decodes\n+            // to fewer rows than RowsPerStrip, leaving the rest of the buffer\n+            // untouched. Clear it so that uninitialised memory is not copied\n+            // into the image.\n+            memset(state-\u003ebuffer, 0, state-\u003ebytes);\n             if (TIFFReadEncodedStrip(\n                     tiff,\n                     TIFFComputeStrip(tiff, state-\u003ey, plane),\n```\n\n## The reproducer\n\n\u003cdetails\u003e\n\u003csummary\u003eReproducer — \u003ccode\u003erepro\u003c/code\u003e, 2,688 bytes (click to open)\u003c/summary\u003e\n\nIts last line is `BUG` when the issue triggers and `OK` when it does not. Re-run on a clean build of that commit it printed `BUG`.\n\n```python\n#!/usr/bin/env python3\n# Pillow TiffDecode.c _decodeStrip/_decodeTile: strip/tile buffer is realloc()ed, never\n# initialised, and copied whole into the image even when libtiff's JPEG codec decoded\n# fewer rows than RowsPerStrip/TileLength.  Two independent signals:\n#  pass 1 (normal heap): seed freed 64 KiB chunks with b\"LEAK\" just before load() and\n#         count copies of LEAK in the decoded pixels (file contains no such bytes);\n#  pass 2 (same script re-run under glibc MALLOC_PERTURB_=170): fresh malloc memory is\n#         0x55, so rows that come back all-0x55 are provably uninitialised heap.\nimport gc, io, os, struct, subprocess, sys\nfrom PIL import Image\nW = H = 256; ROWS = 8\nperturbed = os.environ.get(\"MALLOC_PERTURB_\") == \"170\"\nif not perturbed:\n    print(\"Pillow\", Image.__version__, Image.core.__file__)\n\ndef tiff(jpeg_rows, tiled):\n    j = io.BytesIO(); Image.new(\"L\", (W, jpeg_rows), 200).save(j, \"JPEG\"); j = j.getvalue()\n    tags = [(256,3,1,W), (257,3,1,H), (258,3,1,8), (259,3,1,7), (262,3,1,1), (277,3,1,1)]\n    tags += ([(322,3,1,W), (323,3,1,H), (324,4,1,0), (325,4,1,len(j))] if tiled else\n             [(273,4,1,0), (278,3,1,H), (279,4,1,len(j))])\n    tags.sort(); off = 8 + 2 + 12*len(tags) + 4\n    tags = [(t,ty,c, off if t in (273,324) else v) for t,ty,c,v in tags]\n    ifd = struct.pack(\"\u003cH\", len(tags)) + b\"\".join(struct.pack(\"\u003cHHLL\", *t) for t in tags)\n    return b\"II*\\0\" + struct.pack(\"\u003cL\", 8) + ifd + struct.pack(\"\u003cL\", 0) + j\n\nbug = False\nfor tiled in (False, True):\n    for jpeg_rows, label in ((H, \"well-formed\"), (ROWS, \"crafted\")):\n        data = tiff(jpeg_rows, tiled); assert b\"LEAK\" not in data\n        im = Image.open(io.BytesIO(data)); assert im.tile[0][0] == \"libtiff\"\n        junk = [bytearray(b\"LEAK\" * (W*H//4)) for _ in range(6)]; del junk; gc.collect()\n        im.load()                                   # no exception for either file\n        below = im.tobytes()[W*ROWS:]\n        n55, nleak = below.count(0x55), below.count(b\"LEAK\")\n        print(f\"[{'perturb' if perturbed else 'normal '}] {'tiled' if tiled else 'strip'} \"\n              f\"{label:11s} ({len(data):4d} B) rows {ROWS}-{H-1}: {nleak:5d} x b'LEAK', \"\n              f\"{n55:5d}/{len(below)} == 0x55, head={below[:8]!r}\")\n        if jpeg_rows == ROWS and (nleak \u003e 0 or (perturbed and n55 == len(below))):\n            bug = True\nif not perturbed:\n    r = subprocess.run([sys.executable, sys.argv[0]], env={**os.environ, \"MALLOC_PERTURB_\": \"170\"},\n                       capture_output=True, text=True)\n    lines = r.stdout.rstrip().split(\"\\n\")\n    print(\"\\n\".join(lines[:-1])); sys.stderr.write(r.stderr)\n    bug = bug or lines[-1] == \"BUG\"\nprint(\"BUG\" if bug else \"OK\")\n```\n\u003c/details\u003e\n\n---","aliases":["CVE-2026-112897"],"modified":"2026-10-20T21:00:04.414260544Z","published":"2026-10-20T20:52:43Z","database_specific":{"cwe_ids":["CWE-908"],"severity":"HIGH","github_reviewed":true,"github_reviewed_at":"2026-10-20T20:52:43Z","nvd_published_at":"2026-10-19T22:17:09Z"},"references":[{"type":"WEB","url":"https://github.com/python-pillow/Pillow/security/advisories/GHSA-q45j-58j2-45rg"},{"type":"ADVISORY","url":"https://nvd.nist.gov/vuln/detail/CVE-2026-112897"},{"type":"WEB","url":"https://github.com/python-pillow/Pillow/commit/1d4773e6cea0c4a2814e6d4cdc099bbcf56da6ce"},{"type":"PACKAGE","url":"https://github.com/python-pillow/Pillow"},{"type":"WEB","url":"https://github.com/python-pillow/Pillow/releases/tag/13.0.0"}],"affected":[{"package":{"name":"pillow","ecosystem":"PyPI","purl":"pkg:pypi/pillow"},"ranges":[{"type":"ECOSYSTEM","events":[{"introduced":"5.3.0"},{"fixed":"13.0.0"}]}],"versions":["10.0.0","10.0.1","10.1.0","10.2.0","10.3.0","10.4.0","11.0.0","11.1.0","11.2.1","11.3.0","12.0.0","12.1.0","12.1.1","12.2.0","12.3.0","5.3.0","5.4.0","5.4.0.dev0","5.4.1","6.0.0","6.1.0","6.2.0","6.2.1","6.2.2","7.0.0","7.1.0","7.1.1","7.1.2","7.2.0","8.0.0","8.0.1","8.1.0","8.1.1","8.1.2","8.2.0","8.3.0","8.3.1","8.3.2","8.4.0","9.0.0","9.0.1","9.1.0","9.1.1","9.2.0","9.3.0","9.4.0","9.5.0"],"database_specific":{"source":"https://github.com/github/advisory-database/blob/main/advisories/github-reviewed/2026/10/GHSA-q45j-58j2-45rg/GHSA-q45j-58j2-45rg.json"}}],"schema_version":"1.9.0","severity":[{"type":"CVSS_V4","score":"CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N"}]}