Vulnerable code sample

from PIL import Image

def vulnerable_font_compile(font_glyphs_metrics):
    """
    A simplified function that represents the vulnerable logic in
    Pillow's FontFile.compile() method before it was patched.
    It calculates a total image size from font glyph metrics without
    validating the result before memory allocation.
    """
    xsize = 0
    ysize = 0
    
    # In the original code, metrics are read from a font file.
    # An attacker can craft a font with extremely large metric values.
    for metrics in font_glyphs_metrics:
        width, height = metrics
        xsize += width
        if height > ysize:
            ysize = height

    # THE VULNERABLE LINE:
    # Image.new() is called with dimensions derived directly from the
    # untrusted font file. There is no check to prevent an excessively
    # large allocation (a "decompression bomb").
    # The fix for this vulnerability was to add a call to
    # Image._decompression_bomb_check((xsize, ysize)) before this line.
    im = Image.new("1", (xsize, ysize))

    # The rest of the function, which would paste glyphs into 'im', is omitted.
    return im

# This represents the metrics from a malicious font file.
# A single glyph is defined with a huge size (e.g., 65535x65535 pixels).
malicious_glyph_metrics_data = [
    (65535, 65535) 
]

# This call triggers the vulnerability. It attempts to allocate an
# enormous image (approx 4GB of pixels for a 65535x65535 '1' mode image),
# which can lead to a Denial of Service through memory exhaustion.
try:
    vulnerable_font_compile(malicious_glyph_metrics_data)
except MemoryError:
    # This exception is expected when running the vulnerable code.
    print("A MemoryError was triggered, as expected.")