El decodificador de TIFF por teselas de Pillow lee más allá del búfer de teselas en copy4 (Unpack.c:1290)

Resumen

El decodificador _decodeTile de libImaging en Pillow, utilizado para decodificar imágenes TIFF divididas en teselas (tiled), asigna un búfer por tesela mediante realloc(state->buffer, TIFFTileSize(tiff)). Tras cada TIFFReadTile, itera tile_y desde 0 hasta current_tile_length e invoca al desempaquetador de filas configurado (en este caso copy4) con el puntero de origen state->buffer + tile_y * row_byte_size. Cuando libtiff devuelve un tile_bytes_size menor que el peor caso row_byte_size * tile_length, el bucle interno de avance y copia sobrepasa la región reasignada y copy4 realiza una operación memcpy de 1024 bytes que lee hasta (tile_length-1) * row_byte_size + row_byte_size bytes de un búfer dimensionado únicamente para tile_bytes_size. El TIFF de prueba de concepto suministrado desencadena una sobrelectura de 1024 bytes exactamente 0 bytes después de una asignación de 196608 bytes. Un atacante que convenza a una aplicación basada en Pillow para decodificar un TIFF manipulado puede provocar el bloqueo del proceso (denegación de servicio) y puede hacer que la memoria adyacente del heap se copie en el búfer de píxeles decodificado.

Detalles

Cuando libtiff indica que el archivo está dividido en teselas, el decodificador TIFF de Pillow toma la ruta _decodeTile. La función:

1. Solicita a libtiff TIFFTileSize(tiff) (los bytes por tesela) y TIFFTileRowSize(tiff) (los bytes por fila tal como los almacena libtiff).
2. Reasigna state->buffer a exactamente tile_bytes_size.
3. Para cada origen de tesela (x, y) y cada plano, llama a TIFFReadTile en state->buffer, y luego recorre la tesela fila por fila, invocando al ImagingShuffler configurado (aquí copy4) sobre los bytes de origen correspondientes a cada fila.

La validación que se lleva a cabo antes del bucle es:

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

Esto rechaza teselas de libtiff de tamaño excesivo, pero no rechaza las de tamaño insuficiente, es decir, el caso en que libtiff devuelve un tile_bytes_size estrictamente menor que row_byte_size * tile_length. Sin embargo, el cuerpo del bucle indexa el búfer asumiendo que tiene una longitud de al menos row_byte_size * tile_length bytes.

Código vulnerable

// 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
}

Los metadatos de la tesela del PoC generan tile_width = tile_length = 256, row_byte_size = 1024 (4 bytes/píxel × 256 píxeles), y tile_bytes_size = 196608 (que equivale a 256·256·3 = almacenamiento de tres canales en bytes). El búfer reasignado tiene 196608 bytes. El desempaquetador itera tile_y desde 0 hasta 255, y para las filas más altas el puntero de origen state->buffer + tile_y * 1024 ya se encuentra en o más allá del desplazamiento 196608; la llamada a memcpy(in=buffer+255·1024, 1024) de la última fila lee 1024 bytes comenzando 260096 - 196608 = 63488 bytes después de la asignación; ASAN marca el primer byte después de la región de heap (READ of size 1024 at … 0 bytes after 196608-byte region).

La discrepancia es real: TIFFTileSize de libtiff devuelve el almacenamiento empaquetado por tesela (que depende del diseño fotométrico/de separación del archivo; legítimamente puede ser inferior a row_byte_size × tile_length), mientras que el bucle interno avanza como si el búfer siempre fuera igual a row_byte_size × tile_length.

Atribución

Este problema fue descubierto por Anthropic mediante el uso de Claude para estudiar la seguridad de proyectos de código abierto, y yo soy de Ada Logics, ayudando a validar los problemas encontrados y reportarlos a los mantenedores. Los datos de este informe han sido revisados manualmente.