Files
mtusi2026lab7/student-tests/test_attachments.py
T

339 lines
20 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Вложения через балансировщик: корректные файлы, лимиты, битые файлы, подмена MIME, доступ.
Только HTTP, Docker не нужен. Каждый негативный случай проверяет точный код ответа:
пользовательская ошибка не должна становиться 500.
"""
import hashlib
import http.client
import socket
import struct
import urllib.parse
import uuid
import zlib
import images
from common import BASE_URL, https_connection, tls_socket, call, check, new_chat, new_key, new_user, post_message, read_history, run_tests, upload
URL = urllib.parse.urlsplit(BASE_URL)
def setup():
alice, bob, eve = new_user("alice"), new_user("bob"), new_user("eve")
return alice, bob, eve, new_chat(alice, bob)
def sha(data):
return hashlib.sha256(data).hexdigest()
def check_error(reply, code):
check(reply.json["error"]["code"] == code, f"expected error code {code}, got {reply.json['error']['code']}")
def test_png_and_jpeg_roundtrip():
alice, bob, _, chat = setup()
for data, ctype, name in ((images.sample_png(), "image/png", "sample.png"),
(images.sample_jpeg(), "image/jpeg", "sample.jpg"),
(images.progressive_jpeg(), "image/jpeg", "progressive.jpg"),
(images.png(33, 17, interlace=1), "image/png", "interlaced.png"),
(images.png(1, 1, gray=True), "image/png", "1x1.png")):
att = upload(alice, chat["id"], data, ctype, name).json
check(att["status"] == "ready" and att["error_code"] is None, "not ready")
check([v["name"] for v in att["variants"]] == ["thumbnail", "crop", "optimized"], "lab5 variants missing")
check(att["sha256"] == sha(data) and att["size_bytes"] == len(data), "checksum/size differ")
check(att["content_type"] == ctype and att["filename"] == name, "metadata differs")
meta = call("GET", f"/api/v1/attachments/{att['id']}", 200, token=bob["token"]).json
check(meta == att, "GET metadata differs from POST response")
got = call("GET", f"/api/v1/attachments/{att['id']}/content", 200, token=bob["token"])
check(got.data == data, "downloaded bytes differ")
check(got.headers["content-type"] == ctype, "wrong Content-Type on download")
check(got.headers.get("content-length") == str(len(data)), "wrong Content-Length")
check(got.headers.get("x-content-type-options") == "nosniff", "nosniff is missing")
print(f"{name}: {len(data)} bytes, sha256 {att['sha256'][:12]}..., downloaded by the other member, same bytes")
print("PASS: PNG, JPEG, progressive JPEG, interlaced PNG and 1x1 PNG are stored and returned byte for byte")
def test_size_limit_exact_boundary():
alice, _, _, chat = setup()
exact = images.png(64, 64, pad_to=images.MAX_UPLOAD_BYTES)
check(len(exact) == images.MAX_UPLOAD_BYTES, "fixture must be exactly 10 MiB")
att = upload(alice, chat["id"], exact).json
check(att["size_bytes"] == images.MAX_UPLOAD_BYTES and att["sha256"] == sha(exact), "10 MiB file changed")
print(f"exactly {len(exact)} bytes (10 MiB) -> 202, then ready")
over = images.png(64, 64, pad_to=images.MAX_UPLOAD_BYTES + 1)
reply = upload(alice, chat["id"], over, expected=413)
check_error(reply, "payload_too_large")
print(f"{len(over)} bytes (10 MiB + 1) with Content-Length -> 413 before reading the body")
print("PASS: the 10 MiB limit is exact")
def chunked_upload(user, chat_id, total, piece=64 * 1024):
"""Тело без Content-Length (Transfer-Encoding: chunked): сервер узнаёт размер только при чтении."""
conn = https_connection(timeout=60)
def body():
sent = 0
head = images.sample_png()[:64]
yield head
sent += len(head)
while sent < total:
part = bytes(min(piece, total - sent))
sent += len(part)
yield part
try:
conn.request("POST", f"/api/v1/chats/{chat_id}/attachments?filename=big.png", body=body(),
headers={"Content-Type": "image/png", "Authorization": "Bearer " + user["token"]},
encode_chunked=True)
reply = conn.getresponse()
return reply.status, reply.read()
finally:
conn.close()
def test_size_limit_streaming():
alice, _, _, chat = setup()
status, data = chunked_upload(alice, chat["id"], 12 * 1024 * 1024)
check(status == 413 and b"payload_too_large" in data, f"chunked 12 MiB: expected 413, got {status}")
print("12 MiB without Content-Length (chunked) -> 413 as soon as the 10 MiB limit is passed")
call("GET", "/health/ready", 200)
print("PASS: oversized streamed body is cut off, the API keeps working")
def test_pixel_limit():
alice, _, _, chat = setup()
at_limit = images.png(8000, 5000, gray=True) # ровно 40 000 000 пикселей
att = upload(alice, chat["id"], at_limit, filename="40mpx.png").json
print(f"8000x5000 = 40 000 000 pixels ({len(at_limit)} bytes compressed) -> 202, ready {att['id'][:8]}")
over = images.png(8001, 5000, gray=True)
check_error(upload(alice, chat["id"], over, filename="over.png", expected=413), "payload_too_large")
print(f"8001x5000 = 40 005 000 pixels ({len(over)} bytes) -> 413")
bomb = images.png(100_000, 100_000, idat=b"x\x9c\x03\x00\x00\x00\x00\x01")
check_error(upload(alice, chat["id"], bomb, filename="bomb.png", expected=413), "payload_too_large")
print(f"header claims 100000x100000 in {len(bomb)} bytes -> 413 from the header, nothing is decoded")
print("PASS: pixel limit is checked before decompression")
def test_damaged_images():
alice, _, _, chat = setup()
png, jpeg = images.sample_png(), images.sample_jpeg()
cases = [
("PNG cut in half", png[:len(png) // 2], "image/png"),
("PNG without IEND", png[:-12], "image/png"),
("PNG with a flipped byte in IDAT (CRC mismatch)", images.flip_byte(png, len(png) // 2), "image/png"),
("PNG with garbage after IEND", png + b"garbage", "image/png"),
("PNG signature only", png[:8], "image/png"),
("PNG with less pixel data than the header says", images.png(10, 10, idat=zlib.compress(b"\x00" * 5)), "image/png"),
("JPEG cut in half", jpeg[:len(jpeg) // 2], "image/jpeg"),
("JPEG header only", jpeg[:20], "image/jpeg"),
("random bytes", uuid.uuid4().bytes * 100, "image/png"),
("plain text", "это не картинка".encode(), "image/jpeg"),
]
for name, data, ctype in cases:
reply = upload(alice, chat["id"], data, ctype, "broken.bin", expected=415)
check_error(reply, "unsupported_media_type")
print(f"{name} ({len(data)} bytes, {ctype}) -> 415")
check_error(upload(alice, chat["id"], b"", expected=400), "invalid_request")
print("empty body -> 400")
print("PASS: damaged and foreign files are rejected with 415, never 500")
def test_png_chunk_semantics():
"""CRC у всех чанков верные, но содержимое нарушает спецификацию PNG -> 415, а не 201.
Регрессия: PNG 1x1, глубина 8, палитровый, PLTE из 771 байта (257 записей) раньше получал 201 ready,
хотя Pillow его отклоняет (invalid palette size).
"""
alice, bob, _, chat = setup()
from images import assemble, ihdr, zero_idat
pal = lambda entries: (b"PLTE", bytes(3 * entries))
idat_p = zero_idat(1, 1, 8, 1)
bad = [
("PLTE 771 bytes = 257 entries (review case)",
assemble(ihdr(1, 1, 8, 3), (b"PLTE", bytes(771)), (b"IDAT", zlib.compress(b"\0\0")))),
("PLTE length not a multiple of 3", assemble(ihdr(1, 1, 8, 3), (b"PLTE", bytes(4)), idat_p)),
("empty PLTE", assemble(ihdr(1, 1, 8, 3), (b"PLTE", b""), idat_p)),
("palette larger than bit depth allows (depth 1, 3 entries)",
assemble(ihdr(1, 1, 1, 3), pal(3), zero_idat(1, 1, 1, 1))),
("palette image without PLTE", assemble(ihdr(1, 1, 8, 3), idat_p)),
("PLTE in a grayscale image", assemble(ihdr(1, 1, 8, 0), pal(2), zero_idat(1, 1, 8, 1))),
("PLTE after IDAT", assemble(ihdr(1, 1, 8, 3), idat_p, pal(2))),
("two PLTE chunks", assemble(ihdr(1, 1, 8, 3), pal(2), pal(2), idat_p)),
("tRNS longer than the palette", assemble(ihdr(1, 1, 8, 3), pal(2), (b"tRNS", bytes(3)), idat_p)),
("tRNS before PLTE", assemble(ihdr(1, 1, 8, 3), (b"tRNS", bytes(1)), pal(2), idat_p)),
("tRNS of wrong size for RGB (4 bytes instead of 6)",
assemble(ihdr(1, 1, 8, 2), (b"tRNS", bytes(4)), zero_idat(1, 1, 8, 3))),
("tRNS in an image with alpha channel",
assemble(ihdr(1, 1, 8, 6), (b"tRNS", bytes(2)), zero_idat(1, 1, 8, 4))),
("IEND with data", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"IEND", b"x"))),
("unknown critical chunk", assemble(ihdr(1, 1, 8, 2), (b"ABCD", b""), zero_idat(1, 1, 8, 3))),
("IDAT chunks not consecutive",
assemble(ihdr(1, 2, 8, 2), (b"IDAT", zero_idat(1, 2, 8, 3)[1][:5]), (b"tEXt", b"k\0v"),
(b"IDAT", zero_idat(1, 2, 8, 3)[1][5:]))),
("gAMA after IDAT", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"gAMA", bytes(4)))),
("gAMA of 2 bytes instead of 4", assemble(ihdr(1, 1, 8, 2), (b"gAMA", bytes(2)), zero_idat(1, 1, 8, 3))),
("3 MiB metadata chunk before IDAT", assemble(ihdr(1, 1, 8, 2), (b"prVt", bytes(3 * 1024 * 1024)),
zero_idat(1, 1, 8, 3))),
("private chunk after IDAT", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"prVt", bytes(100)))),
("animated PNG frame (fdAT)", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"fdAT", bytes(10)))),
("tIME of 2 bytes instead of 7", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"tIME", bytes(2)))),
("tEXt without keyword separator", assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"tEXt", b"nokey"))),
("zTXt with broken zlib after IDAT",
assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"zTXt", b"k\0\0garbage"))),
("zTXt text bomb: 50 MB of text in ~50 KB after IDAT",
assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"zTXt", b"k\0\0" + zlib.compress(bytes(50_000_000))))),
]
for name, data in bad:
check_error(upload(alice, chat["id"], data, filename="bad.png", expected=415), "unsupported_media_type")
print(f"{name} ({len(data)} bytes, valid CRCs) -> 415")
good = [
("palette 256 entries + tRNS + tEXt and tIME after IDAT",
assemble(ihdr(2, 2, 8, 3), pal(256), (b"tRNS", bytes(256)), zero_idat(2, 2, 8, 1),
(b"tEXt", b"Comment\0ok"), (b"tIME", struct.pack(">HBBBBB", 2026, 10, 22, 12, 0, 0)))),
("palette depth 2 with 4 entries", assemble(ihdr(3, 1, 2, 3), pal(4), zero_idat(3, 1, 2, 1))),
("RGB with 6-byte tRNS and gAMA", assemble(ihdr(1, 1, 8, 2), (b"gAMA", struct.pack(">I", 45455)),
(b"tRNS", bytes(6)), zero_idat(1, 1, 8, 3))),
("compressed zTXt (100 KB of text) and iTXt after IDAT",
assemble(ihdr(1, 1, 8, 2), zero_idat(1, 1, 8, 3), (b"zTXt", b"Comment\0\0" + zlib.compress(b"a" * 100_000)),
(b"iTXt", b"Title\0\1\0ru\0\0" + zlib.compress("Привет".encode())))),
]
for name, data in good:
att = upload(alice, chat["id"], data, filename="good.png").json
got = call("GET", f"/api/v1/attachments/{att['id']}/content", 200, token=bob["token"])
check(got.data == data, "valid PNG changed")
print(f"{name} -> 201, downloaded byte for byte")
print("PASS: chunk contents are checked, not only CRCs; valid PNGs with metadata are still accepted")
def test_mime_substitution():
alice, _, _, chat = setup()
cases = [
("PNG bytes sent as image/jpeg", images.sample_png(), "image/jpeg"),
("JPEG bytes sent as image/png", images.sample_jpeg(), "image/png"),
("GIF bytes sent as image/png", images.GIF, "image/png"),
("PNG sent as image/gif", images.sample_png(), "image/gif"),
("PNG sent as text/html", images.sample_png(), "text/html"),
("PNG sent as application/octet-stream", images.sample_png(), "application/octet-stream"),
("PNG sent as multipart/form-data", images.sample_png(), "multipart/form-data; boundary=x"),
]
for name, data, ctype in cases:
check_error(upload(alice, chat["id"], data, ctype, expected=415), "unsupported_media_type")
print(f"{name} -> 415")
att = upload(alice, chat["id"], images.sample_png(), "IMAGE/PNG; charset=binary").json
check(att["content_type"] == "image/png", "content type must be normalised")
print("PNG sent as 'IMAGE/PNG; charset=binary' -> 201, stored as image/png")
print("PASS: the type is taken from the content; a declared type that does not match is refused")
def test_filenames():
alice, _, _, chat = setup()
bad = ["../../etc/passwd", "a/b.png", "a\\b.png", "a\x00b.png", "line\nbreak.png", "tab\t.png",
"bell\x07.png", "del\x7f.png", "", " ", ".", "..", "x" * 256]
for name in bad:
check_error(upload(alice, chat["id"], images.sample_png(), filename=name, expected=400), "invalid_request")
print(f"{len(bad)} dangerous or invalid names (path, slashes, NUL, control characters, empty, 256 chars) -> 400")
check_error(upload(alice, chat["id"], images.sample_png(), filename=None, expected=400), "invalid_request")
print("no filename -> 400")
for name in ("фото отпуска 😀.png", "x" * 255, "..hidden.png", "a b%20c?.png"):
att = upload(alice, chat["id"], images.sample_png(), filename=name).json
check(att["filename"] == name, "display name changed")
got = call("GET", f"/api/v1/attachments/{att['id']}/content", 200, token=alice["token"])
check("filename*=UTF-8''" in got.headers.get("content-disposition", ""), "Content-Disposition is not encoded")
print("Unicode, 255 chars, leading dots, %20 and ? are kept as display names only")
print("PASS: filename never becomes a path; dangerous names are refused")
def test_access_control():
alice, bob, eve, chat = setup()
att = upload(alice, chat["id"], images.sample_png()).json
for suffix in ("", "/content"):
reply = call("GET", f"/api/v1/attachments/{att['id']}{suffix}", 404, token=eve["token"])
check_error(reply, "not_found")
call("GET", f"/api/v1/attachments/{att['id']}{suffix}", 401)
call("GET", f"/api/v1/attachments/{uuid.uuid4()}{suffix}", 404, token=alice["token"])
call("GET", f"/api/v1/attachments/not-a-uuid{suffix}", 400, token=alice["token"])
print("outsider -> 404 for metadata and bytes (same as a non-existent id); no token -> 401; bad UUID -> 400")
check_error(upload(eve, chat["id"], images.sample_png(), expected=404), "not_found")
check_error(upload(alice, str(uuid.uuid4()), images.sample_png(), expected=404), "not_found")
upload(None, chat["id"], images.sample_png(), expected=401)
print("upload into someone else's / unknown chat -> 404, without token -> 401")
call("GET", f"/api/v1/attachments/{att['id']}/content?variant=preview", 400, token=bob["token"])
for variant in ("original", "thumbnail", "crop", "optimized"):
call("GET", f"/api/v1/attachments/{att['id']}/content?variant={variant}", 200, token=bob["token"])
print("variant=preview -> 400 (not in the contract); original/thumbnail/crop/optimized -> 200 (lab5)")
print("PASS: only chat members can see an attachment")
def test_message_attachments():
alice, bob, eve, chat = setup()
first = upload(alice, chat["id"], images.sample_png()).json
second = upload(bob, chat["id"], images.sample_jpeg(), "image/jpeg", "b.jpg").json
msg = post_message(alice, chat["id"], "", [second["id"], first["id"]]).json
check(msg["attachment_ids"] == [second["id"], first["id"]] and msg["text"] == "", "order or text changed")
print("text='' with 2 attachments -> 201, order kept; any member may attach a file uploaded by another member")
plain = post_message(bob, chat["id"], "без вложений").json
check(plain["attachment_ids"] == [], "default attachment_ids must be []")
reused = post_message(bob, chat["id"], "то же вложение ещё раз", [first["id"]]).json
history, _ = read_history(bob, chat["id"])
check(history == [msg, plain, reused], "history differs from the confirmed messages")
print("history returns attachment_ids for every message, [] for a message without files; reuse is allowed")
other_chat = new_chat(alice, eve)
foreign = upload(alice, other_chat["id"], images.sample_png()).json
for ids, what in (([foreign["id"]], "attachment of another chat (author is a member of both)"),
([first["id"], foreign["id"]], "own + foreign attachment"),
([str(uuid.uuid4())], "unknown attachment_id")):
check_error(post_message(alice, chat["id"], "x", ids, expected=404), "not_found")
print(f"{what} -> 404")
check_error(post_message(eve, chat["id"], "x", [first["id"]], expected=404), "not_found")
print("outsider referencing an attachment of the chat -> 404")
for ids, text, what in (([first["id"], first["id"]], "x", "duplicate ids"),
([str(uuid.uuid4()) for _ in range(11)], "x", "11 ids"),
(["not-a-uuid"], "x", "bad UUID"),
([], "", "empty text without attachments"),
([], " ", "whitespace text without attachments")):
check_error(post_message(alice, chat["id"], text, ids, expected=400), "invalid_request")
print(f"{what} -> 400")
history_after, _ = read_history(bob, chat["id"])
check(history_after == history, "a rejected message was stored")
print("PASS: only attachments of the same chat can be linked; rejected requests change nothing")
def test_idempotency_with_attachments():
alice, bob, _, chat = setup()
att = upload(alice, chat["id"], images.sample_png()).json
other = upload(alice, chat["id"], images.sample_jpeg(), "image/jpeg").json
key = new_key()
first = post_message(alice, chat["id"], "фото", [att["id"]], key=key).json
again = post_message(alice, chat["id"], "фото", [att["id"]], key=key).json
check(again == first, "replay returned a different message")
check_error(post_message(alice, chat["id"], "фото", [other["id"]], key=key, expected=409), "conflict")
check_error(post_message(alice, chat["id"], "фото", [att["id"], other["id"]], key=key, expected=409), "conflict")
key2 = new_key()
plain = post_message(alice, chat["id"], "текст", None, key=key2).json
check(post_message(alice, chat["id"], "текст", [], key=key2).json == plain, "[] must equal a missing field")
history, _ = read_history(bob, chat["id"])
check(len(history) == 2, "replays created extra messages")
print("same key + same attachments -> same 201; other attachments -> 409; missing field == []")
print("PASS: Idempotency-Key covers attachment_ids")
def test_aborted_upload():
alice, _, _, chat = setup()
sock = tls_socket(timeout=10)
head = (f"POST /api/v1/chats/{chat['id']}/attachments?filename=cut.png HTTP/1.1\r\nHost: {URL.hostname}\r\n"
f"Authorization: Bearer {alice['token']}\r\nContent-Type: image/png\r\nContent-Length: 5000000\r\n\r\n")
sock.sendall(head.encode() + images.sample_png() + bytes(1_000_000))
sock.close() # клиент пропал на середине тела
print("sent 1.1 MB of a declared 5 MB body and closed the connection")
att = upload(alice, chat["id"], images.sample_png()).json
call("GET", f"/api/v1/attachments/{att['id']}/content", 200, token=alice["token"])
print("the API keeps serving uploads; nothing of the aborted request is visible "
"(DB/S3 side is checked by test_consistency.py)")
print("PASS: an interrupted upload is dropped")
if __name__ == "__main__":
run_tests([test_png_and_jpeg_roundtrip, test_size_limit_exact_boundary, test_size_limit_streaming,
test_pixel_limit, test_damaged_images, test_png_chunk_semantics, test_mime_substitution, test_filenames, test_access_control,
test_message_attachments, test_idempotency_with_attachments, test_aborted_upload])