Асинхронная обработка вложений: RabbitMQ 4.1 (quorum-очереди, publisher confirms, manual ack, DLQ), transactional outbox, отдельный worker. - upload: оригинал в staging S3, затем одной транзакцией queued + jobs + outbox -> 202; API к брокеру не подключается - relay: публикация outbox с confirm, reaper истёкших аренд, redrive - worker: claim по строке jobs, аренда с heartbeat и fencing по lease_token, transform в подпроцессе с RLIMIT_AS/RLIMIT_CPU/таймаутом, thumbnail 256, crop 128, WebP 1280 по детерминированным ключам - retry с backoff и jitter, постоянные/временные ошибки, реестр failed, ops replay (ready не повторяется), DLQ для невалидных сообщений - janitor: очистка staging и сирот; миграция 004 с backfill вложений lab4 - тесты отказов: окна COMMIT/publish, крахи worker до/после S3 и ack, заморозка worker, всплеск загрузок, права брокера; evidence/ и REPORT.md
217 lines
9.3 KiB
Python
217 lines
9.3 KiB
Python
"""Проверка загружаемых изображений по СОДЕРЖИМОМУ, с ограниченной памятью.
|
|
|
|
Заголовок Content-Type клиента — только заявление: настоящий формат определяется
|
|
по сигнатуре и структуре файла. Лимит пикселей проверяется по заголовку (PNG IHDR,
|
|
JPEG SOF) ДО распаковки, поэтому «бомба» 100 000×100 000 не декодируется вовсе.
|
|
|
|
PNG проверяется собственным потоковым валидатором (стандартная библиотека):
|
|
структура и CRC каждого chunk, допустимые IHDR, IDAT распаковывается zlib кусками
|
|
по 1 MiB без сохранения результата; объём распакованных данных должен ТОЧНО совпасть
|
|
с размером, который следует из IHDR (больше — бомба/мусор, меньше — обрезанный файл).
|
|
|
|
JPEG: разбор маркеров до SOF (размеры), затем пробное декодирование Pillow в режиме
|
|
draft (масштаб 1/8): проверяются энтропийные данные, а памяти нужно ~1/64 от полного
|
|
кадра (40 Мпикс -> ~2 MiB вместо ~120 MiB).
|
|
"""
|
|
import struct
|
|
import zlib
|
|
|
|
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
|
JPEG_SOI = b"\xff\xd8\xff"
|
|
READ_CHUNK = 64 * 1024
|
|
INFLATE_STEP = 1024 * 1024
|
|
|
|
# Допустимые глубины цвета по типу цвета PNG и число каналов.
|
|
_PNG_DEPTHS = {0: {1, 2, 4, 8, 16}, 2: {8, 16}, 3: {1, 2, 4, 8}, 4: {8, 16}, 6: {8, 16}}
|
|
_PNG_CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}
|
|
# Adam7: (x0, y0, dx, dy)
|
|
_ADAM7 = ((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))
|
|
_JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
|
|
|
|
|
|
class InvalidImage(Exception):
|
|
"""Файл не является корректным PNG/JPEG заявленного типа -> 415."""
|
|
|
|
|
|
class TooManyPixels(Exception):
|
|
"""Декодированный размер превышает лимит -> 413."""
|
|
|
|
|
|
def sniff(head):
|
|
"""Тип по сигнатуре первых байтов: 'image/png', 'image/jpeg' или None."""
|
|
if head.startswith(PNG_SIGNATURE):
|
|
return "image/png"
|
|
if head.startswith(JPEG_SOI):
|
|
return "image/jpeg"
|
|
return None
|
|
|
|
|
|
def png_header_pixels(head):
|
|
"""Ранняя проверка по первым 33 байтам (сигнатура + IHDR): (w, h) или None."""
|
|
if len(head) < 33 or not head.startswith(PNG_SIGNATURE) or head[12:16] != b"IHDR":
|
|
return None
|
|
return struct.unpack(">II", head[16:24])
|
|
|
|
|
|
def _read_exact(f, n):
|
|
data = f.read(n)
|
|
if len(data) != n:
|
|
raise InvalidImage("truncated")
|
|
return data
|
|
|
|
|
|
def _png_expected_bytes(w, h, bits_per_pixel, interlace):
|
|
def raw(pw, ph):
|
|
return ph * (1 + (pw * bits_per_pixel + 7) // 8) if pw and ph else 0
|
|
if interlace == 0:
|
|
return raw(w, h)
|
|
total = 0
|
|
for x0, y0, dx, dy in _ADAM7:
|
|
pw = (w - x0 + dx - 1) // dx if w > x0 else 0
|
|
ph = (h - y0 + dy - 1) // dy if h > y0 else 0
|
|
total += raw(pw, ph)
|
|
return total
|
|
|
|
|
|
def validate_png(f, size, max_pixels):
|
|
if _read_exact(f, 8) != PNG_SIGNATURE:
|
|
raise InvalidImage("signature")
|
|
pos = 8
|
|
width = height = None
|
|
expected = produced = 0
|
|
inflater = None
|
|
seen_plte = idat_done = False
|
|
color_type = None
|
|
last_type = None
|
|
while True:
|
|
if pos + 12 > size:
|
|
raise InvalidImage("truncated")
|
|
length, ctype = struct.unpack(">I4s", _read_exact(f, 8))
|
|
pos += 8
|
|
if length > 0x7FFFFFFF or pos + length + 4 > size:
|
|
raise InvalidImage("chunk length")
|
|
if not ctype.isalpha():
|
|
raise InvalidImage("chunk type")
|
|
if width is None and ctype != b"IHDR":
|
|
raise InvalidImage("IHDR must be first")
|
|
crc = zlib.crc32(ctype)
|
|
if ctype == b"IDAT":
|
|
if idat_done or (color_type == 3 and not seen_plte):
|
|
raise InvalidImage("IDAT order")
|
|
remaining = length
|
|
while remaining:
|
|
piece = _read_exact(f, min(READ_CHUNK, remaining))
|
|
remaining -= len(piece)
|
|
crc = zlib.crc32(piece, crc)
|
|
buf = piece
|
|
while buf:
|
|
if inflater.eof:
|
|
raise InvalidImage("data after zlib stream")
|
|
try:
|
|
out = inflater.decompress(buf, INFLATE_STEP)
|
|
except zlib.error:
|
|
raise InvalidImage("zlib")
|
|
produced += len(out)
|
|
if produced > expected:
|
|
raise InvalidImage("too much pixel data") # бомба/мусор
|
|
buf = inflater.unconsumed_tail
|
|
else:
|
|
if last_type == b"IDAT":
|
|
idat_done = True
|
|
data = _read_exact(f, length)
|
|
crc = zlib.crc32(data, crc)
|
|
if ctype == b"IHDR":
|
|
if width is not None or length != 13:
|
|
raise InvalidImage("IHDR")
|
|
width, height, depth, color_type, comp, filt, interlace = struct.unpack(">IIBBBBB", data)
|
|
if not (1 <= width <= 0x7FFFFFFF and 1 <= height <= 0x7FFFFFFF):
|
|
raise InvalidImage("dimensions")
|
|
if width * height > max_pixels:
|
|
raise TooManyPixels()
|
|
if depth not in _PNG_DEPTHS.get(color_type, ()) or comp != 0 or filt != 0 or interlace not in (0, 1):
|
|
raise InvalidImage("IHDR values")
|
|
expected = _png_expected_bytes(width, height, _PNG_CHANNELS[color_type] * depth, interlace)
|
|
inflater = zlib.decompressobj()
|
|
elif ctype == b"PLTE":
|
|
seen_plte = True
|
|
elif ctype == b"IEND":
|
|
pass
|
|
elif ctype[0:1].isupper():
|
|
raise InvalidImage("unknown critical chunk") # декодер обязан его понимать
|
|
if struct.unpack(">I", _read_exact(f, 4))[0] != crc & 0xFFFFFFFF:
|
|
raise InvalidImage("crc")
|
|
pos += length + 4
|
|
last_type = ctype
|
|
if ctype == b"IEND":
|
|
break
|
|
if inflater is None or not inflater.eof or produced != expected:
|
|
raise InvalidImage("incomplete pixel data")
|
|
if pos != size:
|
|
raise InvalidImage("trailing data") # полиглоты PNG+что-то ещё не принимаем
|
|
return width, height
|
|
|
|
|
|
def jpeg_dimensions(f, size):
|
|
"""Размеры из первого SOF без декодирования. Ограничено размером файла."""
|
|
if _read_exact(f, 2) != b"\xff\xd8":
|
|
raise InvalidImage("signature")
|
|
pos = 2
|
|
while pos < size:
|
|
b = _read_exact(f, 1)
|
|
pos += 1
|
|
if b != b"\xff":
|
|
raise InvalidImage("marker")
|
|
marker = 0xFF
|
|
while marker == 0xFF:
|
|
marker = _read_exact(f, 1)[0]
|
|
pos += 1
|
|
if marker == 0x01 or 0xD0 <= marker <= 0xD7:
|
|
continue
|
|
if marker in (0xD8, 0xD9, 0xDA):
|
|
raise InvalidImage("no SOF before scan")
|
|
seg_len = struct.unpack(">H", _read_exact(f, 2))[0]
|
|
if seg_len < 2 or pos + seg_len > size:
|
|
raise InvalidImage("segment length")
|
|
if marker in _JPEG_SOF:
|
|
if seg_len < 8:
|
|
raise InvalidImage("SOF")
|
|
_precision, height, width = struct.unpack(">BHH", _read_exact(f, 5))
|
|
if width == 0 or height == 0:
|
|
raise InvalidImage("dimensions") # DNL-высота не поддерживается
|
|
return width, height
|
|
f.seek(seg_len - 2, 1)
|
|
pos += seg_len
|
|
raise InvalidImage("no SOF")
|
|
|
|
|
|
def validate_jpeg(f, size, max_pixels):
|
|
width, height = jpeg_dimensions(f, size)
|
|
if width * height > max_pixels:
|
|
raise TooManyPixels()
|
|
from PIL import Image # импорт по требованию: Pillow нужен только для JPEG
|
|
Image.MAX_IMAGE_PIXELS = max_pixels
|
|
f.seek(0)
|
|
try:
|
|
with Image.open(f, formats=("JPEG",)) as im:
|
|
if im.size != (width, height):
|
|
raise InvalidImage("size mismatch")
|
|
im.draft("RGB", (max(1, width // 8), max(1, height // 8)))
|
|
im.load() # обрезанные/битые энтропийные данные -> OSError
|
|
except InvalidImage:
|
|
raise
|
|
except Exception:
|
|
# Pillow бросает разные исключения (OSError, SyntaxError, ValueError,
|
|
# DecompressionBombError...) — для клиента это одинаково «не JPEG».
|
|
raise InvalidImage("decode")
|
|
return width, height
|
|
|
|
|
|
def validate(f, size, content_type, max_pixels):
|
|
"""(width, height) или InvalidImage/TooManyPixels. f — seekable файл, позиция 0."""
|
|
f.seek(0)
|
|
if content_type == "image/png":
|
|
return validate_png(f, size, max_pixels)
|
|
if content_type == "image/jpeg":
|
|
return validate_jpeg(f, size, max_pixels)
|
|
raise InvalidImage("type")
|