"""Сквозные проверки защиты для запущенного 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()