Pillow-Decoder für gekachelte TIFFs liest über Kachelpuffer hinaus in copy4 (Unpack.c:1290)

Zusammenfassung

Der Decoder _decodeTile in Pillows libImaging, der zum Dekodieren von gekachelten TIFF-Bildern verwendet wird, alloziiert über realloc(state->buffer, TIFFTileSize(tiff)) einen Puffer pro Kachel. Nach jedem TIFFReadTile iteriert er tile_y von 0 bis current_tile_length und ruft den konfigurierten Zeilen-Unpacker (hier copy4) mit dem Quellzeiger state->buffer + tile_y * row_byte_size auf. Wenn libtiff einen Wert für tile_bytes_size zurückgibt, der kleiner als der Worst-Case row_byte_size * tile_length ist, läuft die innere Stride-and-Copy-Schleife über den reallokierten Bereich hinaus, und copy4 führt eine 1024-Byte-Operation memcpy aus, die bis zu (tile_length-1) * row_byte_size + row_byte_size Bytes aus einem Puffer liest, der nur für tile_bytes_size dimensioniert ist. Das bereitgestellte PoC-TIFF löst einen Überlesevorgang von 1024 Bytes genau 0 Bytes hinter einer Allokation von 196608 Bytes aus. Ein Angreifer, der eine Pillow nutzende Anwendung dazu bringen kann, ein manipuliertes TIFF zu dekodieren, kann einen Prozessabsturz (Denial of Service) herbeiführen und möglicherweise veranlassen, dass benachbarter Heap-Speicher in den dekodierten Pixelpuffer kopiert wird.

Details

Wenn libtiff meldet, dass die Datei gekachelt ist, nimmt der TIFF-Decoder von Pillow den Pfad _decodeTile. Die Funktion:

1. Fragt libtiff nach TIFFTileSize(tiff) (den Bytes pro Kachel) und TIFFTileRowSize(tiff) (den Bytes pro Zeile wie von libtiff gespeichert).
2. Reallokiert state->buffer auf genau tile_bytes_size.
3. Ruft für jeden Kachelursprung (x, y) und jede Ebene TIFFReadTile nach state->buffer auf und durchläuft die Kachel dann Zeile für Zeile, wobei der konfigurierte ImagingShuffler (hier copy4) auf den Quelldaten jeder Zeile aufgerufen wird.

Die vor der Schleife durchgeführte Validierung lautet:

if (tile_bytes_size > ((tile_length * state->bits / planes + 7) / 8) * tile_width) {
    state->errcode = IMAGING_CODEC_BROKEN;
    return -1;
}

Dies weist überdimensionierte Kacheln von libtiff ab, verwirft jedoch keine unterdimensionierten Kacheln – also den Fall, in dem libtiff ein tile_bytes_size zurückgibt, das strikt kleiner als row_byte_size * tile_length ist. Der Schleifenkörper greift jedoch auf den Puffer unter der Annahme zu, dass dieser mindestens row_byte_size * tile_length Bytes lang ist.

Anfälliger Code

// src/libImaging/TiffDecode.c:446-490 — _decodeTile
new_data = realloc(state->buffer, state->bytes);   // bytes = tile_bytes_size
if (!new_data) { ... }
state->buffer = new_data;

for (y = state->yoff; y < state->ysize; y += tile_length) {
    for (plane = 0; plane < planes; plane++) {
        ImagingShuffler shuffler = unpackers[plane];
        for (x = state->xoff; x < state->xsize; x += tile_width) {
            if (TIFFReadTile(tiff, (tdata_t)state->buffer, x, y, 0, plane) == -1) { ... }

            current_tile_width  = min((INT32)tile_width,  state->xsize - x);
            current_tile_length = min((INT32)tile_length, state->ysize - y);
            for (tile_y = 0; tile_y < current_tile_length; tile_y++) {
                shuffler(
                    (UINT8 *)im->image[tile_y + y] + x * im->pixelsize,
                    state->buffer + tile_y * row_byte_size,   // <-- OOB stride
                    current_tile_width
                );
            }
        }
    }
}

// src/libImaging/Unpack.c:1288-1291 — copy4 (the crash site)
static void
copy4(UINT8 *out, const UINT8 *in, int pixels) {
    /* RGBA, CMYK quadruples */
    memcpy(out, in, 4 * pixels);   // <-- ASAN-detected READ here
}

Die Kachel-Metadaten des PoC ergeben tile_width = tile_length = 256, row_byte_size = 1024 (4 Bytes/Pixel × 256 Pixel) und tile_bytes_size = 196608 (was 256·256·3 = Dreikanal-Byte-Speicher entspricht). Der reallokierte Puffer ist 196608 Bytes groß. Der Unpacker iteriert tile_y von 0 bis 255, und bei den obersten Zeilen liegt der Quellzeiger state->buffer + tile_y * 1024 bereits an oder hinter Offset 196608 – das memcpy(in=buffer+255·1024, 1024) der allerletzten Zeile liest 1024 Bytes beginnend 260096 - 196608 = 63488 Bytes hinter der Allokation; ASAN markiert bereits das allererste Byte hinter dem Heap-Bereich (READ of size 1024 at … 0 bytes after 196608-byte region).

Die Diskrepanz ist real: TIFFTileSize von libtiff gibt den gepackten Kachelspeicherplatz zurück (der vom photometrischen/Separations-Layout der Datei abhängt – er kann legitim kleiner sein als row_byte_size × tile_length), während die innere Schleife so voranschreitet, als ob der Puffer immer gleich row_byte_size × tile_length wäre.

Danksagung

Dieses Problem wurde von Anthropic bei der Untersuchung der Sicherheit von Open-Source-Projekten mithilfe von Claude entdeckt, und ich von Ada Logics helfe bei der Validierung der gefundenen Probleme und der Meldung an die Maintainer. Die Daten in diesem Bericht wurden manuell überprüft.