Files
myrzx_bot/ranch_web/config.py
T

205 lines
8.6 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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} 必须是布尔值")
def normalize_base_path(value: str) -> str:
"""Allow only an empty prefix or slash-separated, plain URL segments."""
if not isinstance(value, str) or (value and not re.fullmatch(r"/[A-Za-z0-9_-]+(?:/[A-Za-z0-9_-]+)*", value)):
raise ValueError("RANCH_WEB_BASE_PATH must be empty or /segment[/segment...] using letters, digits, _ and -")
return value
@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
base_path: str = ""
def __post_init__(self) -> None:
object.__setattr__(self, "base_path", normalize_base_path(self.base_path))
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)),
"base_path": values.get("RANCH_WEB_BASE_PATH", ""),
}
settings.update(overrides)
return cls(**settings)