forked from mtusi2026/mtusi2026lab5
Аудит F02, F04–F07: проверка JPEG в подпроцессе, фильтры PNG, tRNS, метаданные
- F04: Pillow 13.0.0, urllib3 2.8.0, minio 7.2.20 - F02: пробное декодирование JPEG вынесено в src/jpeg_probe.py (RLIMIT_AS, RLIMIT_CPU, oom_score_adj); замер progressive 4:4:4 ~40 Мпикс — 252 MiB; DECODE_CONCURRENCY=1, память API 512 MiB; до исправления 6 одновременных загрузок убивали обе реплики (evidence/before-fix/progressive-oom.txt) - F05: проверка байта фильтра каждой строки PNG (включая Adam7), PLTE, IEND - F06: прозрачность tRNS у RGB и L - F07: info очищается перед сохранением вариантов; тест проверяет сырые маркеры JPEG и чанки WebP
This commit is contained in:
+6
-1
@@ -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
|
||||
|
||||
+7
-2
@@ -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:
|
||||
|
||||
@@ -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
|
||||
+5
-4
@@ -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
|
||||
|
||||
+82
-16
@@ -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):
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Пробное декодирование JPEG в ОТДЕЛЬНОМ процессе с лимитами (аудит F02).
|
||||
|
||||
python jpeg_probe.py <max_pixels> <width> <height> < файл на 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())
|
||||
@@ -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")
|
||||
|
||||
+11
-3
@@ -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})
|
||||
|
||||
@@ -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()
|
||||
@@ -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,
|
||||
|
||||
@@ -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"<x:xmpmeta xmlns:x='adobe:ns:meta/'>PRIVATE-XMP</x:xmpmeta>"),
|
||||
"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,))
|
||||
|
||||
Reference in New Issue
Block a user