Files
mtusi2026lab7-fork/scripts/check_security.py
T

241 lines
9.3 KiB
Python

"""Сквозные проверки уровня 3 для запущенного HTTPS-стенда."""
import argparse
import base64
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())
"""
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"]
assert service["deploy"]["resources"]["limits"]["memory"]
uid = project.run("exec", "-T", name, "id", "-u")
assert int(uid) > 0
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 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:wrong").decode()
login = base + "/api/v1/auth/sessions"
for _ in range(25):
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
break
assert error.code == 401
else:
raise AssertionError("Лимит входа не сработал")
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 statistics import median
from time import perf_counter
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)
print(f"PASS: Argon2id, медиана проверки {median(timings):.1f} мс (15 попыток)")
"""
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)
probe_bao(args.bao_port)
probe_http(args.base_url, project)
measure_argon2(project)
# Отдельный сценарий отказа начинает вход с восстановленным burst-бюджетом.
time.sleep(6)
if __name__ == "__main__":
main()