Add web administration

This commit is contained in:
Alexey Dudin
2026-11-09 15:42:27 +03:00
parent c778db6208
commit ecad6f183c
16 changed files with 1161 additions and 14 deletions
+140
View File
@@ -0,0 +1,140 @@
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from helpers import SiteTestCase
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.services.auth import COOKIE_NAME, AuthService
from site_engine.web.admin.handlers import ADMIN_HEADERS, AdminHandlers
ORIGIN = {"Host": "admin.example", "Origin": "https://admin.example"}
class AdminHandlersTest(SiteTestCase):
def setUp(self):
super().setUp()
self.clock = Clock()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=self.clock)
self.h = AdminHandlers(self.auth, self.site)
def cookie_value(self, result):
header = result.cookies[0]
return header.split(";")[0].split("=", 1)[1]
def login(self, ip="1.1.1.1"):
result = self.h.login_submit("admin", PASSWORD, ORIGIN, ip)
self.assertEqual(result.status, 303, result.body)
return self.cookie_value(result)
def csrf_for(self, cookie):
return self.auth.csrf_token(self.auth.authenticate(cookie))
def test_dashboard_requires_login(self):
result = self.h.dashboard(None)
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/login"))
self.assertEqual(self.h.dashboard("v1.fake.fake").status, 303)
def test_login_page_and_security_headers(self):
result = self.h.login_page(None)
self.assertEqual(result.status, 200)
self.assertIn("name='password'", result.body)
for name, value in ADMIN_HEADERS.items():
self.assertEqual(result.headers[name], value)
self.assertIn("frame-ancestors 'none'", result.headers["Content-Security-Policy"])
self.assertEqual(result.headers["Cache-Control"], "no-store")
def test_successful_login_sets_hardened_cookie(self):
result = self.h.login_submit("admin", PASSWORD, ORIGIN, "1.1.1.1")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/"))
cookie = result.cookies[0]
self.assertTrue(cookie.startswith(f"{COOKIE_NAME}="))
for flag in ("HttpOnly", "SameSite=Strict", "Path=/admin", "Secure", "Max-Age=28800"):
self.assertIn(flag, cookie)
def test_wrong_password_gives_401_without_cookie_and_generic_message(self):
result = self.h.login_submit("admin", "wrong password!!", ORIGIN, "1.1.1.1")
self.assertEqual((result.status, result.cookies), (401, []))
self.assertIn("Неверный логин или пароль", result.body)
other = self.h.login_submit("nobody", PASSWORD, ORIGIN, "1.1.1.2")
self.assertIn("Неверный логин или пароль", other.body)
def test_login_rejects_cross_origin_even_with_correct_password(self):
for headers in ({"Host": "admin.example", "Origin": "https://evil.example"}, {"Host": "admin.example"}):
result = self.h.login_submit("admin", PASSWORD, headers, "1.1.1.1")
self.assertEqual((result.status, result.cookies), (403, []))
def test_throttled_login_returns_429_with_retry_after(self):
for _ in range(5):
self.h.login_submit("admin", "wrong password!!", ORIGIN, "6.6.6.6")
result = self.h.login_submit("admin", PASSWORD, ORIGIN, "6.6.6.6")
self.assertEqual(result.status, 429)
self.assertGreater(int(result.headers["Retry-After"]), 0)
self.assertEqual(result.cookies, [])
def test_login_value_is_escaped_in_error_page(self):
evil = "\"><script>alert(1)</script>"
result = self.h.login_submit(evil, "wrong password!!", ORIGIN, "1.1.1.1")
self.assertNotIn("<script>alert(1)</script>", result.body)
self.assertIn("&lt;script&gt;", result.body)
def test_password_is_never_echoed(self):
result = self.h.login_submit("admin", "super-secret-guess!!", ORIGIN, "1.1.1.1")
self.assertNotIn("super-secret-guess", result.body)
def test_dashboard_lists_pages_collections_and_validation(self):
result = self.h.dashboard(self.login())
self.assertEqual(result.status, 200)
for text in ("Acme Studio", "Главная", "Контакты", "Черновик новой страницы", "status-draft",
"опубликовано 3 из 3", "ошибок проверки: 0"):
self.assertIn(text, result.body)
self.assertIn("name='csrf'", result.body)
self.assertIn("no-store", result.headers["Cache-Control"])
def test_dashboard_shows_broken_site_instead_of_crashing(self):
(self.site / "site.yaml").unlink()
result = self.h.dashboard(self.login())
self.assertEqual(result.status, 200)
self.assertIn("Сайт не загружен", result.body)
def test_logout_needs_csrf_and_same_origin(self):
cookie = self.login()
token = self.csrf_for(cookie)
self.assertEqual(self.h.logout(cookie, "", ORIGIN, "1.1.1.1").status, 403)
self.assertEqual(self.h.logout(cookie, "wrong", ORIGIN, "1.1.1.1").status, 403)
evil = {"Host": "admin.example", "Origin": "https://evil.example"}
self.assertEqual(self.h.logout(cookie, token, evil, "1.1.1.1").status, 403)
self.assertEqual(self.h.dashboard(cookie).status, 200) # сессия цела
def test_logout_clears_cookie_and_revokes_session(self):
cookie = self.login()
result = self.h.logout(cookie, self.csrf_for(cookie), ORIGIN, "1.1.1.1")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/login"))
self.assertIn("Max-Age=0", result.cookies[0])
self.assertEqual(self.h.dashboard(cookie).status, 303)
def test_logged_in_user_is_redirected_from_login_page(self):
result = self.h.login_page(self.login())
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/"))
def test_static_css_is_served(self):
result = self.h.static_css()
self.assertEqual(result.status, 200)
self.assertTrue(result.content_type.startswith("text/css"))
self.assertIn(".login", result.body)
def test_no_inline_scripts_or_styles_in_templates(self):
# CSP не разрешает inline: проверяем, что шаблоны её не нарушают
for body in (self.h.login_page(None).body, self.h.dashboard(self.login()).body):
self.assertNotIn("<script", body)
self.assertNotIn("style=", body)
self.assertNotIn("<style", body)
def test_cookie_without_secure_flag_only_when_configured(self):
local = AdminHandlers(AuthService(make_cfg(cookie_secure=False), self.tmp / "s2", clock=self.clock), self.site)
cookie = local.login_submit("admin", PASSWORD, ORIGIN, "1.1.1.1").cookies[0]
self.assertNotIn("Secure", cookie)
if __name__ == "__main__":
unittest.main()
+121
View File
@@ -0,0 +1,121 @@
"""Проверка проводки FastAPI-адаптера на подставном модуле `fastapi`.
Настоящего FastAPI в окружении нет, поэтому здесь проверяется только то, что роуты вызывают
обработчики с правильными аргументами и переносят статус, заголовки и cookie в ответ.
Поведение самого FastAPI (разбор форм, пул потоков) этим тестом не проверяется.
"""
import sys
import types
import unittest
from unittest import mock
from helpers import SiteTestCase
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.services.auth import COOKIE_NAME, AuthService
from site_engine.web.admin.handlers import AdminHandlers
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
class FakeHeaders(dict):
def __init__(self):
super().__init__()
self.appended = []
def append(self, key, value):
self.appended.append((key, value))
class FakeResponse:
def __init__(self, content="", status_code=200, media_type=None):
self.content, self.status_code, self.media_type = content, status_code, media_type
self.headers = FakeHeaders()
class FakeRouter:
def __init__(self, prefix=""):
self.prefix, self.routes = prefix, {}
def _register(self, method, path):
def deco(fn):
self.routes[(method, self.prefix + path)] = fn
return fn
return deco
def get(self, path):
return self._register("GET", path)
def post(self, path):
return self._register("POST", path)
class FakeRequest:
def __init__(self, cookies=None, headers=None, ip="1.2.3.4"):
self.cookies, self.headers = cookies or {}, headers or {}
self.client = types.SimpleNamespace(host=ip)
def fake_fastapi():
mod = types.ModuleType("fastapi")
mod.APIRouter, mod.Response, mod.Request = FakeRouter, FakeResponse, FakeRequest
mod.Form = lambda default="": default
return mod
class RoutesWiringTest(SiteTestCase):
def setUp(self):
super().setUp()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
handlers = AdminHandlers(self.auth, self.site)
with mock.patch.dict(sys.modules, {"fastapi": fake_fastapi()}):
from site_engine.web.admin.routes import create_admin_router
self.router = create_admin_router(handlers)
def route(self, method, path):
return self.router.routes[(method, path)]
def test_all_expected_routes_exist(self):
self.assertEqual(
sorted(self.router.routes),
[("GET", "/admin/"), ("GET", "/admin/login"), ("GET", "/admin/static/admin.css"),
("POST", "/admin/login"), ("POST", "/admin/logout")],
)
def test_login_flow_through_routes(self):
request = FakeRequest(headers=ORIGIN)
response = self.route("POST", "/admin/login")(request, login="admin", password=PASSWORD)
self.assertEqual((response.status_code, response.headers["Location"]), (303, "/admin/"))
key, cookie = response.headers.appended[0]
self.assertEqual(key, "set-cookie")
value = cookie.split(";")[0].split("=", 1)[1]
dash = self.route("GET", "/admin/")(FakeRequest(cookies={COOKIE_NAME: value}))
self.assertEqual(dash.status_code, 200)
self.assertIn("Главная", dash.content)
self.assertEqual(dash.headers["X-Frame-Options"], "DENY")
anonymous = self.route("GET", "/admin/")(FakeRequest())
self.assertEqual((anonymous.status_code, anonymous.headers["Location"]), (303, "/admin/login"))
def test_bad_login_and_logout_wiring(self):
bad = self.route("POST", "/admin/login")(FakeRequest(headers=ORIGIN), login="admin", password="wrong password!!")
self.assertEqual((bad.status_code, bad.headers.appended), (401, []))
good = self.route("POST", "/admin/login")(FakeRequest(headers=ORIGIN), login="admin", password=PASSWORD)
value = good.headers.appended[0][1].split(";")[0].split("=", 1)[1]
csrf = self.auth.csrf_token(self.auth.authenticate(value))
out = self.route("POST", "/admin/logout")(FakeRequest(cookies={COOKIE_NAME: value}, headers=ORIGIN), csrf=csrf)
self.assertEqual((out.status_code, out.headers["Location"]), (303, "/admin/login"))
self.assertIn("Max-Age=0", out.headers.appended[0][1])
def test_static_and_login_page_routes(self):
css = self.route("GET", "/admin/static/admin.css")()
self.assertTrue(css.media_type.startswith("text/css"))
page = self.route("GET", "/admin/login")(FakeRequest())
self.assertEqual(page.status_code, 200)
if __name__ == "__main__":
unittest.main()
+226
View File
@@ -0,0 +1,226 @@
import json
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from site_engine.services import auth as auth_mod
from site_engine.services.auth import (
AuthConfig, AuthError, AuthService, ConfigError, LoginThrottle, hash_password, is_same_origin,
verify_password,
)
PASSWORD = "correct horse battery"
FAST = dict(n=2**10) # быстрый scrypt для тестов; в проде параметры по умолчанию
class Clock:
def __init__(self, t=1_800_000_000.0):
self.t = t
def __call__(self):
return self.t
def make_cfg(**kw):
base = dict(login="admin", password_hash=hash_password(PASSWORD, **FAST), secret=b"k" * 40)
base.update(kw)
return AuthConfig(**base)
class PasswordTest(unittest.TestCase):
def test_hash_and_verify(self):
h = hash_password(PASSWORD, **FAST)
self.assertTrue(h.startswith("scrypt$1024$8$1$"))
self.assertTrue(verify_password(PASSWORD, h))
self.assertFalse(verify_password(PASSWORD + "x", h))
def test_salts_differ(self):
self.assertNotEqual(hash_password(PASSWORD, **FAST), hash_password(PASSWORD, **FAST))
def test_short_password_rejected(self):
with self.assertRaises(ValueError):
hash_password("short", **FAST)
def test_malformed_hash_is_just_false(self):
for bad in ("", "x", "scrypt$1$2$3$4", "bcrypt$1024$8$1$aa$bb", "scrypt$99999999$8$1$aa$bb",
"scrypt$abc$8$1$aa$bb"):
self.assertFalse(verify_password(PASSWORD, bad), bad)
def test_default_parameters_are_strong(self):
self.assertGreaterEqual(auth_mod.SCRYPT_N, 2**15)
class ConfigTest(unittest.TestCase):
ENV = {"SITE_ADMIN_PASSWORD_HASH": "scrypt$1024$8$1$aa$bb", "SITE_SECRET_KEY": "s" * 32}
def test_defaults(self):
cfg = AuthConfig.from_env(self.ENV)
self.assertEqual((cfg.login, cfg.session_hours, cfg.cookie_secure), ("admin", 8.0, True))
def test_missing_or_weak_values_fail_closed(self):
for patch in ({"SITE_ADMIN_PASSWORD_HASH": ""}, {"SITE_ADMIN_PASSWORD_HASH": "plain-password"},
{"SITE_SECRET_KEY": "short"}, {"SITE_SESSION_HOURS": "abc"},
{"SITE_SESSION_HOURS": "0"}, {"SITE_ADMIN_LOGIN": " "}):
with self.assertRaises(ConfigError, msg=str(patch)):
AuthConfig.from_env({**self.ENV, **patch})
def test_cookie_secure_can_be_disabled_for_local_dev(self):
self.assertFalse(AuthConfig.from_env({**self.ENV, "SITE_COOKIE_SECURE": "0"}).cookie_secure)
class AuthServiceTest(unittest.TestCase):
def setUp(self):
self._tmp = TemporaryDirectory()
self.addCleanup(self._tmp.cleanup)
self.state = Path(self._tmp.name)
self.clock = Clock()
self.svc = AuthService(make_cfg(), self.state, clock=self.clock)
def login(self, ip="1.1.1.1"):
return self.svc.login("admin", PASSWORD, ip)
def test_login_roundtrip(self):
principal = self.svc.authenticate(self.login())
self.assertEqual((principal.login, principal.role), ("admin", "admin"))
def test_wrong_login_and_wrong_password_are_indistinguishable(self):
errors = []
for login, password in (("root", PASSWORD), ("admin", "wrong password!!")):
with self.assertRaises(AuthError) as ctx:
self.svc.login(login, password, "2.2.2.2")
errors.append((ctx.exception.code, ctx.exception.retry_after))
self.assertEqual(errors[0], errors[1])
def test_password_is_verified_even_for_unknown_login(self):
calls = []
original = auth_mod.verify_password
auth_mod.verify_password = lambda *a, **k: calls.append(1) or original(*a, **k)
try:
with self.assertRaises(AuthError):
self.svc.login("nobody", PASSWORD, "3.3.3.3")
finally:
auth_mod.verify_password = original
self.assertEqual(len(calls), 1)
def test_tampered_cookie_is_rejected(self):
version, payload, sig = self.login().split(".")
for bad in (f"{version}.{payload}.{sig[:-2]}AA", f"{version}.{payload}x.{sig}", "v1.a.b", "garbage", "", None):
self.assertIsNone(self.svc.authenticate(bad), bad)
def test_cookie_from_another_secret_is_rejected(self):
other = AuthService(make_cfg(secret=b"z" * 40), self.state, clock=self.clock)
self.assertIsNone(other.authenticate(self.login()))
def test_expiry(self):
cookie = self.login()
self.clock.t += 8 * 3600 - 1
self.assertIsNotNone(self.svc.authenticate(cookie))
self.clock.t += 2
self.assertIsNone(self.svc.authenticate(cookie))
def test_logout_revokes_every_issued_cookie_and_survives_restart(self):
first, second = self.login("1.1.1.1"), self.login("4.4.4.4")
principal = self.svc.authenticate(first)
self.svc.logout(principal)
self.assertIsNone(self.svc.authenticate(first))
self.assertIsNone(self.svc.authenticate(second))
restarted = AuthService(make_cfg(), self.state, clock=self.clock)
self.assertIsNone(restarted.authenticate(first))
self.assertIsNotNone(restarted.authenticate(restarted.login("admin", PASSWORD, "5.5.5.5")))
def test_csrf_is_bound_to_session(self):
a = self.svc.authenticate(self.login())
b = self.svc.authenticate(self.login())
token = self.svc.csrf_token(a)
self.assertTrue(self.svc.verify_csrf(a, token))
self.assertFalse(self.svc.verify_csrf(b, token))
self.assertFalse(self.svc.verify_csrf(a, ""))
self.assertFalse(self.svc.verify_csrf(a, None))
self.assertFalse(self.svc.verify_csrf(a, token + "x"))
def test_session_and_csrf_keys_are_separated(self):
principal = self.svc.authenticate(self.login())
self.assertNotIn(self.svc.csrf_token(principal), self.login())
def test_audit_has_events_but_no_secrets(self):
with self.assertRaises(AuthError):
self.svc.login("admin-guess-xyz", "hunter2hunter2", "9.9.9.9")
principal = self.svc.authenticate(self.login())
self.svc.logout(principal, "1.1.1.1")
raw = (self.state / "audit.jsonl").read_text(encoding="utf-8")
events = [json.loads(line)["event"] for line in raw.splitlines()]
self.assertEqual(events, ["login_fail", "login_ok", "logout"])
for secret in ("hunter2hunter2", "admin-guess-xyz", PASSWORD):
self.assertNotIn(secret, raw)
self.assertEqual(oct((self.state / "audit.jsonl").stat().st_mode & 0o777), "0o600")
class ThrottleTest(unittest.TestCase):
def setUp(self):
self._tmp = TemporaryDirectory()
self.addCleanup(self._tmp.cleanup)
self.clock = Clock()
self.svc = AuthService(make_cfg(), Path(self._tmp.name), clock=self.clock)
def fail(self, ip, times):
for _ in range(times):
with self.assertRaises(AuthError):
self.svc.login("admin", "wrong password!!", ip)
def test_blocks_after_max_failures_even_with_correct_password(self):
self.fail("7.7.7.7", 5)
with self.assertRaises(AuthError) as ctx:
self.svc.login("admin", PASSWORD, "7.7.7.7")
self.assertEqual(ctx.exception.code, "throttled")
self.assertGreater(ctx.exception.retry_after, 0)
def test_block_expires_with_the_window(self):
self.fail("7.7.7.7", 5)
self.clock.t += 901
self.assertIsNotNone(self.svc.login("admin", PASSWORD, "7.7.7.7"))
def test_other_ips_are_not_affected(self):
self.fail("7.7.7.7", 5)
self.assertIsNotNone(self.svc.login("admin", PASSWORD, "8.8.8.8"))
def test_global_limit_stops_distributed_guessing(self):
for i in range(30):
with self.assertRaises(AuthError):
self.svc.login("admin", "wrong password!!", f"10.0.0.{i}")
with self.assertRaises(AuthError) as ctx:
self.svc.login("admin", PASSWORD, "10.9.9.9")
self.assertEqual(ctx.exception.code, "throttled")
def test_success_resets_ip_counter(self):
self.fail("7.7.7.7", 4)
self.svc.login("admin", PASSWORD, "7.7.7.7")
self.fail("7.7.7.7", 4) # снова четыре, блокировки нет
def test_throttle_unit(self):
c = Clock()
t = LoginThrottle(2, 60, 10, c)
t.fail("a")
self.assertIsNone(t.blocked("a"))
t.fail("a")
self.assertEqual(t.blocked("a"), 61)
c.t += 61
self.assertIsNone(t.blocked("a"))
class OriginTest(unittest.TestCase):
def test_same_origin(self):
self.assertTrue(is_same_origin({"Host": "admin.example", "Origin": "https://admin.example"}))
self.assertTrue(is_same_origin({"host": "admin.example", "referer": "https://admin.example/admin/login"}))
def test_cross_origin_and_missing_headers_rejected(self):
self.assertFalse(is_same_origin({"Host": "admin.example", "Origin": "https://evil.example"}))
self.assertFalse(is_same_origin({"Host": "admin.example", "Origin": "null"}))
self.assertFalse(is_same_origin({"Host": "admin.example"}))
self.assertFalse(is_same_origin({"Origin": "https://admin.example"}))
def test_public_host_override_for_proxy(self):
self.assertTrue(is_same_origin({"Host": "127.0.0.1:8000", "Origin": "https://admin.example"}, "admin.example"))
if __name__ == "__main__":
unittest.main()
+30
View File
@@ -0,0 +1,30 @@
import unittest
from click.testing import CliRunner
from site_engine.cli import main
from site_engine.services.auth import verify_password
class CliAuthTest(unittest.TestCase):
def test_hash_password_prints_verifiable_hash(self):
result = CliRunner().invoke(main, ["hash-password"], input="correct horse battery\ncorrect horse battery\n")
self.assertEqual(result.exit_code, 0, result.output)
stored = [line for line in result.output.splitlines() if line.startswith("scrypt$")][0]
self.assertTrue(verify_password("correct horse battery", stored))
self.assertNotIn("correct horse battery", stored)
def test_hash_password_rejects_short_password(self):
result = CliRunner().invoke(main, ["hash-password"], input="short\nshort\n")
self.assertNotEqual(result.exit_code, 0)
self.assertIn("минимум", result.output)
def test_gen_secret_is_long_and_random(self):
a = CliRunner().invoke(main, ["gen-secret"]).output.strip()
b = CliRunner().invoke(main, ["gen-secret"]).output.strip()
self.assertGreaterEqual(len(a), 48)
self.assertNotEqual(a, b)
if __name__ == "__main__":
unittest.main()