Files
mtusi2026lab5/src/images.py
T
zemiles 13bec4ab8b ЛР 5 — БПИ2303 — Лазарев — на 4
Асинхронная обработка вложений: 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
2026-11-13 16:28:18 +03:00

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")