forked from mtusi2026/mtusi2026lab7
303 lines
12 KiB
Python
303 lines
12 KiB
Python
"""Сквозные проверки защиты для запущенного HTTPS-стенда."""
|
||
|
||
import argparse
|
||
import base64
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
import hashlib
|
||
import json
|
||
from pathlib import Path
|
||
import ssl
|
||
import time
|
||
from urllib.error import HTTPError, URLError
|
||
from urllib.parse import urlsplit
|
||
from urllib.request import Request, urlopen
|
||
|
||
from scripts.deployment import ComposeProject
|
||
from tests.client import Client
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
TLS = ROOT / "secrets/tls"
|
||
|
||
|
||
WORKER_SCOPE_PROBE = """
|
||
import asyncio
|
||
import io
|
||
|
||
from minio.error import S3Error
|
||
from sqlalchemy import text
|
||
from sqlalchemy.exc import DBAPIError
|
||
|
||
from app.core.bao import database_secret
|
||
from app.core.config import Settings
|
||
from app.core.database import create_db_engine
|
||
from app.storage.s3 import create_s3_storage
|
||
|
||
|
||
async def probe():
|
||
settings = Settings(**database_secret())
|
||
engine = create_db_engine(settings)
|
||
try:
|
||
async with engine.connect() as connection:
|
||
assert (await connection.execute(text("SELECT 1"))).scalar() == 1
|
||
try:
|
||
await connection.execute(text("SELECT 1 FROM users LIMIT 1"))
|
||
except DBAPIError as error:
|
||
assert error.orig.sqlstate == "42501"
|
||
else:
|
||
raise AssertionError("Worker имеет доступ к users")
|
||
finally:
|
||
await engine.dispose()
|
||
|
||
storage = create_s3_storage(settings.s3)
|
||
try:
|
||
try:
|
||
storage._client.put_object(settings.s3.bucket, "outside-security-probe",
|
||
io.BytesIO(b"x"), 1)
|
||
except S3Error as error:
|
||
assert error.code == "AccessDenied"
|
||
else:
|
||
raise AssertionError("Worker может записать вне разрешённых префиксов")
|
||
finally:
|
||
await storage.aclose()
|
||
|
||
|
||
asyncio.run(probe())
|
||
"""
|
||
|
||
|
||
ROOTFS_PROBE = """
|
||
from os import ST_RDONLY, statvfs
|
||
from tempfile import TemporaryFile
|
||
|
||
assert statvfs("/app").f_flag & ST_RDONLY
|
||
with TemporaryFile(dir="/tmp") as temporary:
|
||
temporary.write(b"tmpfs probe")
|
||
"""
|
||
|
||
API_BROKER_PROBE = """
|
||
import asyncio
|
||
from app.core.jobs import JobSettings
|
||
from app.storage.broker import connect_broker
|
||
|
||
|
||
async def probe():
|
||
async with await connect_broker(JobSettings()) as connection:
|
||
assert not connection.is_closed
|
||
|
||
|
||
asyncio.run(probe())
|
||
"""
|
||
|
||
|
||
def probe_deployment(project: ComposeProject) -> None:
|
||
services = project.config["services"]
|
||
for name in ("api", "worker"):
|
||
service = services[name]
|
||
assert not service.get("ports")
|
||
assert "ALL" in service["cap_drop"] and service["read_only"]
|
||
assert "no-new-privileges:true" in service["security_opt"]
|
||
assert service["tmpfs"]
|
||
assert service["deploy"]["resources"]["limits"]["memory"]
|
||
uid = project.run("exec", "-T", name, "id", "-u")
|
||
assert int(uid) > 0
|
||
project.run("exec", "-T", name, "python", "-c", ROOTFS_PROBE)
|
||
for service in services.values():
|
||
assert not service.get("privileged") and service.get("network_mode") != "host"
|
||
assert all(mount["target"] != "/var/run/docker.sock"
|
||
for mount in service.get("volumes", ()))
|
||
project.run("exec", "-T", "worker", "python", "-c", WORKER_SCOPE_PROBE)
|
||
print("PASS: ограничения контейнеров, роли PostgreSQL и префиксы S3")
|
||
|
||
|
||
def probe_mtls(project: ComposeProject) -> None:
|
||
replicas = project.replicas()
|
||
network = project.name + "_default"
|
||
addresses = [
|
||
project.docker("inspect", "--format",
|
||
'{{(index .NetworkSettings.Networks "' + network + '").IPAddress}}',
|
||
replica.id)
|
||
for replica in replicas
|
||
]
|
||
command = [
|
||
"run", "--rm", "--network", network,
|
||
"-v", f"{ROOT / 'scripts/check_mtls.py'}:/check.py:ro",
|
||
"-v", f"{TLS / 'ca.crt'}:/certificates/ca.crt:ro",
|
||
]
|
||
for identity in ("load-balancer", "foreign-client", "wrong-role"):
|
||
for extension in ("key", "crt"):
|
||
name = f"{identity}.{extension}"
|
||
command.extend(("-v", f"{TLS / name}:/certificates/{name}:ro"))
|
||
image = project.config["services"]["api"]["image"]
|
||
output = project.docker(*command, image, "python", "/check.py", *addresses)
|
||
print(output)
|
||
|
||
|
||
def audit_dependencies(project: ComposeProject) -> None:
|
||
command = ["run", "--rm", "--network", project.name + "_default",
|
||
"--network", project.name + "_objects",
|
||
"-v", f"{ROOT / 'scripts/audit_tls.py'}:/app/audit_tls.py:ro",
|
||
"-v", f"{TLS / 'ca.crt'}:/certificates/ca.crt:ro"]
|
||
for role in ("otel-api", "otel-worker", "otel-publisher", "otel-wrong-role",
|
||
"otel-reader", "otel-writer", "otel-scraper", "api-broker",
|
||
"attachment-worker", "attachment-publisher", "broker-wrong-role", "foreign-client"):
|
||
for extension in ("crt", "key"):
|
||
name = f"{role}.{extension}"
|
||
command.extend(("-v", f"{TLS / name}:/certificates/{name}:ro"))
|
||
project.run("exec", "-T", "api", "python", "-c", API_BROKER_PROBE)
|
||
image = project.config["services"]["api"]["image"]
|
||
print(project.docker(*command, image, "python", "-m", "audit_tls"))
|
||
|
||
|
||
def probe_bao(port: int) -> None:
|
||
def call(context, path, *, token=None, data=None):
|
||
headers = {"Content-Type": "application/json"}
|
||
if token:
|
||
headers["X-Vault-Token"] = token
|
||
request = Request(f"https://localhost:{port}/v1/{path}", headers=headers,
|
||
data=None if data is None else json.dumps(data).encode())
|
||
with urlopen(request, context=context, timeout=5) as response:
|
||
return json.load(response)
|
||
|
||
for role, other in (("api", "worker"), ("worker", "api")):
|
||
context = ssl.create_default_context(cafile=str(TLS / "ca.crt"))
|
||
context.load_cert_chain(TLS / f"{role}-bao.crt", TLS / f"{role}-bao.key")
|
||
try:
|
||
call(context, "auth/cert/login", data={"name": other})
|
||
except HTTPError as error:
|
||
assert error.code in (400, 403)
|
||
else:
|
||
raise AssertionError("OpenBao принял чужую cert-роль")
|
||
login = call(context, "auth/cert/login", data={"name": role})["auth"]
|
||
assert login["token_policies"] == [role] and 0 < login["lease_duration"] <= 600
|
||
token = login["client_token"]
|
||
assert call(context, f"messenger/data/{role}", token=token)["data"]["data"]["db_password"]
|
||
for path, body in ((f"messenger/data/{other}", None),
|
||
(f"messenger/data/{role}", {"data": {"db_password": "denied"}}),
|
||
("sys/policies/acl/denied-probe", {"policy": ""})):
|
||
try:
|
||
call(context, path, data=body, token=token)
|
||
except HTTPError as error:
|
||
assert error.code == 403
|
||
else:
|
||
raise AssertionError(f"OpenBao разрешил {path}")
|
||
print("PASS: OpenBao cert roles, KV allow/deny, TTL")
|
||
|
||
|
||
def probe_http(base: str, project: ComposeProject) -> None:
|
||
cafile = str(TLS / "ca.crt")
|
||
tls = ssl.create_default_context(cafile=cafile)
|
||
port = urlsplit(base).port
|
||
try:
|
||
urlopen(f"https://127.0.0.1:{port}/health/live", context=tls, timeout=5)
|
||
except URLError as error:
|
||
assert isinstance(error.reason, ssl.SSLCertVerificationError)
|
||
else:
|
||
raise AssertionError("TLS принял неверный SAN")
|
||
|
||
client = Client(base, cafile)
|
||
actor, bob, outsider, chat = client.bootstrap()
|
||
attachment, _ = client.attachment(actor, chat)
|
||
endpoint = f"/api/v1/attachments/{attachment['id']}"
|
||
for suffix in ("", "/content"):
|
||
client.call("GET", endpoint + suffix, 404, actor=outsider)
|
||
client.call("GET", f"/api/v1/chats/{chat['id']}", 404, actor=outsider,
|
||
headers={"X-User-Id": actor["id"]})
|
||
other_chat = client.call(
|
||
"POST", "/api/v1/chats", 201, actor=outsider,
|
||
body={"title": "Проверка чужого вложения", "member_ids": [outsider["id"], bob["id"]]},
|
||
schema="Chat",
|
||
)["json"]
|
||
client.call("POST", f"/api/v1/chats/{other_chat['id']}/messages", 404,
|
||
actor=outsider, body={"text": "", "attachment_ids": [attachment["id"]]},
|
||
headers={"Idempotency-Key": "negative-acl-probe"})
|
||
client.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=actor)
|
||
client.call("GET", "/api/v1/users/me", 401, actor=actor)
|
||
key = "session:" + hashlib.sha256(outsider["token"].encode()).hexdigest()
|
||
result = project.run(
|
||
"exec", "-T", "redis", "sh", "-ec",
|
||
'REDISCLI_AUTH="$(cat /run/secrets/test_redis_password)" redis-cli --tls '
|
||
'--cacert /run/tls/ca.crt -h localhost pexpire "$1" 50', "sh", key,
|
||
)
|
||
assert result.strip() == "1"
|
||
time.sleep(0.1)
|
||
client.call("GET", "/api/v1/users/me", 401, actor=outsider)
|
||
|
||
basic = "Basic " + base64.b64encode(b"unknown:synthetic-password").decode()
|
||
login = base + "/api/v1/auth/sessions"
|
||
|
||
def login_attempt(_):
|
||
request = Request(login, data=b"", headers={"Authorization": basic})
|
||
try:
|
||
urlopen(request, context=tls, timeout=5)
|
||
except HTTPError as error:
|
||
if error.code == 429:
|
||
assert int(error.headers["Retry-After"]) > 0
|
||
return error.code, error.headers.get("X-Instance-Id")
|
||
raise AssertionError("Неизвестный пользователь получил сессию")
|
||
|
||
started = time.monotonic()
|
||
with ThreadPoolExecutor(max_workers=12) as pool:
|
||
results = list(pool.map(login_attempt, range(25)))
|
||
statuses = [status for status, _ in results]
|
||
replicas = {instance for status, instance in results if status == 401 and instance}
|
||
assert set(statuses) == {401, 429} and len(replicas) >= 2, (statuses, len(replicas))
|
||
print(f"PASS: login burst 25 за {time.monotonic() - started:.2f} с, "
|
||
f"{statuses.count(401)} проверок на {len(replicas)} репликах, "
|
||
f"{statuses.count(429)} ограничений")
|
||
|
||
try:
|
||
urlopen(Request(login, data=b"x" * 17000), context=tls, timeout=5)
|
||
except HTTPError as error:
|
||
assert error.code == 413
|
||
else:
|
||
raise AssertionError("Превышение размера запроса не отклонено")
|
||
print("PASS: hostname, ACL, logout, expiry, 429/Retry-After, 413")
|
||
|
||
|
||
def measure_argon2(project: ComposeProject) -> None:
|
||
probe = """
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
from resource import RUSAGE_SELF, getrusage
|
||
from statistics import median
|
||
from time import perf_counter, process_time
|
||
|
||
from app.core.security import _hash_password_sync, _verify_password_sync
|
||
|
||
password = "generated-probe-password"
|
||
encoded = _hash_password_sync(password)
|
||
assert encoded.startswith("$argon2id$v=19$m=19456,t=2,p=1$")
|
||
timings = []
|
||
for _ in range(15):
|
||
started = perf_counter()
|
||
assert _verify_password_sync(password, encoded)
|
||
timings.append((perf_counter() - started) * 1000)
|
||
wall, cpu = perf_counter(), process_time()
|
||
with ThreadPoolExecutor(max_workers=2) as pool:
|
||
assert all(pool.map(lambda _: _verify_password_sync(password, encoded), range(24)))
|
||
wall, cpu = perf_counter() - wall, process_time() - cpu
|
||
print(f"PASS: Argon2id, медиана {median(timings):.1f} мс, 24 проверки на 2 потоках "
|
||
f"за {wall:.2f} с, CPU {cpu / 24 * 1000:.1f} мс/проверку, "
|
||
f"пиковый RSS {getrusage(RUSAGE_SELF).ru_maxrss / 1024:.1f} MiB")
|
||
"""
|
||
print(project.run("exec", "-T", "api", "python", "-c", probe))
|
||
|
||
|
||
def main() -> None:
|
||
parser = argparse.ArgumentParser(description=__doc__)
|
||
parser.add_argument("--base-url", required=True)
|
||
parser.add_argument("--bao-port", required=True, type=int)
|
||
args = parser.parse_args()
|
||
project = ComposeProject()
|
||
probe_deployment(project)
|
||
probe_mtls(project)
|
||
audit_dependencies(project)
|
||
probe_bao(args.bao_port)
|
||
probe_http(args.base_url, project)
|
||
measure_argon2(project)
|
||
# Отдельный сценарий отказа начинает вход с восстановленным burst-бюджетом.
|
||
time.sleep(6)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|