Аудит 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:
2026-11-13 20:40:07 +03:00
parent 98aca383b8
commit eac741349a
11 changed files with 321 additions and 30 deletions
+6 -1
View File
@@ -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
View File
@@ -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:
+9
View File
@@ -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
View File
@@ -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
View File
@@ -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):
+52
View File
@@ -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())
+3
View File
@@ -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
View File
@@ -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})
+77
View File
@@ -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()
+6
View File
@@ -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,
+63 -4
View File
@@ -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,))