"""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)