diff --git a/.env.example b/.env.example index 01ae5db..f62bd67 100644 --- a/.env.example +++ b/.env.example @@ -43,7 +43,12 @@ MAX_IMAGE_PIXELS=40000000 # Весь приём тела upload, с; одновременных загрузок и JPEG-декодирований на реплику. UPLOAD_TIMEOUT_SECONDS=60 UPLOAD_CONCURRENCY=8 -DECODE_CONCURRENCY=2 +DECODE_CONCURRENCY=1 +# Lab5 (аудит F02): проверка JPEG в подпроцессе — лимит его адресного пространства (MiB), +# CPU-времени (с) и общего времени (с). Progressive JPEG 40 Мпикс 4:4:4 требует ~250 MiB. +JPEG_PROBE_MEMORY_MB=384 +JPEG_PROBE_CPU_SECONDS=10 +JPEG_PROBE_TIMEOUT_SECONDS=15 # Одновременных S3 PUT на реплику (~20 MiB RAM каждый), остальные ждут в очереди. S3_PUT_CONCURRENCY=3 S3_CONNECT_TIMEOUT_SECONDS=2 diff --git a/compose.yaml b/compose.yaml index 62215ae..c90bd9d 100644 --- a/compose.yaml +++ b/compose.yaml @@ -186,7 +186,12 @@ services: S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_api_secret_key UPLOAD_TIMEOUT_SECONDS: ${UPLOAD_TIMEOUT_SECONDS:-60} UPLOAD_CONCURRENCY: ${UPLOAD_CONCURRENCY:-8} - DECODE_CONCURRENCY: ${DECODE_CONCURRENCY:-2} + # Проверка JPEG — в подпроцессе src/jpeg_probe.py (аудит F02): progressive JPEG 40 Мпикс + # 4:4:4 требует до ~250 MiB. Одна проба за раз + её лимит адресного пространства. + DECODE_CONCURRENCY: ${DECODE_CONCURRENCY:-1} + JPEG_PROBE_MEMORY_MB: ${JPEG_PROBE_MEMORY_MB:-384} + JPEG_PROBE_CPU_SECONDS: ${JPEG_PROBE_CPU_SECONDS:-10} + JPEG_PROBE_TIMEOUT_SECONDS: ${JPEG_PROBE_TIMEOUT_SECONDS:-15} S3_PUT_CONCURRENCY: ${S3_PUT_CONCURRENCY:-3} FAULT_INJECTION: ${FAULT_INJECTION:-0} # У API НЕТ доступа к брокеру: задание пишется в outbox PostgreSQL. @@ -201,7 +206,7 @@ services: deploy: replicas: ${API_REPLICAS:-2} resources: - limits: {cpus: "0.5", memory: 256M} + limits: {cpus: "0.5", memory: 512M} # ~100 MiB upload+S3 PUT + проба JPEG до ~260 MiB + запас # Outbox relay + reaper аренд (src/relay.py). Можно масштабировать: SKIP LOCKED + advisory lock. relay: diff --git a/evidence/before-fix/progressive-oom.txt b/evidence/before-fix/progressive-oom.txt new file mode 100644 index 0000000..56e3e15 --- /dev/null +++ b/evidence/before-fix/progressive-oom.txt @@ -0,0 +1,9 @@ +# 2026-11-13T17:39:00Z ДО исправления F02 (коммит 98aca38 + Pillow 13): api 256 MiB, DECODE_CONCURRENCY=2, JPEG декодируется в процессе API +# docker compose --profile tools run --rm checks /app/student-tests/progressive_upload.py (4 progressive 4:4:4 + 1 progressive 4:2:0 + 1 baseline, ~40 Мпикс, одновременно) +до: mtusi-lab5-api-1 restarts=0, mtusi-lab5-api-2 restarts=0 +итог: client.Failure: missing X-Instance-Id (ответ сформировал LB: реплика умерла посреди запроса) +после: mtusi-lab5-api-1 restarts=1, mtusi-lab5-api-2 restarts=1 (обе реплики убиты по памяти cgroup) +api-2 | 2026-11-13 17:34:27,723 INFO listening on 0.0.0.0:8080 instance=5c1cf2d2c351 version=1 env=lab session_ttl=3600s +api-1 | 2026-11-13 17:34:27,608 INFO listening on 0.0.0.0:8080 instance=0da80584b8f1 version=1 env=lab session_ttl=3600s +api-2 | 2026-11-13 17:38:50,736 INFO listening on 0.0.0.0:8080 instance=5c1cf2d2c351 version=1 env=lab session_ttl=3600s +api-1 | 2026-11-13 17:38:51,755 INFO listening on 0.0.0.0:8080 instance=0da80584b8f1 version=1 env=lab session_ttl=3600s diff --git a/requirements.txt b/requirements.txt index b9a5844..31c1aa2 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,11 +1,12 @@ -# Закреплённые версии. +# Закреплённые версии. Lab5 (аудит F04): Pillow 13.0.0 (GHSA-wqgw-9xfh-qf2g, EXIF memory DoS), +# urllib3 2.8.0 (GHSA-vxq7-64xx-v4gw), minio 7.2.20 — совместимая с новым urllib3. # Драйвер PostgreSQL для Python (из lab3). psycopg[binary]==3.2.3 psycopg-pool==3.2.4 # Lab4: S3-клиент (SigV4, multipart) и проверка JPEG (draft-декодирование). -minio==7.2.15 -urllib3==2.3.0 +minio==7.2.20 +urllib3==2.8.0 # Lab5: Pillow также делает варианты (JPEG, WebP — libwebp входит в wheel). -Pillow==11.1.0 +Pillow==13.0.0 # Lab5: клиент AMQP 0-9-1 для RabbitMQ (publisher confirms, manual ack, basic.qos). pika==1.3.2 diff --git a/src/images.py b/src/images.py index d1c8c5b..c7f6eb3 100644 --- a/src/images.py +++ b/src/images.py @@ -10,9 +10,16 @@ PNG проверяется собственным потоковым валид с размером, который следует из IHDR (больше — бомба/мусор, меньше — обрезанный файл). JPEG: разбор маркеров до SOF (размеры), затем пробное декодирование Pillow в режиме -draft (масштаб 1/8): проверяются энтропийные данные, а памяти нужно ~1/64 от полного -кадра (40 Мпикс -> ~2 MiB вместо ~120 MiB). +draft (масштаб 1/8) в ОТДЕЛЬНОМ процессе с лимитами (src/jpeg_probe.py). Для baseline JPEG +draft экономит память, но progressive JPEG держит DCT-коэффициенты всего кадра: до ~250 MiB +на 40 Мпикс (аудит F02) — поэтому не в процессе API. + +PNG (аудит F05): кроме CRC/zlib/объёма проверяется байт фильтра КАЖДОЙ строки (0..4), +включая проходы Adam7, а также PLTE (кратна 3, <= 256 записей) и пустой IEND. """ +import os +import subprocess +import sys import struct import zlib @@ -37,6 +44,14 @@ class TooManyPixels(Exception): """Декодированный размер превышает лимит -> 413.""" +class ResourceLimit(Exception): + """Проверка не уложилась в лимиты памяти/времени -> 413 (вход слишком тяжёлый).""" + + +JPEG_PROBE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "jpeg_probe.py") +JPEG_PROBE_TIMEOUT_SECONDS = float(os.environ.get("JPEG_PROBE_TIMEOUT_SECONDS", "15")) + + def sniff(head): """Тип по сигнатуре первых байтов: 'image/png', 'image/jpeg' или None.""" if head.startswith(PNG_SIGNATURE): @@ -60,6 +75,49 @@ def _read_exact(f, n): return data +def _png_passes(w, h, bits_per_pixel, interlace): + """[(строк, байт в строке вместе с байтом фильтра)] для каждого непустого прохода.""" + def row(pw): + return 1 + (pw * bits_per_pixel + 7) // 8 + if interlace == 0: + return [(h, row(w))] + out = [] + 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 + if pw and ph: + out.append((ph, row(pw))) + return out + + +class _FilterCheck: + """Байт фильтра в начале каждой строки распакованных данных PNG должен быть 0..4. + Проверка срезами bytes[first::rowbytes] — скорость C, без цикла Python по строкам + (иначе PNG 1x40 000 000 стал бы атакой на CPU).""" + + def __init__(self, passes): + self.passes = passes + self.index = 0 + self.offset = 0 # байт уже пройдено в текущем проходе + + def feed(self, out): + i, n = 0, len(out) + while i < n: + if self.index >= len(self.passes): + raise InvalidImage("too much pixel data") + rows, rb = self.passes[self.index] + total = rows * rb + take = min(n - i, total - self.offset) + first = (-self.offset) % rb + if first < take and max(out[i + first:i + take:rb]) > 4: + raise InvalidImage("bad filter type") + i += take + self.offset += take + if self.offset == total: + self.index += 1 + self.offset = 0 + + 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 @@ -114,6 +172,7 @@ def validate_png(f, size, max_pixels): produced += len(out) if produced > expected: raise InvalidImage("too much pixel data") # бомба/мусор + filters.feed(out) buf = inflater.unconsumed_tail else: if last_type == b"IDAT": @@ -131,11 +190,17 @@ def validate_png(f, size, max_pixels): 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) + filters = _FilterCheck(_png_passes(width, height, _PNG_CHANNELS[color_type] * depth, interlace)) inflater = zlib.decompressobj() elif ctype == b"PLTE": + # PLTE: кратна 3, 1..256 записей, только одна, не для серых типов, до IDAT. + if seen_plte or length == 0 or length % 3 or length > 768 or color_type in (0, 4) \ + or last_type == b"IDAT" or idat_done: + raise InvalidImage("PLTE") seen_plte = True elif ctype == b"IEND": - pass + if length != 0: + raise InvalidImage("IEND") elif ctype[0:1].isupper(): raise InvalidImage("unknown critical chunk") # декодер обязан его понимать if struct.unpack(">I", _read_exact(f, 4))[0] != crc & 0xFFFFFFFF: @@ -188,22 +253,23 @@ 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 + if not hasattr(f, "fileno"): + raise InvalidImage("probe needs a real file") + f.flush() 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». + # stdin подпроцесса — тот же временный файл (анонимный, O_TMPFILE): байты не копируются. + proc = subprocess.run([sys.executable, JPEG_PROBE, str(max_pixels), str(width), str(height)], + stdin=f, capture_output=True, timeout=JPEG_PROBE_TIMEOUT_SECONDS, check=False) + except subprocess.TimeoutExpired: + raise ResourceLimit("timeout") + finally: + f.seek(0) + if proc.returncode == 0: + return width, height + if proc.returncode == 3: raise InvalidImage("decode") - return width, height + raise ResourceLimit("probe exit %d" % proc.returncode) # 5 или убит сигналом (RLIMIT/OOM) def validate(f, size, content_type, max_pixels): diff --git a/src/jpeg_probe.py b/src/jpeg_probe.py new file mode 100644 index 0000000..640ef44 --- /dev/null +++ b/src/jpeg_probe.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +"""Пробное декодирование JPEG в ОТДЕЛЬНОМ процессе с лимитами (аудит F02). + + python jpeg_probe.py < файл на stdin (обычный файл, seekable) + +API раньше декодировал JPEG в своём процессе, рассчитывая, что draft(1/8) уменьшает +память в ~64 раза. Для progressive JPEG это неверно: декодеру нужен буфер DCT- +коэффициентов ВСЕГО кадра. Замер на Pillow 13, 6324x6324 (~40 Мпикс): baseline — 23 MiB, +progressive 4:2:0 — 137 MiB, progressive 4:4:4 — 252 MiB на одно декодирование, а лимит +реплики был 256 MiB. Поэтому проверка вынесена в подпроцесс: + * RLIMIT_AS / RLIMIT_CPU ставятся ДО импорта Pillow; + * oom_score_adj=1000: если памяти контейнера всё же не хватит, ядро убьёт пробу, а не API; + * код выхода: 0 — корректный JPEG; 3 — повреждён/не тот формат; 5 — не хватило памяти/CPU. +""" +import os +import resource +import sys + +EXIT_OK, EXIT_INVALID, EXIT_RESOURCE = 0, 3, 5 + + +def main(): + max_pixels, width, height = (int(x) for x in sys.argv[1:4]) + limit = int(os.environ.get("JPEG_PROBE_MEMORY_MB", "384")) * 1024 * 1024 + cpu = int(os.environ.get("JPEG_PROBE_CPU_SECONDS", "10")) + resource.setrlimit(resource.RLIMIT_AS, (limit, limit)) + resource.setrlimit(resource.RLIMIT_CPU, (cpu, cpu + 1)) + try: + with open("/proc/self/oom_score_adj", "w") as f: + f.write("1000") + except OSError: + pass + import warnings + from PIL import Image + Image.MAX_IMAGE_PIXELS = max_pixels + warnings.simplefilter("error", Image.DecompressionBombWarning) + src = os.fdopen(0, "rb", closefd=False) + try: + with Image.open(src, formats=("JPEG",)) as im: + if im.size != (width, height): + return EXIT_INVALID + im.draft("RGB", (max(1, width // 8), max(1, height // 8))) + im.load() # обрезанные/битые энтропийные данные -> исключение + except MemoryError: + return EXIT_RESOURCE + except Exception: + return EXIT_INVALID + return EXIT_OK + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/server.py b/src/server.py index 2cc7f07..58360ff 100644 --- a/src/server.py +++ b/src/server.py @@ -657,6 +657,9 @@ def h_upload_attachment(req, chat_id): width, height = images.validate(tmp, length, ctype, MAX_IMAGE_PIXELS) except images.TooManyPixels: raise ApiError(413, "payload_too_large", "Изображение больше 40 млн пикселей") + except images.ResourceLimit as exc: + log.warning("image check exceeded limits (%s) request_id=%s", exc, req.request_id) + raise ApiError(413, "payload_too_large", "Изображение требует слишком много ресурсов для проверки") except images.InvalidImage as exc: log.info("rejected image (%s) request_id=%s", exc, req.request_id) raise ApiError(415, "unsupported_media_type", "Файл повреждён или не является PNG/JPEG") diff --git a/src/transform.py b/src/transform.py index c2b356e..970a3d2 100644 --- a/src/transform.py +++ b/src/transform.py @@ -18,8 +18,11 @@ Worker запускает его через subprocess с таймаутом JOB (320x200 -> 256x160); EXIF orientation применяется; alpha -> на белый фон; crop — JPEG q=85, центрированный квадрат 128x128 (маленькие исходники увеличиваются); optimized — WebP q=80 method=4, вписан в 1280x1280 без увеличения; alpha сохраняется. -Во все варианты НЕ переносятся EXIF/XMP/ICC/комментарии: Pillow пишет метаданные только -если их явно передать (exif=, icc_profile=), мы их не передаём. Цвет считается sRGB. +Во все варианты НЕ переносятся EXIF/XMP/ICC/комментарии. Одного «не передавать exif=» мало: +Pillow при save() берёт часть метаданных из im.info (так JPEG-комментарий доходил до +thumbnail и crop — аудит F07). Поэтому перед сохранением info очищается полностью, а тест +проверяет сырые байты результата (маркеры COM/APP1/APP2, чанки EXIF/XMP/ICCP). +Прозрачность: RGBA/LA/PA и ЛЮБОЙ режим с tRNS (P, RGB, L — аудит F06). Цвет считается sRGB. """ import json import os @@ -80,7 +83,8 @@ def main(): im.load() if orientation in range(2, 9): im = ImageOps.exif_transpose(im) - has_alpha = im.mode in ("RGBA", "LA", "PA") or (im.mode == "P" and "transparency" in im.info) + # tRNS бывает не только у палитры: у RGB и L это «прозрачный цвет» (аудит F06). + has_alpha = im.mode in ("RGBA", "LA", "PA") or "transparency" in im.info work = im.convert("RGBA") if has_alpha else im.convert("RGB") del im # Промежуточная копия <= 1280: из неё делаются все варианты (экономия памяти и CPU). @@ -92,13 +96,17 @@ def main(): flat.paste(work, mask=work.getchannel("A")) else: flat = work + work.info = {} # без метаданных источника (EXIF, XMP, ICC, comment...) + flat.info = {} variants = [] tw, th = fit_within(ow, oh, THUMB) thumb = flat if flat.size == (tw, th) else flat.resize((tw, th), Image.LANCZOS) path = os.path.join(out_dir, "thumbnail.jpg") + thumb.info = {} thumb.save(path, "JPEG", quality=JPEG_QUALITY, optimize=True) variants.append({"name": "thumbnail", "path": path, "content_type": "image/jpeg", "width": tw, "height": th}) crop = ImageOps.fit(flat, (CROP, CROP), method=Image.LANCZOS, centering=(0.5, 0.5)) + crop.info = {} path = os.path.join(out_dir, "crop.jpg") crop.save(path, "JPEG", quality=JPEG_QUALITY, optimize=True) variants.append({"name": "crop", "path": path, "content_type": "image/jpeg", "width": CROP, "height": CROP}) diff --git a/student-tests/progressive_upload.py b/student-tests/progressive_upload.py new file mode 100644 index 0000000..1485a28 --- /dev/null +++ b/student-tests/progressive_upload.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Аудит F02: допустимые по контракту progressive JPEG ~40 Мпикс не должны ронять API. + + docker compose --profile tools run --rm checks /app/student-tests/progressive_upload.py \ + --base-url http://lb:8080 --output /app/evidence/progressive-upload.json + +Файлы маленькие (~0,5–0,9 MB, гладкая картинка), но декодирование progressive JPEG требует +буфер коэффициентов всего кадра: 4:2:0 ~140 MiB, 4:4:4 ~250 MiB (замер на Pillow 13). +Одновременно загружаются 4 progressive 4:4:4 + 1 progressive 4:2:0 + 1 baseline: при двух +репликах за round-robin LB на каждую приходится по 2 тяжёлых декодирования одновременно. Ожидаем: +все 202, все ready, thumbnail 256x256. Что реплики API не были убиты (RestartCount, OOMKilled), +проверяет хост-обёртка api_negative_lab5.py. +""" +import argparse +import concurrent.futures +import io +import json +import sys +import time +from pathlib import Path + +sys.path.insert(0, "/app/tests") +from client import Client, check # noqa: E402 +from PIL import Image # noqa: E402 + +SIDE = 6324 # 39 992 976 пикселей (< 40 000 000) + + +def make(kind, seed): + g = Image.radial_gradient("L").resize((SIDE, SIDE)) + img = Image.merge("RGB", (g, g.rotate(90 * seed), g.transpose(Image.Transpose.FLIP_TOP_BOTTOM))) + kw = {"baseline": {}, "progressive_420": {"progressive": True}, + "progressive_444": {"progressive": True, "subsampling": 0}}[kind] + buf = io.BytesIO() + img.save(buf, "JPEG", quality=85, **kw) + return buf.getvalue() + + +def main(): + p = argparse.ArgumentParser() + p.add_argument("--base-url", default="http://lb:8080") + p.add_argument("--output") + args = p.parse_args() + c = Client(args.base_url, timeout=60) + alice, bob, _eve, chat = c.bootstrap() + files = [("progressive_444", make("progressive_444", i)) for i in range(4)] + \ + [("progressive_420", make("progressive_420", 1)), ("baseline", make("baseline", 0))] + + def up(item): + kind, data = item + t = time.monotonic() + r = c.call("POST", "/api/v1/chats/%s/attachments?filename=%s.jpg" % (chat["id"], kind), [202, 413, 502, 503, 504], + actor=alice, raw=data, headers={"Content-Type": "image/jpeg"}, schema="Attachment") + return {"kind": kind, "bytes": len(data), "status": r["status"], "seconds": round(time.monotonic() - t, 2), + "instance": r["headers"].get("X-Instance-Id"), + "id": r["json"]["id"] if r["status"] == 202 else None, + "error": r["json"]["error"]["code"] if r["status"] != 202 else None} + + with concurrent.futures.ThreadPoolExecutor(len(files)) as pool: + results = list(pool.map(up, files)) + for r in results: + print(json.dumps(r), flush=True) + for r in results: + check(r["status"] == 202, "%s upload: %s %s" % (r["kind"], r["status"], r["error"])) + for r in results: + att = c.wait_ready(bob, {"id": r["id"]}, wait_seconds=120) + thumb = [v for v in att["variants"] if v["name"] == "thumbnail"][0] + check((thumb["width"], thumb["height"]) == (256, 256), "thumbnail size") + r["ready"] = True + if args.output: + Path(args.output).write_text(json.dumps({"side": SIDE, "pixels": SIDE * SIDE, "uploads": results}, + indent=1) + "\n") + print("PASS: %d concurrent ~40 Mpx JPEG (progressive 4:4:4/4:2:0, baseline) -> 202 -> ready" % len(results)) + + +if __name__ == "__main__": + main() diff --git a/student-tests/transform_limits.py b/student-tests/transform_limits.py index c620a78..4c59f1d 100644 --- a/student-tests/transform_limits.py +++ b/student-tests/transform_limits.py @@ -63,8 +63,14 @@ def main(): n = Image.effect_noise((6300, 6300), 80) Image.merge("RGBA", [n, n.transpose(Image.Transpose.ROTATE_90), n, n]).save(buf, "PNG", compress_level=1) heavy = buf.getvalue() + # Аудит F02: progressive 4:4:4 ~40 Мпикс — допустимый вход, ~250 MiB на декодирование. + g = Image.radial_gradient("L").resize((6324, 6324)) + buf = io.BytesIO() + Image.merge("RGB", (g, g.rotate(90), g)).save(buf, "JPEG", quality=85, progressive=True, subsampling=0) + prog = buf.getvalue() cases = [ ("valid 640x480", ok, "image/png", {}, 40000000, "ok"), + ("40 Mpx progressive 4:4:4 JPEG, default limits", prog, "image/jpeg", {}, 40000000, "ok"), ("49 Mpx PNG (> MAX_IMAGE_PIXELS)", png((7000, 7000)), "image/png", {}, 40000000, "image_too_large"), ("36 Mpx PNG, normal limits", big, "image/png", {}, 40000000, "ok"), ("36 Mpx PNG, memory limit 160 MiB", big, "image/png", {"TRANSFORM_MEMORY_LIMIT_MB": "160"}, 40000000, diff --git a/student-tests/variants_check.py b/student-tests/variants_check.py index 2bac449..2a75ddc 100644 --- a/student-tests/variants_check.py +++ b/student-tests/variants_check.py @@ -7,7 +7,10 @@ Для каждого входа: ready, ровно 3 варианта, метаданные = фактическим байтам (размер, SHA-256, декодированные размеры, формат), оригинал неизменен. Thumbnail: JPEG, вписан в 256x256 без увеличения, округление вниз; EXIF orientation применена; alpha -> белый. Crop: JPEG 128x128. -Optimized: WebP, вписан в 1280x1280 без увеличения. В вариантах нет EXIF/ICC. +Optimized: WebP, вписан в 1280x1280 без увеличения. В вариантах нет метаданных — проверяются +СЫРЫЕ байты (аудит F07): в JPEG нет маркеров COM, APP1 (Exif/XMP), APP2 (ICC); в WebP нет +чанков EXIF, XMP, ICCP. Прозрачность tRNS у RGB и L (аудит F06) тоже даёт белый фон в JPEG +и alpha=0 в WebP. """ import argparse import hashlib @@ -36,6 +39,36 @@ def encode(img, fmt, **kw): return buf.getvalue() +def jpeg_markers(b): + """Маркеры сегментов JPEG до начала скана (SOS).""" + out, i = [], 2 + while i + 4 <= len(b) and b[i] == 0xFF: + m = b[i + 1] + if m == 0xDA: + break + out.append(m) + i += 2 + int.from_bytes(b[i + 2:i + 4], "big") + return out + + +def webp_chunks(b): + out, i = [], 12 + while i + 8 <= len(b): + name, size = b[i:i + 4], int.from_bytes(b[i + 4:i + 8], "little") + out.append(name.decode("latin-1")) + i += 8 + size + (size & 1) + return out + + +def no_metadata(b, fmt): + if fmt == "JPEG": + bad = {0xFE: "COM", 0xE1: "APP1", 0xE2: "APP2"} + found = [bad[m] for m in jpeg_markers(b) if m in bad] + else: + found = [c for c in webp_chunks(b) if c.strip() in ("EXIF", "XMP", "ICCP")] + return found + + def cases(): out = [("fixture 320x200 PNG", FIXTURE, "image/png", (320, 200), None)] # RGBA: левая половина прозрачная -> в JPEG должна стать белой. @@ -51,6 +84,21 @@ def cases(): exif[0x010F] = "MTUSI test camera" # Make: проверяем, что EXIF не утёк в варианты out.append(("JPEG 400x200 EXIF orientation=6", encode(raw, "JPEG", quality=95, exif=exif.tobytes()), "image/jpeg", (200, 400), "orientation")) + # Все виды метаданных сразу: комментарий, EXIF, XMP, ICC (аудит F07). + from PIL import ImageCms + icc = ImageCms.ImageCmsProfile(ImageCms.createProfile("sRGB")).tobytes() + meta = Image.new("RGB", (500, 300), (30, 90, 160)) + meta_exif = Image.Exif() + meta_exif[0x010F] = "PRIVATE-CAMERA" # Make, без orientation + out.append(("JPEG with COM+EXIF+XMP+ICC", encode(meta, "JPEG", quality=90, comment=b"PRIVATE-COMMENT", + exif=meta_exif.tobytes(), icc_profile=icc, + xmp=b"PRIVATE-XMP"), + "image/jpeg", (500, 300), "metadata")) + # tRNS у RGB и L (аудит F06): весь кадр — «прозрачный цвет». + out.append(("RGB PNG with tRNS (fully transparent)", encode(Image.new("RGB", (300, 200), (255, 0, 0)), "PNG", + transparency=(255, 0, 0)), "image/png", (300, 200), "alpha_full")) + out.append(("L PNG with tRNS (fully transparent)", encode(Image.new("L", (200, 300), 0), "PNG", transparency=0), + "image/png", (200, 300), "alpha_full")) out.append(("tiny PNG 10x5 (no upscale)", encode(Image.new("RGB", (10, 5), (9, 200, 9)), "PNG"), "image/png", (10, 5), None)) big = Image.radial_gradient("L").resize((3000, 2000)).convert("RGB") @@ -102,9 +150,20 @@ def main(): check((v["width"], v["height"]) == size == img.size, "%s %s: size %s meta %s expected %s" % ( name, v["name"], img.size, (v["width"], v["height"]), size)) check(v["size_bytes"] == len(b) and v["sha256"] == hashlib.sha256(b).hexdigest(), name + ": checksum") - no_meta = not img.getexif() and "icc_profile" not in img.info and "exif" not in img.info - check(no_meta, name + ": metadata leaked into " + v["name"]) - item = {"size": list(img.size), "format": fmt, "bytes": len(b), "no_exif_icc": no_meta} + leaked = no_metadata(b, fmt) + check(not leaked and not img.getexif() and "icc_profile" not in img.info, + "%s: metadata leaked into %s: %s" % (name, v["name"], leaked)) + check(b"PRIVATE" not in b, name + ": private text found in bytes of " + v["name"]) + item = {"size": list(img.size), "format": fmt, "bytes": len(b), "metadata_markers": leaked} + if special == "alpha_full": + if v["name"] == "optimized": + a = img.convert("RGBA").getpixel((img.size[0] // 2, img.size[1] // 2))[3] + check(a == 0, name + ": WebP alpha must be 0, got %d" % a) + item["webp_alpha"] = a + else: + px = img.convert("RGB").getpixel((img.size[0] // 2, img.size[1] // 2)) + check(min(px) >= 245, name + ": transparent area is not white: %s" % (px,)) + item["center_rgb"] = list(px) if special == "alpha" and v["name"] in ("thumbnail", "crop"): px = img.convert("RGB").getpixel((1, img.size[1] // 2)) check(min(px) >= 245, name + ": transparent area is not white: %s" % (px,))