forked from mtusi2026/mtusi2026lab4
168 lines
7.1 KiB
Python
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:]))
|