forked from mtusi2026/mtusi2026lab7
241 lines
9.3 KiB
Python
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()
|