Files
mtusi2026lab4/app/tools.py
T

168 lines
7.1 KiB
Python

"""
Служебные проверки хранилища для тестов и защиты (не HTTP API).
Запуск внутри контейнера api (он в сети storage):
python -m app.tools private-check # bucket приватный, права API ограничены
python -m app.tools stats # число объектов / attachments / upload_intents
python -m app.tools state <attachment_id> # есть ли объект, метаданные, журнал
python -m app.tools find-local <sha256> # нет ли на диске реплики копии файла
Секреты не печатаются. Ключи объектов печатаются только для служебного prefix.
"""
from __future__ import annotations
import json
import sys
import urllib.error
import urllib.request
import uuid
import psycopg
from botocore.exceptions import ClientError
from . import storage
from .config import settings
def _anon(method: str, path: str, data: bytes | None = None) -> int:
"""HTTP-запрос к MinIO БЕЗ подписи (как посторонний клиент)."""
req = urllib.request.Request(settings.s3_endpoint.rstrip("/") + path, data=data, method=method)
try:
with urllib.request.urlopen(req, timeout=5) as r:
return r.status
except urllib.error.HTTPError as e:
return e.code
def _denied(fn) -> str:
try:
fn()
return "ALLOWED"
except ClientError as exc:
return exc.response.get("Error", {}).get("Code", "error")
def private_check() -> int:
s3 = storage.client()
bucket = settings.s3_bucket
probe = f"{storage.ORIGINALS_PREFIX}privacy-probe-{uuid.uuid4()}"
results: list[tuple[str, str, bool]] = []
def check(name: str, observed, ok: bool) -> None:
results.append((name, str(observed), ok))
s3.put_object(Bucket=bucket, Key=probe, Body=b"probe", ContentType="text/plain")
try:
# Позитивный контроль: объект существует и API-пользователь его читает.
body = s3.get_object(Bucket=bucket, Key=probe)["Body"].read()
check("API credentials: GET own object", "200", body == b"probe")
# Аноним: ни чтения, ни листинга, ни записи.
st = _anon("GET", f"/{bucket}/{probe}")
check("anonymous GET object", st, st == 403)
st = _anon("GET", f"/{bucket}?list-type=2")
check("anonymous LIST bucket", st, st == 403)
st = _anon("PUT", f"/{bucket}/{storage.ORIGINALS_PREFIX}anon-{uuid.uuid4()}", b"x")
check("anonymous PUT object", st, st == 403)
# Ограниченные права API-пользователя: только объекты своего bucket.
# MinIO без s3:ListAllMyBuckets либо отказывает, либо показывает только
# бакеты, на которые есть права, — чужие бакеты API-пользователь не видит.
try:
names = sorted(b["Name"] for b in s3.list_buckets().get("Buckets", []))
r = "only " + ",".join(names) if names else "empty"
ok = set(names) <= {bucket}
except ClientError as exc:
r = exc.response.get("Error", {}).get("Code", "error")
ok = r == "AccessDenied"
check("API credentials: ListBuckets (no foreign buckets)", r, ok)
r = _denied(lambda: s3.create_bucket(Bucket="lab4-forbidden-" + uuid.uuid4().hex[:8]))
check("API credentials: CreateBucket", r, r == "AccessDenied")
public = json.dumps({"Version": "2012-10-17", "Statement": [{
"Effect": "Allow", "Principal": {"AWS": ["*"]}, "Action": ["s3:GetObject"],
"Resource": [f"arn:aws:s3:::{bucket}/*"]}]})
r = _denied(lambda: s3.put_bucket_policy(Bucket=bucket, Policy=public))
check("API credentials: PutBucketPolicy (make public)", r, r == "AccessDenied")
r = _denied(lambda: s3.delete_bucket(Bucket=bucket))
check("API credentials: DeleteBucket", r, r == "AccessDenied")
finally:
s3.delete_object(Bucket=bucket, Key=probe)
width = max(len(n) for n, _, _ in results)
for name, observed, ok in results:
print(f" {'ok ' if ok else 'FAIL'} {name.ljust(width)} -> {observed}")
failed = sum(1 for _, _, ok in results if not ok)
print(f"\n{len(results) - failed} passed, {failed} failed")
return 1 if failed else 0
def _db():
return psycopg.connect(settings.database_url, connect_timeout=3)
def stats() -> int:
objects = sum(1 for _ in storage.list_sync())
with _db() as conn:
attachments = conn.execute("SELECT count(*) FROM attachments").fetchone()[0]
intents = conn.execute("SELECT count(*) FROM upload_intents").fetchone()[0]
print(json.dumps({"objects": objects, "attachments": attachments, "upload_intents": intents}))
return 0
def state(attachment_id: str) -> int:
key = storage.object_key(uuid.UUID(attachment_id))
with _db() as conn:
att = conn.execute("SELECT 1 FROM attachments WHERE object_key = %s", (key,)).fetchone()
intent = conn.execute("SELECT 1 FROM upload_intents WHERE object_key = %s", (key,)).fetchone()
print(json.dumps({"object_exists": storage.exists_sync(key),
"attachment_row": att is not None, "upload_intent": intent is not None}))
return 0
def find_local(digest: str) -> int:
"""Обойти файловую систему контейнера API и найти файлы с таким SHA-256.
Доказательство, что оригинал не хранится на реплике (только в S3)."""
import hashlib
import os
skip = ("/proc", "/sys", "/dev", "/usr", "/lib", "/bin", "/sbin", "/etc", "/var/lib/dpkg")
scanned, found = 0, []
for root, dirs, files in os.walk("/"):
if root.startswith(skip):
dirs[:] = []
continue
for name in files:
path = os.path.join(root, name)
try:
if not os.path.isfile(path) or os.path.getsize(path) > 32 * 1024 * 1024:
continue
h = hashlib.sha256()
with open(path, "rb") as f:
for block in iter(lambda: f.read(1 << 20), b""):
h.update(block)
scanned += 1
if h.hexdigest() == digest:
found.append(path)
except OSError:
continue
print(json.dumps({"files_scanned": scanned, "copies_found": found}))
return 1 if found else 0
def main(argv: list[str]) -> int:
if not argv:
print(__doc__)
return 2
cmd, args = argv[0], argv[1:]
if cmd == "private-check":
return private_check()
if cmd == "stats":
return stats()
if cmd == "state" and len(args) == 1:
return state(args[0])
if cmd == "find-local" and len(args) == 1:
return find_local(args[0])
print(__doc__)
return 2
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))