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
+39 -7
View File
@@ -25,7 +25,8 @@ site-engine/
├── Makefile Dockerfile # Dockerfile — для M2+ (админка, формы, MCP)
├── docs/ # ТЗ, ревью, журнал решений
├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект)
├── tests/ # 62 теста: значения, разбор, маршруты, сборка, безопасность, запись
├── .env.example # переменные окружения для админки
├── tests/ # 112 тестов: ядро, сборка, безопасность, запись, вход в админку
└── src/site_engine/
├── cli.py # validate · build · preview · fragments
├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка
@@ -40,26 +41,57 @@ site-engine/
├── build/pipeline.py # load → validate → render → релиз → атомарный current
├── parsing/ # безопасный YAML, front matter, Markdown (raw HTML выключен)
├── storage/ # safe_join, atomic_write, SiteLock, .engine/history
├── services/ # ContentService (if_match, история, синтаксис), publish; stubs: changeset, auth, forms
├── services/ # auth (вход админа), ContentService (if_match, история), publish; stubs: changeset, forms
├── builtin/ # base.css и 15 фрагментов ядра (ADR-006)
├── db/ # SQLAlchemy-модели служебных таблиц (M2)
├── web/ # FastAPI-фабрика, место для админки htmx (M1–M3)
├── web/ # FastAPI-фабрика; admin/: handlers (вход, выход, обзор), шаблоны, routes-адаптер
└── mcp/ # перечень инструментов MVP (M3)
```
## Вход в админку
Самый простой вариант: **один администратор, без ролей**, логин и хеш пароля задаются переменными окружения, БД для входа не нужна.
```bash
site-engine hash-password # спросит пароль (от 12 символов) и напечатает scrypt-хеш
site-engine gen-secret # ключ подписи сессий
cp .env.example .env # впишите SITE_ADMIN_PASSWORD_HASH и SITE_SECRET_KEY
SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file .env # локально по http
```
Без `SITE_ADMIN_PASSWORD_HASH` и `SITE_SECRET_KEY` (не короче 32 символов) `/admin/` не включается вообще: нет пароля — нет входа. После входа `/admin/` показывает страницы сайта со статусами, коллекции и результат проверки (только чтение; редактор — следующий шаг).
| Мера | Как сделано |
|---|---|
| Пароль | scrypt (N=2^15, r=8, p=1), соль на каждый хеш, сравнение за постоянное время |
| Сессия | Подписанная cookie `se_session`: HttpOnly, SameSite=Strict, Secure (выключается только `SITE_COOKIE_SECURE=0`), Path=/admin, срок `SITE_SESSION_HOURS` (по умолчанию 8) |
| Выход | Увеличивает «эпоху» в `.engine/auth_epoch`: все выданные cookie сразу недействительны, в том числе украденные |
| Перебор | 5 неудач за 15 минут блокируют IP (429 + Retry-After), общий порог 30 на все адреса; хеш считается и при неверном логине, поэтому по времени логин не угадать |
| CSRF | POST принимается только с Origin или Referer того же хоста; выход дополнительно требует токен, привязанный к сессии |
| Заголовки | CSP без inline, `frame-ancestors 'none'`, `no-store`, `X-Frame-Options: DENY`, `nosniff` |
| Аудит | `.engine/audit.jsonl`: вход, неудача, блокировка, выход; без паролей и без введённого логина |
Ограничения этого варианта:
- Один пользователь, роль всегда `admin`; таблицы `users` и `api_tokens` из `db/models.py` пока не используются.
- Окно попыток хранится в памяти процесса: при нескольких воркерах у каждого свой счётчик, после перезапуска он обнуляется.
- За обратным прокси `request.client.host` — адрес прокси, поэтому ограничение по IP работает как общее. Доверие к `X-Forwarded-For` нужно включать явно (задача M2).
- Выход завершает все сессии администратора сразу, отдельного списка устройств нет.
- Отдельная смена пароля: сгенерировать новый хеш и перезапустить сервис; чтобы разлогинить всех, поменяйте `SITE_SECRET_KEY`.
## Что реализовано
| Этап | Состояние |
|---|---|
| M0 Контракт и прототип | Готово: формат файлов, модель блоков, load → validate → render, CLI, 15 фрагментов, сайт-пример |
| M1 Публикуемый движок | Частично: маршруты, ссылки, редиректы, sitemap, атомарная публикация, откат (`services/publish.py`), превью страницы через CLI. Нет: превью по токену, 404-страница из коробки, тема |
| M2 Коллекции, заявки, доступ | Частично: коллекции, display templates, запросы, формы (разметка, версия формы в релизе). Нет: приём заявок, outbox, вход и роли, аудит |
| M3 MCP и редактор | `ContentService` с `if_match`, блокировкой и историей готов; нет `patch_page`, changeset, MCP-сервера, админки |
| M2 Коллекции, заявки, доступ | Частично: коллекции, display templates, запросы, формы (разметка, версия формы в релизе), **вход одного администратора с аудитом входов и обзорная страница админки**. Нет: роли, приём заявок, outbox, аудит правок |
| M3 MCP и редактор | `ContentService` с `if_match`, блокировкой и историей готов; нет редактора страниц, `patch_page`, changeset, MCP-сервера |
| M4 | Не начат |
## Что проверено, а что нет
Тесты и сборка примера выполнялись в окружении без сети: ядро (всё, что в `core/`, `build/`, `parsing/`, `storage/`, `services/content.py`) запущено и покрыто 62 тестами. Модули `db/`, `web/`, `mcp/` и `Dockerfile` проверены только компиляцией и чтением: SQLAlchemy, FastAPI и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 112 тестами. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
## Соответствие журналу решений
@@ -83,4 +115,4 @@ site-engine/
- Поле `props` в шаблоне — объект `Props`: `props.items` читает поле «items», а не метод словаря.
- `layout.extends` проверяется на существование, наследование шаблонов делается обычным `{% extends 'layout/<id>' %}`.
- CSS и JS собираются в один бандл с хешем в имени; минификации и изоляции по страницам пока нет.
- Нет приёма заявок, входа, MCP и админки: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006).
- Нет приёма заявок, редактора и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход уже есть, роли и аудит правок будут вместе с редактором.
+11
View File
@@ -0,0 +1,11 @@
# Каталоги
SITE_ROOT=examples/studio-site
SITE_DIST=dist
# Вход в админку (без этих переменных /admin/ отключена)
SITE_ADMIN_LOGIN=admin
SITE_ADMIN_PASSWORD_HASH= # site-engine hash-password
SITE_SECRET_KEY= # site-engine gen-secret (не короче 32 символов)
SITE_COOKIE_SECURE=1 # 0 только для локальной разработки по http
SITE_SESSION_HOURS=8
# SITE_PUBLIC_HOST=admin.example.com # если Host подменяется прокси
+20
View File
@@ -73,6 +73,26 @@ def preview(site: Path, page_id: str) -> None:
click.echo(html)
@main.command("hash-password")
def hash_password_cmd() -> None:
"""Хеш пароля администратора для SITE_ADMIN_PASSWORD_HASH (пароль вводится скрыто)."""
from .services.auth import MIN_PASSWORD_LENGTH, hash_password
password = click.prompt("Пароль", hide_input=True, confirmation_prompt=True)
try:
click.echo(hash_password(password))
except ValueError as exc:
raise click.ClickException(f"{exc} (минимум {MIN_PASSWORD_LENGTH})") from exc
@main.command("gen-secret")
def gen_secret_cmd() -> None:
"""Случайный ключ подписи сессий для SITE_SECRET_KEY."""
import secrets
click.echo(secrets.token_urlsafe(48))
@main.command()
@click.option("--site", type=click.Path(exists=True, file_okay=False, path_type=Path), default=None)
def fragments(site: Path | None) -> None:
+262 -2
View File
@@ -1,4 +1,264 @@
"""Вход, роли owner/developer/editor, токены агентов со scope — M2 (ADR-005, ADR-006).
"""Аутентификация админки: один администратор, без ролей, без БД (ADR-005, упрощённый MVP).
Правило порядка: сетевая поверхность записи включается только вместе с этим модулем.
Логин и хеш пароля берутся из конфигурации (переменные окружения). Сессия — подписанная
cookie без серверного хранилища; выход увеличивает «эпоху» в `.engine/auth_epoch`, после чего
все выданные cookie перестают действовать. Перебор пароля ограничивается окном попыток.
События входа пишутся в `.engine/audit.jsonl` (без паролей и без введённого логина).
Путь расширения: `Principal.role` уже есть; пользователи и роли (таблицы `users`,
`api_tokens`) подключаются позже без смены интерфейса `AuthService`.
"""
from __future__ import annotations
import base64
import datetime as dt
import hashlib
import hmac
import json
import os
import secrets
import time
from collections import defaultdict, deque
from collections.abc import Callable, Mapping
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import urlsplit
from ..errors import EngineError
from ..storage.fs import atomic_write
COOKIE_NAME = "se_session"
MIN_PASSWORD_LENGTH = 12
MIN_SECRET_LENGTH = 32
SCRYPT_N, SCRYPT_R, SCRYPT_P = 2**15, 8, 1
_SCRYPT_MAXMEM = 128 * 1024 * 1024
class ConfigError(EngineError):
"""Неполная или небезопасная конфигурация входа."""
class AuthError(Exception):
"""code: invalid | throttled."""
def __init__(self, code: str, retry_after: int | None = None):
super().__init__(code)
self.code = code
self.retry_after = retry_after
def _b64(data: bytes) -> str:
return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
def _unb64(text: str) -> bytes:
return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
# ── пароли ────────────────────────────────────────────────────────────────────
def hash_password(password: str, *, n: int = SCRYPT_N, r: int = SCRYPT_R, p: int = SCRYPT_P) -> str:
"""`scrypt$N$r$p$соль$хеш`; параметры хранятся в строке, их можно усиливать позже."""
if len(password) < MIN_PASSWORD_LENGTH:
raise ValueError(f"пароль короче {MIN_PASSWORD_LENGTH} символов")
salt = secrets.token_bytes(16)
digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=n, r=r, p=p, maxmem=_SCRYPT_MAXMEM, dklen=32)
return f"scrypt${n}${r}${p}${_b64(salt)}${_b64(digest)}"
def verify_password(password: str, stored: str) -> bool:
"""Сравнение за постоянное время; любой дефект строки хеша — просто False."""
try:
scheme, n, r, p, salt, digest = stored.split("$")
n, r, p = int(n), int(r), int(p)
if scheme != "scrypt" or not (2 <= n <= 2**20 and 1 <= r <= 32 and 1 <= p <= 16):
return False
expected = _unb64(digest)
actual = hashlib.scrypt(password.encode("utf-8"), salt=_unb64(salt), n=n, r=r, p=p,
maxmem=_SCRYPT_MAXMEM, dklen=len(expected))
return hmac.compare_digest(actual, expected)
except (ValueError, TypeError, MemoryError):
return False
# ── конфигурация ──────────────────────────────────────────────────────────────
@dataclass(frozen=True)
class AuthConfig:
login: str
password_hash: str
secret: bytes
session_hours: float = 8.0
cookie_secure: bool = True
public_host: str | None = None # Host админки, если стоит прокси и Host подменяется
max_failures: int = 5
window_seconds: int = 900
global_max_failures: int = 30
@classmethod
def from_env(cls, env: Mapping[str, str] | None = None) -> "AuthConfig":
env = os.environ if env is None else env
login = env.get("SITE_ADMIN_LOGIN", "admin").strip()
password_hash = env.get("SITE_ADMIN_PASSWORD_HASH", "").strip()
secret = env.get("SITE_SECRET_KEY", "")
if not login:
raise ConfigError("SITE_ADMIN_LOGIN пуст")
if not password_hash.startswith("scrypt$"):
raise ConfigError("SITE_ADMIN_PASSWORD_HASH не задан или не в формате scrypt (site-engine hash-password)")
if len(secret) < MIN_SECRET_LENGTH:
raise ConfigError(f"SITE_SECRET_KEY короче {MIN_SECRET_LENGTH} символов (site-engine gen-secret)")
try:
hours = float(env.get("SITE_SESSION_HOURS", "8"))
except ValueError as exc:
raise ConfigError("SITE_SESSION_HOURS: ожидается число") from exc
if not 0 < hours <= 24 * 30:
raise ConfigError("SITE_SESSION_HOURS: от 0 до 720")
secure = env.get("SITE_COOKIE_SECURE", "1").strip().lower() not in ("0", "false", "no", "off")
return cls(login, password_hash, secret.encode("utf-8"), hours, secure,
env.get("SITE_PUBLIC_HOST") or None)
# ── ограничение попыток и аудит ───────────────────────────────────────────────
class LoginThrottle:
"""Скользящее окно неудач: по IP и общий порог на все адреса."""
def __init__(self, max_failures: int, window_seconds: int, global_max: int,
clock: Callable[[], float] = time.time):
self.max_failures, self.window, self.global_max = max_failures, window_seconds, global_max
self.clock = clock
self._by_key: dict[str, deque[float]] = defaultdict(deque)
self._all: deque[float] = deque()
def _trim(self, q: deque[float]) -> None:
cutoff = self.clock() - self.window
while q and q[0] <= cutoff:
q.popleft()
def blocked(self, key: str) -> int | None:
"""Секунд до следующей попытки или None, если можно пробовать."""
for q, limit in ((self._by_key[key], self.max_failures), (self._all, self.global_max)):
self._trim(q)
if len(q) >= limit:
return max(1, int(q[0] + self.window - self.clock()) + 1)
return None
def fail(self, key: str) -> None:
now = self.clock()
self._by_key[key].append(now)
self._all.append(now)
def success(self, key: str) -> None:
self._by_key.pop(key, None)
class AuditLog:
"""JSON Lines: одно событие на строку. В записях нет паролей и введённых логинов."""
def __init__(self, path: Path, clock: Callable[[], float] = time.time):
self.path, self.clock = path, clock
def write(self, event: str, **fields) -> None:
self.path.parent.mkdir(parents=True, exist_ok=True)
entry = {"ts": dt.datetime.fromtimestamp(self.clock(), dt.timezone.utc).isoformat(), "event": event, **fields}
line = json.dumps(entry, ensure_ascii=False) + "\n"
fd = os.open(self.path, os.O_WRONLY | os.O_APPEND | os.O_CREAT, 0o600)
try:
os.write(fd, line.encode("utf-8"))
finally:
os.close(fd)
# ── сервис ────────────────────────────────────────────────────────────────────
@dataclass(frozen=True)
class Principal:
login: str
sid: str
role: str = "admin"
class AuthService:
def __init__(self, cfg: AuthConfig, state_dir: Path, *, clock: Callable[[], float] = time.time,
throttle: LoginThrottle | None = None):
self.cfg, self.state_dir, self.clock = cfg, Path(state_dir), clock
self.throttle = throttle or LoginThrottle(cfg.max_failures, cfg.window_seconds, cfg.global_max_failures, clock)
self.audit = AuditLog(self.state_dir / "audit.jsonl", clock)
self._session_key = hmac.new(cfg.secret, b"site-engine/session/v1", hashlib.sha256).digest()
self._csrf_key = hmac.new(cfg.secret, b"site-engine/csrf/v1", hashlib.sha256).digest()
@property
def cookie_max_age(self) -> int:
return int(self.cfg.session_hours * 3600)
# эпоха: выход увеличивает её, и все ранее выданные cookie недействительны
def _epoch(self) -> int:
try:
return int((self.state_dir / "auth_epoch").read_text().strip() or 0)
except (FileNotFoundError, ValueError):
return 0
def _bump_epoch(self) -> None:
atomic_write(self.state_dir / "auth_epoch", str(self._epoch() + 1))
def _sign(self, payload: str) -> str:
return _b64(hmac.new(self._session_key, payload.encode("ascii"), hashlib.sha256).digest())
def login(self, login: str, password: str, ip: str) -> str:
"""Значение cookie. AuthError('invalid') при неверной паре, AuthError('throttled') при блокировке."""
retry = self.throttle.blocked(ip)
if retry is not None:
self.audit.write("login_blocked", ip=ip, retry_after=retry)
raise AuthError("throttled", retry)
login_ok = hmac.compare_digest(login.encode("utf-8"), self.cfg.login.encode("utf-8"))
password_ok = verify_password(password, self.cfg.password_hash) # хеш считаем всегда: время не выдаёт логин
if not (login_ok and password_ok):
self.throttle.fail(ip)
self.audit.write("login_fail", ip=ip, login_matched=login_ok)
raise AuthError("invalid")
self.throttle.success(ip)
now = int(self.clock())
payload = _b64(json.dumps(
{"l": self.cfg.login, "sid": secrets.token_hex(16), "iat": now,
"exp": now + self.cookie_max_age, "ep": self._epoch()}, separators=(",", ":")).encode("utf-8"))
self.audit.write("login_ok", ip=ip)
return f"v1.{payload}.{self._sign(payload)}"
def authenticate(self, cookie: str | None) -> Principal | None:
if not cookie:
return None
try:
version, payload, signature = cookie.split(".")
if version != "v1" or not hmac.compare_digest(signature, self._sign(payload)):
return None
data = json.loads(_unb64(payload))
if data["exp"] <= self.clock() or data["ep"] != self._epoch() or data["l"] != self.cfg.login:
return None
return Principal(login=data["l"], sid=str(data["sid"]))
except (ValueError, KeyError, TypeError, UnicodeError):
return None
def logout(self, principal: Principal, ip: str = "") -> None:
"""Выход отзывает все сессии администратора (эпоха +1)."""
self._bump_epoch()
self.audit.write("logout", ip=ip)
def csrf_token(self, principal: Principal) -> str:
return _b64(hmac.new(self._csrf_key, principal.sid.encode("ascii"), hashlib.sha256).digest())
def verify_csrf(self, principal: Principal, token: str | None) -> bool:
return bool(token) and hmac.compare_digest(token, self.csrf_token(principal))
def is_same_origin(headers: Mapping[str, str], public_host: str | None = None) -> bool:
"""POST принимается только с Origin (или Referer) того же хоста, что и админка."""
h = {k.lower(): v for k, v in headers.items()}
host = (public_host or h.get("host", "")).lower()
if not host:
return False
for name in ("origin", "referer"):
value = h.get(name)
if value:
return urlsplit(value).netloc.lower() == host
return False
+125
View File
@@ -0,0 +1,125 @@
"""Обработчики админки без привязки к веб-фреймворку: запрос → `HttpResult`.
Так вся логика входа, выхода, CSRF и защитных заголовков проверяется обычными тестами;
FastAPI-слой (`routes.py`) только переводит запрос в аргументы и результат в Response.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from pathlib import Path
from ...core.registry import load_site
from ...core.routes import build_route_table
from ...core.validate import validate_release, validate_workspace
from ...errors import EngineError, Report
from ...services.auth import COOKIE_NAME, AuthError, AuthService, is_same_origin
from .render import read_static, render
ADMIN_HEADERS = {
"Cache-Control": "no-store",
"X-Frame-Options": "DENY",
"X-Content-Type-Options": "nosniff",
"Referrer-Policy": "same-origin",
"Content-Security-Policy": (
"default-src 'none'; style-src 'self'; script-src 'self'; img-src 'self'; "
"connect-src 'self'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'"
),
}
@dataclass
class HttpResult:
status: int = 200
body: str = ""
content_type: str = "text/html; charset=utf-8"
headers: dict[str, str] = field(default_factory=dict)
cookies: list[str] = field(default_factory=list) # готовые значения Set-Cookie
def build_set_cookie(value: str, *, max_age: int, secure: bool) -> str:
parts = [f"{COOKIE_NAME}={value}", "Path=/admin", "HttpOnly", "SameSite=Strict", f"Max-Age={max_age}"]
if secure:
parts.append("Secure")
return "; ".join(parts)
def _page(body: str, status: int = 200, headers: dict[str, str] | None = None) -> HttpResult:
return HttpResult(status, body, headers={**ADMIN_HEADERS, **(headers or {})})
def _redirect(location: str, cookies: list[str] | None = None) -> HttpResult:
return HttpResult(303, "", headers={**ADMIN_HEADERS, "Location": location}, cookies=cookies or [])
class AdminHandlers:
def __init__(self, auth: AuthService, site_root: Path):
self.auth = auth
self.site_root = Path(site_root)
def _clear_cookie(self) -> str:
return build_set_cookie("", max_age=0, secure=self.auth.cfg.cookie_secure)
def _same_origin(self, headers: dict[str, str]) -> bool:
return is_same_origin(headers, self.auth.cfg.public_host)
# ── вход ──────────────────────────────────────────────────────────────
def login_page(self, cookie: str | None, *, error: str = "", login: str = "", status: int = 200,
headers: dict[str, str] | None = None) -> HttpResult:
if self.auth.authenticate(cookie):
return _redirect("/admin/")
return _page(render("login.html.j2", error=error, login=login), status, headers)
def login_submit(self, login: str, password: str, request_headers: dict[str, str], ip: str) -> HttpResult:
if not self._same_origin(request_headers):
return _page("Недопустимый источник запроса", 403)
try:
cookie = self.auth.login(login, password, ip)
except AuthError as exc:
if exc.code == "throttled":
minutes = max(1, (exc.retry_after or 60) // 60 + 1)
return self.login_page(None, error=f"Слишком много попыток. Повторите через {minutes} мин.",
login=login, status=429, headers={"Retry-After": str(exc.retry_after or 60)})
return self.login_page(None, error="Неверный логин или пароль", login=login, status=401)
value = build_set_cookie(cookie, max_age=self.auth.cookie_max_age, secure=self.auth.cfg.cookie_secure)
return _redirect("/admin/", [value])
def logout(self, cookie: str | None, csrf: str, request_headers: dict[str, str], ip: str) -> HttpResult:
principal = self.auth.authenticate(cookie)
if principal is None:
return _redirect("/admin/login", [self._clear_cookie()])
if not self._same_origin(request_headers) or not self.auth.verify_csrf(principal, csrf):
return _page("Недопустимый запрос", 403)
self.auth.logout(principal, ip)
return _redirect("/admin/login", [self._clear_cookie()])
# ── обзор ─────────────────────────────────────────────────────────────
def dashboard(self, cookie: str | None) -> HttpResult:
principal = self.auth.authenticate(cookie)
if principal is None:
return _redirect("/admin/login")
ctx: dict = {"login": principal.login, "csrf": self.auth.csrf_token(principal),
"site_error": "", "site_name": "", "pages": [], "collections": [],
"errors": 0, "warnings": 0}
try:
reg = load_site(self.site_root)
report = Report()
table = build_route_table(reg, report)
report.extend(validate_workspace(reg, table))
report.extend(validate_release(reg, table))
routes = {r.page.id: r.route for r in table.values() if r.page}
ctx.update(
site_name=reg.site.name, errors=len(report.errors), warnings=len(report.warnings),
pages=[{"title": p.title, "status": p.status, "route": routes.get(p.id, "—")}
for p in sorted(reg.pages.values(), key=lambda x: routes.get(x.id, ""))],
collections=[{"name": c.name, "total": len(reg.entries.get(c.id, [])),
"published": sum(e.status == "published" for e in reg.entries.get(c.id, []))}
for c in reg.collections.values()],
)
except EngineError as exc:
ctx["site_error"] = str(exc)
return _page(render("dashboard.html.j2", **ctx))
def static_css(self) -> HttpResult:
return HttpResult(200, read_static("admin.css"), "text/css; charset=utf-8",
headers={"Cache-Control": "public, max-age=3600", "X-Content-Type-Options": "nosniff"})
+21
View File
@@ -0,0 +1,21 @@
"""Рендер шаблонов админки: обычный Jinja с автоэкранированием (не окружение сайта)."""
from __future__ import annotations
from pathlib import Path
from jinja2 import Environment, FileSystemLoader, StrictUndefined
ADMIN_DIR = Path(__file__).resolve().parent
_env = Environment(
loader=FileSystemLoader(ADMIN_DIR / "templates"), autoescape=True,
undefined=StrictUndefined, trim_blocks=True, lstrip_blocks=True,
)
def render(name: str, **ctx) -> str:
return _env.get_template(name).render(**ctx)
def read_static(name: str) -> str:
return (ADMIN_DIR / "static" / name).read_text(encoding="utf-8")
+50
View File
@@ -0,0 +1,50 @@
"""FastAPI-адаптер для `AdminHandlers`. Не запускался в песочнице без сети: только компиляция.
Обработчики синхронные (`def`): хеш scrypt считается около 100 мс, и FastAPI вынесет их в пул потоков.
За обратным прокси `request.client.host` — адрес прокси, тогда ограничение попыток по IP
работает как общее; доверие к X-Forwarded-For нужно включать явно (задача M2).
"""
from __future__ import annotations
from ...services.auth import COOKIE_NAME
from .handlers import AdminHandlers, HttpResult
def create_admin_router(handlers: AdminHandlers):
from fastapi import APIRouter, Form, Request, Response
router = APIRouter(prefix="/admin")
def adapt(result: HttpResult) -> Response:
response = Response(content=result.body, status_code=result.status, media_type=result.content_type)
for key, value in result.headers.items():
response.headers[key] = value
for cookie in result.cookies:
response.headers.append("set-cookie", cookie)
return response
def client_ip(request: Request) -> str:
return request.client.host if request.client else "unknown"
@router.get("/login")
def login_page(request: Request):
return adapt(handlers.login_page(request.cookies.get(COOKIE_NAME)))
@router.post("/login")
def login_submit(request: Request, login: str = Form(""), password: str = Form("")):
return adapt(handlers.login_submit(login, password, dict(request.headers), client_ip(request)))
@router.post("/logout")
def logout(request: Request, csrf: str = Form("")):
return adapt(handlers.logout(request.cookies.get(COOKIE_NAME), csrf, dict(request.headers), client_ip(request)))
@router.get("/")
def dashboard(request: Request):
return adapt(handlers.dashboard(request.cookies.get(COOKIE_NAME)))
@router.get("/static/admin.css")
def admin_css():
return adapt(handlers.static_css())
return router
@@ -0,0 +1,19 @@
:root { --c-primary: #0b5fff; --c-border: #dcdfe6; --c-muted: #667085; }
* { box-sizing: border-box; }
body { margin: 0; font: 15px/1.5 system-ui, sans-serif; color: #1b1f24; background: #f7f8fa; }
.login { max-width: 22rem; margin: 12vh auto; padding: 1.5rem; background: #fff; border: 1px solid var(--c-border); border-radius: .6rem; }
.login h1 { font-size: 1.2rem; margin: 0 0 1rem; }
label { display: grid; gap: .25rem; margin-bottom: .8rem; font-size: .9rem; color: var(--c-muted); }
input[type=text], input[type=password] { padding: .55rem .6rem; font: inherit; border: 1px solid var(--c-border); border-radius: .4rem; }
button { padding: .55rem 1rem; font: inherit; color: #fff; background: var(--c-primary); border: 0; border-radius: .4rem; cursor: pointer; }
.error { padding: .6rem .8rem; color: #8a1c1c; background: #fdecec; border-radius: .4rem; }
.bar { display: flex; align-items: center; gap: .8rem; padding: .6rem 1rem; background: #fff; border-bottom: 1px solid var(--c-border); }
.bar form { margin: 0; }
.spacer { flex: 1; }
.content { max-width: 60rem; margin: 1.5rem auto; padding: 0 1rem; }
table { width: 100%; border-collapse: collapse; background: #fff; }
th, td { padding: .5rem .7rem; text-align: left; border-bottom: 1px solid var(--c-border); }
.status { padding: .1rem .5rem; border-radius: 1rem; font-size: .8rem; background: #eef0f4; }
.status-published { background: #e3f6e8; }
.status-draft { background: #fff4d6; }
.summary { color: var(--c-muted); }
@@ -0,0 +1,13 @@
<!doctype html>
<html lang='ru'>
<head>
<meta charset='utf-8'>
<meta name='viewport' content='width=device-width, initial-scale=1'>
<meta name='robots' content='noindex, nofollow'>
<title>{% block title %}Админка{% endblock %}</title>
<link rel='stylesheet' href='/admin/static/admin.css'>
</head>
<body>
{% block body %}{% endblock %}
</body>
</html>
@@ -0,0 +1,44 @@
{% extends 'base.html.j2' %}
{% block title %}Обзор — админка{% endblock %}
{% block body %}
<header class='bar'>
<strong>Админка</strong>
<span class='spacer'></span>
<span>{{ login }}</span>
<form method='post' action='/admin/logout'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<button type='submit'>Выйти</button>
</form>
</header>
<main class='content'>
{% if site_error %}
<p class='error' role='alert'>Сайт не загружен: {{ site_error }}</p>
{% else %}
<h1>{{ site_name }}</h1>
<p class='summary'>
Страниц: {{ pages|length }} · ошибок проверки: {{ errors }} · предупреждений: {{ warnings }}
</p>
<h2>Страницы</h2>
<table>
<thead><tr><th>Страница</th><th>Адрес</th><th>Статус</th></tr></thead>
<tbody>
{% for p in pages %}
<tr>
<td>{{ p.title }}</td>
<td><code>{{ p.route }}</code></td>
<td><span class='status status-{{ p.status }}'>{{ p.status }}</span></td>
</tr>
{% endfor %}
</tbody>
</table>
<h2>Коллекции</h2>
<ul>
{% for c in collections %}
<li>{{ c.name }}: опубликовано {{ c.published }} из {{ c.total }}</li>
{% else %}
<li>Коллекций нет</li>
{% endfor %}
</ul>
{% endif %}
</main>
{% endblock %}
@@ -0,0 +1,17 @@
{% extends 'base.html.j2' %}
{% block title %}Вход — админка{% endblock %}
{% block body %}
<main class='login'>
<h1>Вход в админку</h1>
{% if error %}<p class='error' role='alert'>{{ error }}</p>{% endif %}
<form method='post' action='/admin/login'>
<label>Логин
<input type='text' name='login' value='{{ login }}' autocomplete='username' required autofocus>
</label>
<label>Пароль
<input type='password' name='password' autocomplete='current-password' required>
</label>
<button type='submit'>Войти</button>
</form>
</main>
{% endblock %}
+23 -5
View File
@@ -1,20 +1,30 @@
"""Фабрика приложения. M0–M1: health и раздача `dist/current` для разработки.
"""Фабрика приложения. Админка подключается, только если задана конфигурация входа.
Дальше: `POST /forms/{id}` и outbox (M2), админка `web/admin/` (M2–M3), превью по токену
`/_preview/<token>/` (M1), MCP на `/mcp/` (M3). В production статику отдаёт nginx.
Переменные окружения: SITE_ROOT, SITE_DIST, SITE_STATE_DIR (по умолчанию SITE_ROOT/.engine),
SITE_ADMIN_LOGIN, SITE_ADMIN_PASSWORD_HASH, SITE_SECRET_KEY, SITE_COOKIE_SECURE, SITE_SESSION_HOURS,
SITE_PUBLIC_HOST. Без них `/admin/` отдаёт 404, и это сознательно: нет пароля — нет входа.
Не запускалось в песочнице без сети (нужен `pip install site-engine[server]`).
"""
from __future__ import annotations
import logging
import os
from pathlib import Path
log = logging.getLogger("site_engine")
def create_app():
from fastapi import FastAPI, HTTPException
from fastapi.staticfiles import StaticFiles
app = FastAPI(title="Site Engine")
from ..services.auth import AuthConfig, AuthService, ConfigError
from .admin.handlers import AdminHandlers
from .admin.routes import create_admin_router
app = FastAPI(title="Site Engine", docs_url=None, redoc_url=None, openapi_url=None)
root = Path(os.environ.get("SITE_ROOT", "site"))
dist = Path(os.environ.get("SITE_DIST", "dist"))
@app.get("/healthz")
@@ -25,6 +35,14 @@ def create_app():
def submit_form(form_id: str) -> None:
raise HTTPException(status_code=501, detail="приём заявок появится в M2 (ADR-003)")
if (dist / "current").exists():
try:
cfg = AuthConfig.from_env()
except ConfigError as exc:
log.warning("админка отключена: %s", exc)
else:
state_dir = Path(os.environ.get("SITE_STATE_DIR", root / ".engine"))
app.include_router(create_admin_router(AdminHandlers(AuthService(cfg, state_dir), root)))
if (dist / "current").exists(): # маршруты выше имеют приоритет над раздачей статики
app.mount("/", StaticFiles(directory=dist / "current", html=True), name="site")
return app
+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()