"""Проверка PNG и JPEG по содержимому, память ограничена. Размер изображения берётся из заголовка до любой работы с данными, поэтому decompression bomb отсекается сразу. PNG проверяется потоково без декодера: CRC блоков, порядок блоков, распаковка с выбрасыванием результата, байт фильтра в начале каждой строки, точный объём данных. Память не зависит от размера изображения, поэтому Pillow здесь не нужен. JPEG так проверить нельзя: чтобы понять, что в скане настоящие данные, их надо декодировать. Поэтому сначала идёт быстрый разбор маркеров, а потом настоящий декодер с уменьшением в 8 раз. Обычный JPEG при этом занимает несколько МБ. Прогрессивный хранит коэффициенты всего изображения, это до 2 байт на отсчёт, то есть до 320 МБ на 40 млн пикселей CMYK, поэтому декодирование идёт по одному на реплику. """ import struct import threading import zlib BLOCK = 64 * 1024 PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n" JPEG_SIGNATURE = b"\xff\xd8\xff" # допустимая глубина цвета для каждого типа PNG и число каналов PNG_COLOR_TYPES = {0: ((1, 2, 4, 8, 16), 1), 2: ((8, 16), 3), 3: ((1, 2, 4, 8), 1), 4: ((8, 16), 2), 6: ((8, 16), 4)} # все маркеры SOF, кроме DHT (C4), JPG (C8) и DAC (CC), которые попадают в тот же диапазон JPEG_SOF = set(range(0xC0, 0xD0)) - {0xC4, 0xC8, 0xCC} # кодирование Хаффмана: минимум 1 бит на блок. У арифметического (C9-CF) нижней границы нет JPEG_HUFFMAN_SOF = {0xC0, 0xC1, 0xC2} # каждый скан заставляет декодер пройти всё изображение, а в 10 MiB их можно уместить тысячи; # настоящим файлам хватает нескольких десятков MAX_JPEG_SCANS = 100 PNG_CRITICAL_CHUNKS = {b"IHDR", b"PLTE", b"IDAT", b"IEND"} # проходы Adam7: первая колонка, первая строка, шаг по колонкам, шаг по строкам ADAM7_PASSES = ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2)) # см. начало файла: не больше одного тяжёлого декодирования на реплику decode_lock = threading.Lock() class NotAnImage(Exception): pass class TooManyPixels(Exception): pass def inspect(file, max_pixels: int) -> str: """Возвращает настоящий тип файла или бросает NotAnImage / TooManyPixels.""" file.seek(0) head = file.read(8) try: if head == PNG_SIGNATURE: check_png(file, max_pixels) return "image/png" if head[:3] == JPEG_SIGNATURE: file.seek(2) check_jpeg_structure(file, max_pixels) decode_jpeg(file) return "image/jpeg" except (struct.error, zlib.error, ValueError) as error: raise NotAnImage() from error raise NotAnImage() def check_size(width: int, height: int, max_pixels: int) -> None: if width == 0 or height == 0: raise NotAnImage() if width * height > max_pixels: raise TooManyPixels() def png_passes(width: int, height: int, bits_per_pixel: int, interlaced: bool) -> list: """Группы строк распакованных данных: (длина строки вместе с байтом фильтра, число строк).""" if not interlaced: return [(1 + (width * bits_per_pixel + 7) // 8, height)] passes = [] for column, row, column_step, row_step in ADAM7_PASSES: columns = (width - column + column_step - 1) // column_step rows = (height - row + row_step - 1) // row_step if columns > 0 and rows > 0: # у маленького изображения часть проходов пуста passes.append((1 + (columns * bits_per_pixel + 7) // 8, rows)) return passes class ScanlineFilters: """Следит за байтами фильтра в распакованном потоке, сами данные не хранит.""" def __init__(self, passes: list): self.passes = iter(passes) self.position = 0 # смещение начала следующего блока в распакованном потоке self.next_filter = 0 # смещение следующего байта фильтра self.row_size, self.rows_left = next(self.passes, (0, 0)) self.expected = sum(size * rows for size, rows in passes) def feed(self, block: bytes) -> None: end = self.position + len(block) if end > self.expected: raise NotAnImage() while self.rows_left and self.next_filter < end: start = self.next_filter - self.position rows = min(self.rows_left, (len(block) - start + self.row_size - 1) // self.row_size) # срез вместо цикла: строк может быть 40 млн, а Python проходит их слишком долго if max(block[start:start + rows * self.row_size:self.row_size]) > 4: raise NotAnImage() self.next_filter += rows * self.row_size self.rows_left -= rows if not self.rows_left: self.row_size, self.rows_left = next(self.passes, (0, 0)) self.position = end def check_png(file, max_pixels: int) -> None: inflater = zlib.decompressobj() filters = None seen_palette = False seen_data = False data_finished = False color = None while True: length, kind = struct.unpack(">I4s", read_exact(file, 8)) if length >= 2**31 or not kind.isalpha() or (filters is None and kind != b"IHDR"): raise NotAnImage() # заглавная первая буква значит «без понимания этого блока файл читать нельзя» if kind[0] < 0x61 and kind not in PNG_CRITICAL_CHUNKS: raise NotAnImage() if kind == b"IDAT": if data_finished or (color == 3 and not seen_palette): raise NotAnImage() elif seen_data: data_finished = True # блоки IDAT должны идти подряд crc = zlib.crc32(kind) remaining = length body = b"" while remaining: block = file.read(min(BLOCK, remaining)) if not block: raise NotAnImage() remaining -= len(block) crc = zlib.crc32(block, crc) if kind == b"IHDR" and len(body) <= 13: body += block elif kind == b"IDAT": seen_data = True inflate(inflater, block, filters) if struct.unpack(">I", read_exact(file, 4))[0] != crc: raise NotAnImage() if kind == b"IHDR": if filters is not None or length != 13: raise NotAnImage() width, height, depth, color, compression, filtering, interlace = struct.unpack(">IIBBBBB", body) depths, channels = PNG_COLOR_TYPES.get(color, ((), 0)) if depth not in depths or compression != 0 or filtering != 0 or interlace not in (0, 1): raise NotAnImage() check_size(width, height, max_pixels) filters = ScanlineFilters(png_passes(width, height, depth * channels, interlace == 1)) elif kind == b"PLTE": if seen_palette or seen_data or color in (0, 4) or length == 0 or length % 3 or length > 768: raise NotAnImage() seen_palette = True elif kind == b"IEND": if length != 0: raise NotAnImage() break if not seen_data or not inflater.eof or inflater.unused_data or file.read(1): raise NotAnImage() if filters.position != filters.expected: raise NotAnImage() def inflate(inflater, block: bytes, filters: ScanlineFilters) -> None: """Распаковывает блок и проверяет строки, не накапливая результат.""" while block and not inflater.eof: filters.feed(inflater.decompress(block, BLOCK)) block = inflater.unconsumed_tail def check_jpeg_structure(file, max_pixels: int) -> None: """Быстрая проверка маркеров: размер, число сканов, объём данных. Содержимое проверит декодер.""" file.seek(0, 2) end = file.tell() file.seek(2) frame = None scans = 0 scan_bytes = 0 while True: if read_exact(file, 1) != b"\xff": raise NotAnImage() marker = 0xFF while marker == 0xFF: # перед маркером разрешены байты-заполнители marker = read_exact(file, 1)[0] if marker == 0xD9: # конец изображения; данные после него допустимы, так делают камеры break if 0xD0 <= marker <= 0xD7 or marker == 0x01: continue if marker == 0x00 or marker == 0xD8: raise NotAnImage() length = struct.unpack(">H", read_exact(file, 2))[0] if length < 2 or file.tell() + length - 2 > end: raise NotAnImage() segment = read_exact(file, length - 2) if marker in JPEG_SOF: if frame is not None: raise NotAnImage() frame = marker, parse_frame(segment, max_pixels) if marker == 0xDA: scans += 1 if frame is None or scans > MAX_JPEG_SCANS: raise NotAnImage() scan_bytes += skip_scan(file) if frame is None or not scans: raise NotAnImage() # без этой проверки декодер принял бы заголовки с почти пустым сканом: конец данных он считает предупреждением if frame[0] in JPEG_HUFFMAN_SOF and scan_bytes * 8 < frame[1]: raise NotAnImage() def parse_frame(segment: bytes, max_pixels: int) -> int: """Проверяет заголовок кадра и возвращает число блоков изображения.""" if len(segment) < 6: raise NotAnImage() _, height, width, components = struct.unpack(">BHHB", segment[:6]) if components not in (1, 3, 4) or len(segment) != 6 + 3 * components: raise NotAnImage() check_size(width, height, max_pixels) sampling = [segment[7 + 3 * index] for index in range(components)] horizontal = [value >> 4 for value in sampling] vertical = [value & 0x0F for value in sampling] if not all(1 <= value <= 4 for value in horizontal + vertical): raise NotAnImage() mcu_columns = (width + 8 * max(horizontal) - 1) // (8 * max(horizontal)) mcu_rows = (height + 8 * max(vertical) - 1) // (8 * max(vertical)) return mcu_columns * mcu_rows * sum(h * v for h, v in zip(horizontal, vertical)) def skip_scan(file) -> int: """Проходит сжатые данные скана, оставляет файл на следующем маркере и возвращает их объём.""" begin = file.tell() while True: start = file.tell() block = file.read(BLOCK) if len(block) < 2: raise NotAnImage() position = 0 while True: position = block.find(b"\xff", position) if position < 0: break if position + 1 == len(block): # маркер разрезан границей блока file.seek(start + position) break following = block[position + 1] if following == 0x00 or 0xD0 <= following <= 0xD7: position += 2 elif following == 0xFF: position += 1 else: file.seek(start + position) return start + position - begin def decode_jpeg(file) -> None: """Настоящее декодирование с уменьшением: файл принимается, только если декодер дошёл до конца.""" from PIL import Image # здесь, а не в начале файла: разбор PNG декодера не требует file.seek(0) with decode_lock: try: with Image.open(file, formats=["JPEG"]) as image: image.draft(None, (max(1, image.width // 8), max(1, image.height // 8))) image.load() except MemoryError: raise except Exception as error: # у декодера нет единого исключения: OSError, SyntaxError, ValueError и другие raise NotAnImage() from error def read_exact(file, size: int) -> bytes: data = file.read(size) if len(data) != size: raise NotAnImage() return data