195 lines
8.0 KiB
Python
195 lines
8.0 KiB
Python
"""Web settings and password verification, without desktop imports or disk reads."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import base64
|
||
from dataclasses import dataclass, field
|
||
import hashlib
|
||
import hmac
|
||
import ipaddress
|
||
import os
|
||
from pathlib import Path
|
||
import re
|
||
import secrets
|
||
from typing import Mapping
|
||
from urllib.parse import urlsplit
|
||
|
||
|
||
DEFAULT_DATA_DIR = Path(__file__).resolve().parents[1] / "local_state" / "ranch_web"
|
||
DEFAULT_HOST = "127.0.0.1"
|
||
DEFAULT_PORT = 8765
|
||
COOKIE_NAME = "ranch_web_session"
|
||
_HASH_PREFIX = "pbkdf2_sha256$"
|
||
|
||
|
||
def is_loopback(host: str) -> bool:
|
||
if host.lower() == "localhost":
|
||
return True
|
||
try:
|
||
address = ipaddress.ip_address(host)
|
||
if isinstance(address, ipaddress.IPv6Address) and address.ipv4_mapped:
|
||
return address.ipv4_mapped.is_loopback
|
||
return address.is_loopback
|
||
except ValueError:
|
||
return False
|
||
|
||
|
||
def normalize_host(value: str) -> str:
|
||
"""Accept a hostname / IP literal, never URLs, ports or wildcard patterns."""
|
||
candidate = value.strip().lower()
|
||
if candidate.startswith("[") and candidate.endswith("]"):
|
||
candidate = candidate[1:-1]
|
||
try:
|
||
return str(ipaddress.ip_address(candidate))
|
||
except ValueError:
|
||
pass
|
||
if len(candidate) > 253 or not re.fullmatch(
|
||
r"[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*",
|
||
candidate,
|
||
):
|
||
raise ValueError("允许的主机必须是明确的域名或 IP 地址,不能包含通配符或端口")
|
||
return candidate
|
||
|
||
|
||
def normalize_origin(value: str) -> str:
|
||
parsed = urlsplit(value)
|
||
if (
|
||
parsed.scheme not in {"http", "https"}
|
||
or not parsed.hostname
|
||
or parsed.username is not None
|
||
or parsed.password is not None
|
||
or parsed.path not in {"", "/"}
|
||
or parsed.query
|
||
or parsed.fragment
|
||
):
|
||
raise ValueError("允许的来源必须是明确的 http 或 https 来源")
|
||
host = normalize_host(parsed.hostname)
|
||
try:
|
||
port = parsed.port
|
||
except ValueError:
|
||
raise ValueError("允许的来源端口无效") from None
|
||
if port is not None and not 1 <= port <= 65535:
|
||
raise ValueError("允许的来源端口无效")
|
||
authority = f"[{host}]" if ":" in host else host
|
||
if port is not None and port != (443 if parsed.scheme == "https" else 80):
|
||
authority += f":{port}"
|
||
return f"{parsed.scheme}://{authority}"
|
||
|
||
|
||
def _hash_parts(encoded: str) -> tuple[int, bytes, bytes]:
|
||
try:
|
||
algorithm, raw_iterations, salt, digest = encoded.split("$")
|
||
iterations = int(raw_iterations)
|
||
expected = base64.b64decode(digest, validate=True)
|
||
if (
|
||
algorithm != "pbkdf2_sha256"
|
||
or not 100_000 <= iterations <= 2_000_000
|
||
or not 8 <= len(salt) <= 128
|
||
or len(expected) != 32
|
||
):
|
||
raise ValueError
|
||
return iterations, salt.encode("utf-8"), expected
|
||
except (ValueError, TypeError):
|
||
raise ValueError("管理密码哈希格式无效") from None
|
||
|
||
|
||
def hash_password(password: str, *, iterations: int = 600_000) -> str:
|
||
if not password or len(password) > 1024 or not 100_000 <= iterations <= 2_000_000:
|
||
raise ValueError("密码或哈希迭代次数无效")
|
||
salt = secrets.token_hex(16)
|
||
digest = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode(), iterations)
|
||
return f"{_HASH_PREFIX}{iterations}${salt}${base64.b64encode(digest).decode('ascii')}"
|
||
|
||
|
||
def verify_password(password: str, configured: str) -> bool:
|
||
if configured.startswith(_HASH_PREFIX):
|
||
iterations, salt, expected = _hash_parts(configured)
|
||
candidate = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations)
|
||
return hmac.compare_digest(candidate, expected)
|
||
# Equal-length digests also permit non-ASCII passwords with compare_digest.
|
||
return hmac.compare_digest(
|
||
hashlib.sha256(password.encode("utf-8")).digest(),
|
||
hashlib.sha256(configured.encode("utf-8")).digest(),
|
||
)
|
||
|
||
|
||
def _env_bool(value: str, name: str) -> bool:
|
||
normalized = value.strip().lower()
|
||
if normalized in {"1", "true", "yes", "on"}:
|
||
return True
|
||
if normalized in {"0", "false", "no", "off", ""}:
|
||
return False
|
||
raise ValueError(f"{name} 必须是布尔值")
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class WebConfig:
|
||
host: str = DEFAULT_HOST
|
||
port: int = DEFAULT_PORT
|
||
data_dir: Path = DEFAULT_DATA_DIR
|
||
password: str = field(default="", repr=False)
|
||
password_hash: str = field(default="", repr=False)
|
||
allowed_hosts: tuple[str, ...] = ()
|
||
allowed_origins: tuple[str, ...] = ()
|
||
secure_cookie: bool = False
|
||
session_ttl: int = 43_200
|
||
max_body_bytes: int = 1_048_576
|
||
|
||
def __post_init__(self) -> None:
|
||
object.__setattr__(self, "host", normalize_host(self.host))
|
||
object.__setattr__(self, "data_dir", Path(self.data_dir).expanduser().absolute())
|
||
object.__setattr__(self, "allowed_hosts", tuple(normalize_host(h) for h in self.allowed_hosts))
|
||
object.__setattr__(self, "allowed_origins", tuple(normalize_origin(o) for o in self.allowed_origins))
|
||
if type(self.port) is not int or not 1 <= self.port <= 65535:
|
||
raise ValueError("监听端口必须在 1–65535 之间")
|
||
if type(self.session_ttl) is not int or not 60 <= self.session_ttl <= 2_592_000:
|
||
raise ValueError("管理会话有效期必须在 60–2592000 秒之间")
|
||
if type(self.max_body_bytes) is not int or not 1024 <= self.max_body_bytes <= 16_777_216:
|
||
raise ValueError("请求正文上限必须在 1 KiB–16 MiB 之间")
|
||
if self.password and self.password_hash:
|
||
raise ValueError("管理密码和管理密码哈希只能配置一个")
|
||
if self.password_hash:
|
||
_hash_parts(self.password_hash)
|
||
elif self.password.startswith(_HASH_PREFIX):
|
||
_hash_parts(self.password)
|
||
if not is_loopback(self.host) and not self.credential:
|
||
raise ValueError("非本机绑定必须设置 RANCH_WEB_PASSWORD 或 RANCH_WEB_PASSWORD_HASH")
|
||
# Public proxy hostnames must never silently enable the local password bypass.
|
||
if not self.credential and any(not is_loopback(h) for h in self.allowed_hosts):
|
||
raise ValueError("允许远程域名访问时必须设置 RANCH_WEB_PASSWORD 或 RANCH_WEB_PASSWORD_HASH")
|
||
if not self.credential and any(not is_loopback(urlsplit(o).hostname or "") for o in self.allowed_origins):
|
||
raise ValueError("允许远程来源访问时必须设置管理密码")
|
||
|
||
@property
|
||
def credential(self) -> str:
|
||
return self.password_hash or self.password
|
||
|
||
@property
|
||
def access_mode(self) -> str:
|
||
return "password" if self.credential else "local"
|
||
|
||
@property
|
||
def trusted_hosts(self) -> frozenset[str]:
|
||
hosts = {"localhost", "127.0.0.1", "::1", *self.allowed_hosts}
|
||
if self.host not in {"0.0.0.0", "::"}:
|
||
hosts.add(self.host)
|
||
return frozenset(hosts)
|
||
|
||
@classmethod
|
||
def from_env(cls, env: Mapping[str, str] | None = None, **overrides) -> WebConfig:
|
||
values = os.environ if env is None else env
|
||
settings = {
|
||
"host": values.get("RANCH_WEB_HOST", DEFAULT_HOST),
|
||
"port": int(values.get("RANCH_WEB_PORT", DEFAULT_PORT)),
|
||
"data_dir": values.get("RANCH_WEB_DATA_DIR", DEFAULT_DATA_DIR),
|
||
"password": values.get("RANCH_WEB_PASSWORD", ""),
|
||
"password_hash": values.get("RANCH_WEB_PASSWORD_HASH", ""),
|
||
"allowed_hosts": tuple(h.strip() for h in values.get("RANCH_WEB_ALLOWED_HOSTS", "").split(",") if h.strip()),
|
||
"allowed_origins": tuple(o.strip() for o in values.get("RANCH_WEB_ALLOWED_ORIGINS", "").split(",") if o.strip()),
|
||
"secure_cookie": _env_bool(values.get("RANCH_WEB_SECURE_COOKIE", ""), "RANCH_WEB_SECURE_COOKIE"),
|
||
"session_ttl": int(values.get("RANCH_WEB_SESSION_TTL", 43_200)),
|
||
"max_body_bytes": int(values.get("RANCH_WEB_MAX_BODY_BYTES", 1_048_576)),
|
||
}
|
||
settings.update(overrides)
|
||
return cls(**settings)
|