Files
myrzx_bot/ranch_web/store.py
T

325 lines
13 KiB
Python

"""Web-only atomic storage, portable encrypted credentials and role sessions.
Nothing here reads the desktop workspace or its DPAPI records. The key and
encrypted records must be backed up together. Losing a key is an error, never an
excuse to replace it and silently discard remembered sessions.
"""
from __future__ import annotations
from dataclasses import asdict
from datetime import datetime, timezone
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import threading
import uuid
from cryptography.fernet import Fernet, InvalidToken
from ranch_assistant.api import Session
def _identifier(value, length=32):
if not isinstance(value, str) or not re.fullmatch(r"[a-f0-9]{%d}" % length, value):
raise ValueError("无效的账号或会话编号")
return value
def _unlinked(path):
path = Path(path)
if path.is_symlink() or getattr(path, "is_junction", lambda: False)():
raise ValueError("Web 状态目录含链接路径,已停止操作")
return path
def atomic_json(path, value):
"""Write a complete JSON record with owner-only permissions and replacement."""
path = _unlinked(path)
path.parent.mkdir(parents=True, exist_ok=True)
temporary = path.with_name(path.name + "." + uuid.uuid4().hex + ".tmp")
descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
try:
with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
json.dump(value, stream, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
stream.flush()
os.fsync(stream.fileno())
temporary.replace(path)
finally:
temporary.unlink(missing_ok=True)
def session_identity(session):
owner = session.account_id or session.server_url.rstrip("/")
raw = json.dumps([owner, session.channel, session.platform, session.server_id, session.role_id], separators=(",", ":"))
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
class WorkspaceLock:
"""Hold the Web data root exclusively, on Windows as well as Linux."""
def __init__(self, root):
self.path = _unlinked(Path(root) / "workspace.lock")
self.stream = self.path.open("a+b")
self.stream.seek(0)
if self.path.stat().st_size == 0:
self.stream.write(b"\0")
self.stream.flush()
self.stream.seek(0)
try:
if os.name == "nt":
import msvcrt
msvcrt.locking(self.stream.fileno(), msvcrt.LK_NBLCK, 1)
else:
import fcntl
fcntl.flock(self.stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
self.stream.close()
raise RuntimeError("Web 数据目录已由另一个服务实例使用") from None
def close(self):
if self.stream.closed:
return
try:
self.stream.seek(0)
if os.name == "nt":
import msvcrt
msvcrt.locking(self.stream.fileno(), msvcrt.LK_UNLCK, 1)
else:
import fcntl
fcntl.flock(self.stream.fileno(), fcntl.LOCK_UN)
finally:
self.stream.close()
class WebStore:
def __init__(self, root):
candidate = Path(root).absolute()
for parent in (candidate, *candidate.parents):
_unlinked(parent)
self.root = candidate.resolve()
self.root.mkdir(parents=True, exist_ok=True)
self.lock = threading.RLock()
self.workspace_lock = WorkspaceLock(self.root)
try:
self.profiles = _unlinked(self.root / "profiles")
self.profiles.mkdir(exist_ok=True)
self.fernet = Fernet(self._key())
except Exception:
self.workspace_lock.close()
raise
def _key(self):
path = _unlinked(self.root / "web.key")
if not path.exists():
if next(self.profiles.glob("*/credentials.fernet"), None) or next(self.profiles.glob("*/sessions/*.fernet"), None):
raise ValueError("缺少 Web 加密密钥,无法恢复已保存登录;请恢复原密钥")
try:
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
except FileExistsError:
pass
else:
with os.fdopen(descriptor, "wb") as stream:
stream.write(Fernet.generate_key())
stream.flush()
os.fsync(stream.fileno())
os.chmod(path, 0o600)
try:
raw = path.read_bytes()
Fernet(raw)
except (OSError, ValueError):
raise ValueError("Web 加密密钥无法读取,请恢复原密钥") from None
return raw
def profile(self, identifier):
folder = _unlinked(self.profiles / _identifier(identifier))
if folder.resolve() != folder or self.profiles.resolve() != self.profiles:
raise ValueError("账号工作区路径不合法")
return folder
def accounts(self):
with self.lock:
path = _unlinked(self.root / "accounts.json")
if not path.exists():
return []
value = json.loads(path.read_text(encoding="utf-8"))
if not isinstance(value, dict) or value.get("schema") != 1 or not isinstance(value.get("accounts"), list):
raise ValueError("Web 账号目录格式错误")
entries, seen = [], set()
for row in value["accounts"]:
if not isinstance(row, dict) or set(row) != {"id", "label", "demo"}:
raise ValueError("Web 账号目录格式错误")
identifier = _identifier(row["id"])
if identifier in seen or not isinstance(row["label"], str) or type(row["demo"]) is not bool:
raise ValueError("Web 账号目录格式错误")
self.profile(identifier)
seen.add(identifier)
entries.append(dict(row))
return entries
def save_accounts(self, entries):
with self.lock:
atomic_json(self.root / "accounts.json", {"schema": 1, "accounts": entries})
def secure(self, identifier):
return SecureStore(self, identifier)
def role_root(self, identifier, identity=None, *, demo=False):
folder = self.profile(identifier)
if identity is not None:
roles = _unlinked(folder / "roles")
result = _unlinked(roles / _identifier(identity, 64))
else:
result = _unlinked(folder / ("demo" if demo else "disconnected"))
if not result.resolve().is_relative_to(folder):
raise ValueError("角色工作区路径不合法")
result.mkdir(parents=True, exist_ok=True)
return result
def load_config(self, folder):
path = _unlinked(Path(folder) / "settings.json")
if not path.exists():
return None
value = json.loads(path.read_text(encoding="utf-8"))
if not isinstance(value, dict) or value.get("schema") != 1 or type(value.get("revision")) is not int or not isinstance(value.get("config"), dict):
raise ValueError("Web 策略文件格式错误")
return value
def save_config(self, folder, config, revision):
atomic_json(Path(folder) / "settings.json", {"schema": 1, "revision": revision, "config": config})
def remove_profile(self, identifier):
"""Validate the whole tree before deleting only this UUID profile."""
folder = self.profile(identifier)
if not folder.exists():
return
for current, directories, files in os.walk(folder, followlinks=False):
for name in (*directories, *files):
target = _unlinked(Path(current) / name)
if not target.resolve().is_relative_to(folder):
raise ValueError("账号工作区含越界路径,已停止删除")
shutil.rmtree(folder)
def close(self):
self.workspace_lock.close()
class SecureStore:
"""Account-scoped Fernet records; public session entries are explicit fields."""
def __init__(self, workspace, identifier):
self.workspace = workspace
self.profile_root = workspace.profile(identifier)
self.profile_root.mkdir(exist_ok=True)
self.folder = _unlinked(self.profile_root / "sessions")
self.lock = threading.RLock()
def _write(self, path, value):
encrypted = self.workspace.fernet.encrypt(json.dumps(value, ensure_ascii=False, allow_nan=False).encode("utf-8"))
atomic_json(path, {"schema": 1, "scheme": "fernet", "protected": encrypted.decode("ascii")})
def _read(self, path):
try:
record = json.loads(_unlinked(path).read_text(encoding="utf-8"))
if record.get("schema") != 1 or record.get("scheme") != "fernet":
raise ValueError
return json.loads(self.workspace.fernet.decrypt(record["protected"].encode("ascii")))
except (InvalidToken, KeyError, ValueError, TypeError, AttributeError, UnicodeError):
raise ValueError("Web 加密记录无法读取,请恢复正确密钥或重新登录") from None
def save_credentials(self, account, password, remember=True):
with self.lock:
self._write(self.profile_root / "credentials.fernet", {"remember": bool(remember),
"account": str(account) if remember else "", "password": str(password) if remember else ""})
def load_credentials(self):
with self.lock:
path = self.profile_root / "credentials.fernet"
if not path.exists():
return False, "", ""
value = self._read(path)
if type(value.get("remember")) is not bool or not isinstance(value.get("account"), str) or not isinstance(value.get("password"), str):
raise ValueError("Web 登录记录格式错误")
return value["remember"], value["account"], value["password"]
def device(self):
with self.lock:
path = self.profile_root / "device.fernet"
if path.exists():
return self._read(path)["device_id"]
device = str(uuid.uuid4())
self._write(path, {"device_id": device})
return device
def set_active(self, identity):
with self.lock:
path = self.profile_root / "active.fernet"
if identity is None:
_unlinked(path).unlink(missing_ok=True)
else:
self._write(path, {"session_id": _identifier(identity, 64)})
def active(self):
with self.lock:
path = self.profile_root / "active.fernet"
if not path.exists():
return None
return _identifier(self._read(path)["session_id"], 64)
def save(self, session, label):
if not session.token or not session.server_url or not session.role_id:
return None
identity = session_identity(session)
with self.lock:
self.folder.mkdir(exist_ok=True)
path = self.folder / (identity + ".fernet")
value = asdict(session)
if path.exists():
previous = self._read(path)["session"]
# Counters are never rolled back, including by an imported/stale object.
for field in ("reqid", "reqsid"):
value[field] = max(int(value[field]), int(previous.get(field, 0)))
setattr(session, field, value[field])
self._write(path, {"session_id": identity, "label": str(label),
"saved_at": datetime.now(timezone.utc).isoformat(timespec="seconds"), "session": value})
return identity
def entries(self):
with self.lock:
_unlinked(self.folder)
result = []
for path in self.folder.glob("*.fernet"):
_identifier(path.stem, 64)
value = self._read(path)
if value.get("session_id") != path.stem:
raise ValueError("Web 会话编号不一致")
result.append({field: value[field] for field in ("session_id", "label", "saved_at")})
return sorted(result, key=lambda row: row["saved_at"], reverse=True)
def load(self, identifier):
identifier = _identifier(identifier, 64)
with self.lock:
value = self._read(_unlinked(self.folder) / (identifier + ".fernet"))
session = Session(**value["session"])
if session_identity(session) != identifier or not session.token or not session.role_id:
raise ValueError("保存的账号、区服或角色信息不一致")
return session
def remove(self, identifier):
with self.lock:
self.load(identifier)
(self.folder / (identifier + ".fernet")).unlink()
def forget(self):
with self.lock:
_unlinked(self.folder)
for path in self.folder.glob("*.fernet"):
_identifier(path.stem, 64)
_unlinked(path)
for path in self.folder.glob("*.fernet"):
path.unlink()
_unlinked(self.profile_root / "credentials.fernet").unlink(missing_ok=True)
_unlinked(self.profile_root / "active.fernet").unlink(missing_ok=True)