Files
mtusi2026lab7-fork/scripts/check_security.py
T

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